knave 0.14.8

A Lisp programming language for humans and agents that infers types and ownership and compiles to readable 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

use rustc_hash::FxHashMap;

use super::ty::{GenericId, Type};

pub struct GenericBinding {
    bound: FxHashMap<GenericId, Type>,
}

impl GenericBinding {
    pub fn of(declared: &Type, used: &Type) -> Self {
        Self::of_each([declared], [used])
    }

    pub fn of_each<'t>(
        declared: impl IntoIterator<Item = &'t Type>,
        used: impl IntoIterator<Item = &'t Type>,
    ) -> Self {
        Self {
            bound: BindingWalk::of_each(declared, used).finish(),
        }
    }

    pub fn substitute(&self, declared: &[Type]) -> Vec<Type> {
        declared
            .iter()
            .map(|parameter| parameter.substitute(&self.bound))
            .collect()
    }

    pub fn into_bound(self) -> FxHashMap<GenericId, Type> {
        self.bound
    }
}

struct BindingWalk {
    exact: FxHashMap<GenericId, Type>,
    through_reference: FxHashMap<GenericId, Type>,
}

impl BindingWalk {
    fn of(declared: &Type, used: &Type) -> Self {
        Self::of_each([declared], [used])
    }

    fn of_each<'t>(
        declared: impl IntoIterator<Item = &'t Type>,
        used: impl IntoIterator<Item = &'t Type>,
    ) -> Self {
        let mut walk = Self {
            exact: FxHashMap::default(),
            through_reference: FxHashMap::default(),
        };
        walk.bind_each(declared, used);
        walk
    }

    fn bind(&mut self, declared: &Type, used: &Type) {
        match declared {
            Type::Generic(generic) => {
                self.exact.entry(*generic).or_insert_with(|| used.clone());
            }
            Type::Ref(_, inner) | Type::Mut(_, inner) => {
                self.absorb_behind_reference(Self::of(inner, used.referent()));
            }
            _ => self.bind_parts(declared, used),
        }
    }

    fn absorb_behind_reference(&mut self, binding: Self) {
        for (generic, used) in binding.finish() {
            self.through_reference.entry(generic).or_insert(used);
        }
    }

    fn finish(self) -> FxHashMap<GenericId, Type> {
        let mut bound = self.through_reference;
        bound.extend(self.exact);
        bound
    }

    fn bind_parts(&mut self, declared: &Type, used: &Type) {
        if declared.shares_head_with(used) {
            self.bind_each(declared.parts(), used.parts());
        }
    }

    fn bind_each<'t>(
        &mut self,
        declared: impl IntoIterator<Item = &'t Type>,
        used: impl IntoIterator<Item = &'t Type>,
    ) {
        for (declared, used) in declared.into_iter().zip(used) {
            self.bind(declared, used);
        }
    }
}