lyte 0.1.0

Rust-like typesystem created for the Lumina project
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

use super::{Type, TypeData, TypeKind, TypesBuf};

pub trait TypeVisitor<D: TypeData> {
    fn map_types<F: FnMut(D::Meta, &TypeKind<D>, TypesBuf<D>) -> Type<D>>(&self, f: F) -> Self
    where
        Self: Sized;

    fn map_constr<F: FnMut(D::Meta, &TypeKind<D>) -> TypeKind<D>>(&self, mut f: F) -> Self
    where
        Self: Sized,
    {
        self.map_types(|meta, constr, params| Type {
            constr: f(meta.clone(), constr),
            meta,
            params,
        })
    }
}

impl<D: TypeData> Type<D> {
    pub fn map_constr<
        O: TypeData<Meta = D::Meta>,
        F: FnMut(D::Meta, &TypeKind<D>) -> TypeKind<O>,
    >(
        &self,
        f: &mut F,
    ) -> Type<O> {
        self.map_type(&mut |meta, constr, params| Type {
            constr: f(meta.clone(), constr),
            meta,
            params,
        })
    }

    pub fn map_type<O: TypeData, F: FnMut(D::Meta, &TypeKind<D>, Vec<Type<O>>) -> Type<O>>(
        &self,
        f: &mut F,
    ) -> Type<O> {
        let params = self.params.iter().map(|t| t.map_type(f)).collect();
        f(self.meta.clone(), &self.constr, params)
    }

    pub fn into_map_constr<O: TypeData<Meta = D::Meta>, F: FnMut(TypeKind<D>) -> TypeKind<O>>(
        self,
        f: &mut F,
    ) -> Type<O> {
        self.into_map_type(&mut |meta, constr, params| Type {
            meta,
            constr: f(constr),
            params,
        })
    }

    pub fn into_map_type<
        O: TypeData<Meta = D::Meta>,
        F: FnMut(D::Meta, TypeKind<D>, Vec<Type<O>>) -> Type<O>,
    >(
        self,
        f: &mut F,
    ) -> Type<O> {
        let params = self
            .params
            .into_iter()
            .map(|t| t.into_map_type(f))
            .collect();
        f(self.meta, self.constr, params)
    }

    pub fn substitute_self_and_meta(&self, impltor: &Type<D>, or_meta: D::Meta) -> Type<D> {
        self.map_type(&mut |_, constr, params| match constr {
            TypeKind::Self_ => {
                let mut type_ = impltor.clone();
                type_.params.extend(params);
                type_
            }
            _ => Type {
                constr: constr.clone(),
                params,
                meta: or_meta.clone(),
            },
        })
    }
}