knave 0.14.22

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

use super::boxed_payload::BoxedPayload;
use super::payload_position::PayloadPosition;
use super::ty::Type;
use super::type_declarations::TypeDeclarations;
use crate::core::BindingId;

#[derive(Clone, Copy)]
pub(super) struct VariantPayloads<'a> {
    types: &'a TypeDeclarations,
}

impl<'a> VariantPayloads<'a> {
    pub(super) fn new(types: &'a TypeDeclarations) -> Self {
        Self { types }
    }

    pub(super) fn variant_count(&self, owner: BindingId) -> Option<usize> {
        self.types
            .enums
            .get(owner)
            .map(|definition| definition.variants.len())
    }

    pub(super) fn visible(&self, owner: BindingId, index: usize, arguments: &[Type]) -> Vec<Type> {
        self.types
            .enums
            .get(owner)
            .and_then(|definition| definition.instantiated_payload(index, arguments))
            .unwrap_or_default()
            .into_iter()
            .enumerate()
            .map(|(payload, stored)| {
                let position = PayloadPosition {
                    variant: index,
                    payload,
                };
                self.seen_by_pattern(BoxedPayload::at(owner, position), stored)
            })
            .collect()
    }

    pub(super) fn seen_by_pattern(&self, payload: BoxedPayload, stored: Type) -> Type {
        match self.is_inferred_box(payload) {
            true => self.unboxed(&stored).clone(),
            false => stored,
        }
    }

    pub(super) fn written<'p>(&self, payload: BoxedPayload, stored: &'p Type) -> &'p Type {
        match self.is_inferred_box(payload) {
            true => self.unboxed(stored),
            false => stored,
        }
    }

    pub(super) fn is_inferred_box(&self, payload: BoxedPayload) -> bool {
        self.types.inferred_boxes.contains(&payload)
    }

    fn unboxed<'p>(&self, inferred_box: &'p Type) -> &'p Type {
        match inferred_box {
            Type::Named(binding, arguments) if Some(*binding) == self.types.box_binding => {
                match arguments.as_slice() {
                    [argument] => argument,
                    _ => panic!("an inferred box has one type argument"),
                }
            }
            _ => panic!("an inferred box is a box"),
        }
    }
}