knave 0.10.1

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

use super::definitions::LocalDefinitions;
use super::moved_values::MovedValues;
use crate::types::TypedLambda;

pub struct RepeatingBody {
    entry: MovedValues,
    carried: MovedValues,
}

impl RepeatingBody {
    pub fn enter(moved: &MovedValues) -> Self {
        Self {
            entry: moved.clone(),
            carried: MovedValues::default(),
        }
    }

    pub fn carry(&mut self, moved: &MovedValues) {
        self.carried.merge(moved.moved_since(&self.entry));
    }

    pub fn next_pass(mut self, lambda: &TypedLambda) -> Option<NextPass> {
        if self.carried.is_empty() {
            return None;
        }
        let own = LocalDefinitions::default().of(lambda);
        self.carried.retain(|binding| !own.contains(&binding));
        (!self.carried.is_empty()).then_some(NextPass {
            entry: self.entry,
            carried: self.carried,
        })
    }
}

pub struct NextPass {
    entry: MovedValues,
    carried: MovedValues,
}

impl NextPass {
    pub fn carried(&self) -> &MovedValues {
        &self.carried
    }

    pub fn moved_at_start(self) -> MovedValues {
        let mut moved = self.entry;
        moved.merge(self.carried);
        moved
    }
}