kari 0.1.0

An embeddable programming language, writting in and for Rust
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
144
145
146
147
148
149
150
151
152
153
154
155
156

use std::{
    fmt,
    hash::{
        Hash,
        Hasher,
    },
};

use crate::data::{
    token::Span,
    value::{
        self,
        Value,
    },
};


pub trait Typed {
    fn get_type(&self) -> &'static dyn Type;
}


pub trait Type : fmt::Debug {
    fn name(&self) -> &'static str;
}

impl PartialEq for dyn Type {
    fn eq(&self, other: &Self) -> bool {
        self.name() == other.name()
            || self.name() == Any.name()
            || other.name() == Any.name()
    }
}

impl Eq for dyn Type {}

impl Hash for dyn Type {
    fn hash<H>(&self, _: &mut H) where H: Hasher {
        // All types must have the same hash, because all types are equal to
        // `Any`. This meant we can't feed anything into the hasher here.
    }
}


pub trait Downcast : Type {
    type Value: Value;

    fn downcast_raw(&self, _: value::Any) -> Result<Self::Value, value::Any>;

    fn downcast(&self, any: value::Any) -> Result<Self::Value, TypeError> {
        self.downcast_raw(any)
            .map_err(|any|
                TypeError {
                    expected: self.name(),
                    actual:   any,
                }
            )
    }
}


#[derive(Debug)]
pub struct Any;

impl Type for Any {
    fn name(&self) -> &'static str { "any" }
}

impl Downcast for Any {
    type Value = value::Any;

    fn downcast_raw(&self, any: value::Any) -> Result<Self::Value, value::Any> {
        Ok(any)
    }
}


macro_rules! impl_type {
    (
        $(
            $ty:ident,
            $name:expr;
        )*
    )
        =>
    {
        impl Typed for value::Any {
            fn get_type(&self) -> &'static dyn Type {
                match self.kind {
                    $(value::Kind::$ty(_) => &$ty,)*
                }
            }
        }

        $(
            #[derive(Debug)]
            pub struct $ty;

            impl Type for $ty {
                fn name(&self) -> &'static str { $name }
            }

            impl Downcast for $ty {
                type Value = value::$ty;

                fn downcast_raw(&self, any: value::Any)
                    -> Result<Self::Value, value::Any>
                {
                    match any.kind {
                        value::Kind::$ty(value) => {
                            Ok(Value::new(value, any.span))
                        }
                        _ => {
                            Err(any)
                        }
                    }
                }
            }
        )*
    }
}

impl_type!(
    Bool,   "bool";
    Float,  "float";
    Number, "number";
    List,   "list";
    Scope,  "scope";
    String, "string";
    Symbol, "symbol";
    Word,   "word";
);


#[derive(Debug)]
pub struct TypeError {
    pub expected: &'static str,
    pub actual:   value::Any,
}

impl TypeError {
    pub fn spans<'r>(&'r self, spans: &mut Vec<&'r Span>) {
        spans.push(&self.actual.span);
    }
}

impl fmt::Display for TypeError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "Type error: Expected `{}`, found `{}`",
            self.expected,
            self.actual.kind,
        )
    }
}