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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

use super::*;
use crate::{infer::Lift, TypeVisitor};
use itertools::Itertools;
use std::fmt;

#[derive(Debug, Clone)]
pub struct Function<D: TypeData> {
    pub ptypes: TypesBuf<D>,
    pub returns: Type<D>,
}

#[derive(Debug, Clone)]
pub struct ForeignFunction<D: TypeData> {
    pub generics: Generics<D>,
    pub function: Function<D>,
}

impl<D: TypeData> TypeVisitor<D> for Function<D> {
    fn map_types<F: FnMut(D::Meta, &TypeKind<D>, TypesBuf<D>) -> Type<D>>(&self, mut f: F) -> Self {
        Function {
            ptypes: self.ptypes.iter().map(|t| t.map_type(&mut f)).collect(),
            returns: self.returns.map_type(&mut f),
        }
    }
}

impl<D: TypeData> Function<D> {
    /// Lift to a standalone instantiable function.
    ///
    /// Any types pending to be infered in the parameters or return type will be lifted into
    /// generics implicitly declared in `generics`
    pub fn to_foreign(&self, tenv: &TEnv<D>, mut generics: Generics<D>) -> ForeignFunction<D> {
        let ptypes = tenv.concretify_types(&self.ptypes);
        let returns = tenv.concretify_type(&self.returns);

        let mut lifter = Lift::new(tenv, &mut generics);

        ForeignFunction {
            function: Function {
                ptypes: lifter.types(ptypes),
                returns: lifter.type_(returns),
            },
            generics,
        }
    }
}

impl<D: TypeData> ForeignFunction<D> {
    pub fn with_extra_generics(mut self, generics: &Generics<D>) -> Self {
        self.generics.extend(generics);
        self
    }

    pub fn instantiate(&self, tenv: &mut TEnv<D>) -> InstantiatedFunction<D> {
        let mapping = self.generics.to_mapping(tenv);
        InstantiatedFunction {
            mapping,
            function: &self.function,
        }
    }
}

impl<D: TypeData> Function<D> {
    pub fn new(ptypes: TypesBuf<D>, returns: Type<D>) -> Self {
        Function { ptypes, returns }
    }
}

pub struct InstantiatedFunction<'a, D: TypeData> {
    mapping: Mapping<D>,
    function: &'a Function<D>,
}

impl<'a, D: TypeData> InstantiatedFunction<'a, D> {
    pub fn function(&self) -> Function<D> {
        let ptypes = self.mapping.apply_types(&self.function.ptypes);
        let returns = self.mapping.apply_type(&self.function.returns);
        Function { ptypes, returns }
    }

    pub fn mapping_mut(&mut self) -> &mut Mapping<D> {
        &mut self.mapping
    }
}

impl<D: TypeData> Function<D> {
    pub fn call(
        &self,
        tenv: &mut TEnv<D>,
        traits: &TraitIndex<D>,
        params: &Types<D>,
    ) -> Result<(), CallError<D>> {
        let expected = &self.ptypes;

        let got = params.len();
        let exp = params.len();

        if got != exp {
            return Err(CallError::ParamCount { got, exp });
        }

        let mut tctx = TypeContext::new(tenv, traits, ErrorHandler::Expensive);
        let mut errors = Vec::new();
        for pid in 0..got {
            if let Err(err) = tctx.check(&params[pid], &expected[pid]) {
                errors.push((pid, err));
            }
        }

        if errors.is_empty() {
            Ok(())
        } else {
            Err(CallError::CheckErrors(errors))
        }
    }
}

#[derive(Clone, Debug)]
pub enum CallError<D: TypeData> {
    CheckErrors(Vec<(usize, check::Error<D>)>),
    ParamCount { got: usize, exp: usize },
}

impl<D: TypeData> fmt::Display for ForeignFunction<D> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        if self.generics.is_empty() {
            self.function.fmt(f)
        } else {
            write!(f, "∀{}. {}", &self.generics, &self.function)
        }
    }
}

impl<D: TypeData> fmt::Display for Function<D> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "({} -> {})",
            self.ptypes.iter().format(", "),
            &self.returns
        )
    }
}