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

use super::*;
use itertools::Itertools;
use std::fmt;

#[derive(Debug, Clone)]
pub struct Sum<D: TypeData> {
    pub identifier: D::Concrete,
    pub variants: Vec<TypesBuf<D>>,
}

impl<D: TypeData> Sum<D> {
    pub fn new(identifier: D::Concrete, variants: Vec<TypesBuf<D>>) -> Self {
        Self { identifier, variants }
    }

    pub fn to_foreign(self, generics: Generics<D>) -> ForeignSum<D> {
        ForeignSum { generics, sum: self }
    }
}

#[derive(Debug, Clone)]
pub struct ForeignSum<D: TypeData> {
    pub generics: Generics<D>,
    pub sum: Sum<D>,
}

pub struct InstantiatedSum<'a, D: TypeData> {
    mapping: Mapping<D>,
    pub sum: &'a Sum<D>,
}

impl<D: TypeData> ForeignSum<D> {
    pub fn instantiate<'s>(&'s self, tenv: &mut TEnv<D>) -> InstantiatedSum<'s, D> {
        let mapping = self.generics.to_mapping(tenv);
        InstantiatedSum { mapping, sum: &self.sum }
    }
}

impl<'a, D: TypeData> InstantiatedSum<'a, D> {
    pub fn variant(&self, variant: usize) -> TypesBuf<D> {
        let variant = self
            .sum
            .variants
            .get(variant)
            .expect("variant does not exist");

        self.mapping.apply_types(variant)
    }

    pub fn constructor(&self, ret_meta: D::Meta, variant: usize) -> Function<D> {
        let params = self.variant(variant);
        let returns = self.to_type(ret_meta);

        Function::new(params, returns)
    }

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

impl_to_type!(InstantiatedSum<'a, D>, sum);

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

impl<D: TypeData> fmt::Display for Sum<D> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "{} = {}",
            self.identifier,
            self.variants
                .iter()
                .format_with(" | ", |params, f| f(&format_args!(
                    "_ {}",
                    params.iter().format(" ")
                )))
        )
    }
}