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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

use rustc_hash::FxHashMap;

use crate::core::BindingId;
use crate::types::{TypedBodyItem, TypedControl, TypedExpr, TypedExprKind, TypedLambda, TypedLeaf};

pub struct LetAliases<'e> {
    values: FxHashMap<BindingId, &'e TypedExpr>,
}

pub struct LetAlias<'e> {
    pub alias: BindingId,
    pub target: BindingId,
    pub bound: &'e TypedExpr,
}

impl<'e> LetAliases<'e> {
    pub fn in_expressions(expressions: &[&'e TypedExpr]) -> Self {
        Self {
            values: expressions
                .iter()
                .flat_map(|expr| Self::body_items(expr))
                .filter_map(|item| match item {
                    TypedBodyItem::Let(binder, value) => Some((binder.binding, value)),
                    TypedBodyItem::Expr(_) => None,
                })
                .collect(),
        }
    }

    pub fn unannotated_in(value: &'e TypedExpr) -> Self {
        Self {
            values: value
                .let_bindings()
                .filter(|(binder, _)| !binder.annotated)
                .map(|(binder, bound)| (binder.binding, bound))
                .collect(),
        }
    }

    pub fn functions_in(expressions: &[&'e TypedExpr]) -> Vec<(BindingId, &'e TypedLambda)> {
        expressions
            .iter()
            .flat_map(|expr| Self::body_items(expr))
            .filter_map(|item| match item {
                TypedBodyItem::Let(binder, value) => match &value.kind {
                    TypedExprKind::Fn(lambda) => Some((binder.binding, lambda.as_ref())),
                    _ => None,
                },
                TypedBodyItem::Expr(_) => None,
            })
            .collect()
    }

    fn body_items(expr: &'e TypedExpr) -> &'e [TypedBodyItem] {
        match &expr.kind {
            TypedExprKind::Fn(lambda) => &lambda.body.items,
            TypedExprKind::Control(TypedControl::Block(block)) => &block.items,
            _ => &[],
        }
    }

    pub fn resolve(&self, value: &'e TypedExpr) -> &'e TypedExpr {
        let mut resolved = value;
        while let TypedExprKind::Leaf(TypedLeaf::Local(binding)) = resolved.kind
            && let Some(bound) = self.values.get(&binding)
        {
            resolved = bound;
        }
        resolved
    }

    pub fn entries(&self) -> impl Iterator<Item = (BindingId, &'e TypedExpr)> + '_ {
        self.values
            .iter()
            .map(|(binding, bound)| (*binding, *bound))
    }

    pub fn links(&self, alias: BindingId) -> Vec<LetAlias<'e>> {
        let mut links = Vec::new();
        let mut current = alias;
        while let Some(bound) = self.values.get(&current)
            && let TypedExprKind::Leaf(TypedLeaf::Local(target)) = bound.kind
        {
            links.push(LetAlias {
                alias: current,
                target,
                bound,
            });
            current = target;
        }
        links
    }

    pub fn origins(&self) -> FxHashMap<BindingId, BindingId> {
        self.values
            .keys()
            .map(|alias| (*alias, self.origin(*alias)))
            .filter(|(alias, origin)| alias != origin)
            .collect()
    }

    fn origin(&self, alias: BindingId) -> BindingId {
        let mut origin = alias;
        while let Some(TypedExprKind::Leaf(TypedLeaf::Local(bound))) =
            self.values.get(&origin).map(|value| &value.kind)
        {
            origin = *bound;
        }
        origin
    }
}