knave 0.10.2

A small Lisp 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

use rustc_hash::FxHashMap;

use crate::core::BindingId;
use crate::types::{Type, TypedProgram};

#[derive(Default)]
pub struct ShrunkParameters {
    parameters: FxHashMap<BindingId, Type>,
    declarations: FxHashMap<BindingId, Vec<(usize, Type)>>,
}

impl ShrunkParameters {
    pub fn new(
        parameters: FxHashMap<BindingId, Type>,
        declarations: FxHashMap<BindingId, Vec<(usize, Type)>>,
    ) -> Self {
        Self {
            parameters,
            declarations,
        }
    }

    pub fn parameters(&self) -> &FxHashMap<BindingId, Type> {
        &self.parameters
    }

    pub fn rewrite_declarations(&self, program: &mut TypedProgram) {
        for definition in program
            .modules
            .iter_mut()
            .flat_map(|module| module.definitions.iter_mut())
        {
            for (position, shrunk) in self
                .declarations
                .get(&definition.binding)
                .into_iter()
                .flatten()
            {
                Self::replace_parameter(&mut definition.scheme.body, *position, shrunk);
            }
        }
    }

    fn replace_parameter(function: &mut Type, position: usize, shrunk: &Type) {
        if let Type::Function(_, parameters, _) = function
            && let Some(parameter) = parameters.get_mut(position)
        {
            *parameter = shrunk.clone();
        }
    }
}