fungi-lang 0.1.63

Fungi: A typed, functional language for programs that name their cached dependency graphs
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


fgi_mod!{    
    fn vec_gen_range:(
        Thk[0] 0 Nat -> 0 F Vec Nat
    ) = {
        #n.
        {unsafe (1) trapdoor::vec_gen_range}
            n
    }

    fn vec_fold:(
        Thk[0] forallt a:type.
            0 Vec a -> 0 b ->
            0 (Thk[0] 0 a -> 0 b -> 0 F b) ->
            0 F b
    ) = {
        #v.#b.#f.
        {unsafe (3) trapdoor::vec_fold}
            v b f
    }

    fn vec_fold_rev:(
        Thk[0] forallt a:type.
            0 Vec a -> 0 b ->
            0 (Thk[0] 0 a -> 0 b -> 0 F b) ->
            0 F b
    ) = {
        #v.#b.#f.
        {unsafe (3) trapdoor::vec_fold_rev}
            v b f
    }

    fn vec_filter:(
        Thk[0] forallt a:type.
            0 Vec a ->
            0 (Thk[0] 0 a -> 0 F Bool) ->
            0 F Vec a
    ) = {
        #v.#f.
        {unsafe (2) trapdoor::vec_filter}
            v f
    }
    
    fn vec_map:(
        Thk[0] forallt (a,b):type.
            0 Vec a ->
            0 (Thk[0] 0 a -> 0 F b) ->
            0 F Vec b
    ) = {
        #v.#f.
        {unsafe (2) trapdoor::vec_map}
            v f
    }
}

mod trapdoor {
    // This code essentially extends the Fungi evaluator
    use crate::dynamics::{RtVal,ExpTerm};

    pub fn vec_gen_range(args:Vec<RtVal>) -> ExpTerm {
        // gen_range(count)
        match (&args[0], &args[1]) {
            _ => panic!("TODO")
        }
    }
    
    pub fn vec_filter(args:Vec<RtVal>) -> ExpTerm {
        // filter(vector, userfun)
        match (&args[0], &args[1]) {
            _ => panic!("TODO")
        }
    }
    
    pub fn vec_map(args:Vec<RtVal>) -> ExpTerm {
        // map(vector, userfun)
        match (&args[0], &args[1]) {
            _ => panic!("TODO")
        }
    }
    
    pub fn vec_fold(args:Vec<RtVal>) -> ExpTerm {
        // fold(vector, accum0, userfun)
        match (&args[0], &args[1], &args[2]) {
            _ => panic!("TODO")
        }
    }
    
    pub fn vec_fold_rev(args:Vec<RtVal>) -> ExpTerm {
        // fold_rev(vector, accum0, userfun)
        match (&args[0], &args[1], &args[2]) {
            _ => panic!("TODO")
        }
    }
}