prismqueer 0.1.0

The spectral-triple substrate — five operations (focus, project, split, shift, settle), the Prism trait, zero deps. The foundation.
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

//! Integration tests for #[derive(Lambda)] and Composable.

#[cfg(feature = "lambda")]
mod tests {
    extern crate prismqueer;

    use prismqueer::lambda::{Composable, Lambda};
    use prismqueer::oid::Addressable;
    use prismqueer::DeriveLambda;
    use prismqueer::Oid;

    #[derive(DeriveLambda)]
    #[oid("@parse")]
    struct Parse;

    #[derive(DeriveLambda)]
    #[oid("@resolve")]
    struct Resolve;

    #[derive(DeriveLambda)]
    #[oid("@emit")]
    struct Emit;

    #[derive(DeriveLambda)]
    #[oid("@properties")]
    struct Properties;

    #[test]
    fn parse_is_composable() {
        let lambda: Lambda<String> = Parse.into();
        assert!(matches!(lambda, Lambda::Abs(_)));
    }

    #[test]
    fn parse_oid_from_derive() {
        assert_eq!(Parse.oid(), Oid::hash(b"@parse"));
    }

    #[test]
    fn parse_display() {
        assert_eq!(format!("{}", Parse), "@parse");
    }

    #[test]
    fn resolve_display() {
        assert_eq!(format!("{}", Resolve), "@resolve");
    }

    #[test]
    fn parse_then_resolve() {
        let pipeline: Lambda<String> = Parse.then(Resolve);
        assert!(matches!(pipeline, Lambda::Abs(_)));
        assert!(!pipeline.oid().is_dark());
    }

    #[test]
    fn craft_pipeline_composes_four_phases() {
        let craft: Lambda<String> = Parse.then(Resolve).then(Properties).then(Emit);
        assert!(!craft.oid().is_dark());
    }

    #[test]
    fn same_composition_same_oid() {
        let a: Lambda<String> = Parse.then(Resolve);
        let b: Lambda<String> = Parse.then(Resolve);
        assert_eq!(a.oid(), b.oid());
    }

    #[test]
    fn different_composition_different_oid() {
        let a: Lambda<String> = Parse.then(Resolve);
        let b: Lambda<String> = Parse.then(Emit);
        assert_ne!(a.oid(), b.oid());
    }

    #[test]
    fn named_lambda_display() {
        assert_eq!(format!("{}", Parse), "@parse");
        assert_eq!(format!("{}", Resolve), "@resolve");
    }

    #[test]
    fn order_matters() {
        let ab: Lambda<String> = Parse.then(Resolve);
        let ba: Lambda<String> = Resolve.then(Parse);
        assert_ne!(ab.oid(), ba.oid());
    }

    #[test]
    fn apply_to_wraps_in_apply() {
        let input = Lambda::<String>::bind(Oid::hash(b"source"));
        let applied = Parse.apply_to(input);
        assert!(matches!(applied, Lambda::Apply(_)));
    }

    #[test]
    fn into_lambda_is_named_identity() {
        let lambda: Lambda<String> = Parse.into();
        // Should be Abs(@parse, Bind(@parse))
        if let Lambda::Abs(a) = &lambda {
            assert_eq!(a.param, Oid::hash(b"@parse"));
            if let Lambda::Bind(b) = a.body.as_ref() {
                assert_eq!(b.name, Oid::hash(b"@parse"));
            } else {
                panic!("expected Bind body");
            }
        } else {
            panic!("expected Abs");
        }
    }
}