knave 0.14.0

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

use super::constructor::Constructor;
use super::constructor_tag::ConstructorTag;
use crate::core::BindingId;

#[derive(Clone)]
pub(super) enum Witness {
    Wild,
    Variant {
        owner: BindingId,
        index: usize,
        arguments: Vec<Witness>,
    },
    Struct {
        owner: BindingId,
        arguments: Vec<Witness>,
    },
    Bool(bool),
}

impl Witness {
    pub(super) fn built_by(constructor: &Constructor, arguments: &[Witness]) -> Self {
        match constructor.tag() {
            ConstructorTag::Variant { owner, index } => Witness::Variant {
                owner,
                index,
                arguments: arguments.to_vec(),
            },
            ConstructorTag::Struct(owner) => Witness::Struct {
                owner,
                arguments: arguments.to_vec(),
            },
            ConstructorTag::Bool(value) => Witness::Bool(value),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::Witness;
    use crate::core::BindingId;
    use crate::types::coverage::constructor::Constructor;
    use crate::types::coverage::constructor_tag::ConstructorTag;

    struct WitnessFixture {
        owner: BindingId,
    }

    impl WitnessFixture {
        fn new() -> Self {
            Self {
                owner: BindingId::from_index(3),
            }
        }

        fn built_by(tag: ConstructorTag) -> Witness {
            Witness::built_by(&Constructor::new(tag, Vec::new()), &[Witness::Wild])
        }
    }

    #[test]
    fn a_variant_constructor_builds_a_variant_witness_with_its_arguments() {
        let fixture = WitnessFixture::new();
        let witness = WitnessFixture::built_by(ConstructorTag::Variant {
            owner: fixture.owner,
            index: 2,
        });
        assert!(matches!(
            witness,
            Witness::Variant { owner, index: 2, arguments } if owner == fixture.owner && arguments.len() == 1
        ));
    }

    #[test]
    fn a_struct_constructor_builds_a_struct_witness_with_its_arguments() {
        let fixture = WitnessFixture::new();
        let witness = WitnessFixture::built_by(ConstructorTag::Struct(fixture.owner));
        assert!(matches!(
            witness,
            Witness::Struct { owner, arguments } if owner == fixture.owner && arguments.len() == 1
        ));
    }

    #[test]
    fn a_bool_constructor_builds_its_bool() {
        assert!(matches!(
            WitnessFixture::built_by(ConstructorTag::Bool(false)),
            Witness::Bool(false)
        ));
    }
}