LanguageStandard/SymbolList at master · LoLi-Lang/LanguageStandard · GitHub

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
LoLi Standard Symbol List

Types:                      Identifier
Object                      :OBJ
|---Number                  :NUM
    |---Integer             :INT
    |---Real Number         :REAL
    |---Ratio               :RAT
|---Symbol                  :SYM
|---Keyword                 :KEY
    |---Boolean             :BOOL
|---Function                :FN
    |---Lambda              :LAMBDA
    |---Primitve Procedure  :PROC
|---Cons                    :CONS
    |---Tuple               :TUP
        |---List            :LST
|---Character               :CHAR
|---String                  :STR
|---Error                   :ERR

The type will be denoted as:
:TYPE1 -> :TYPE2 -> ... -> OBJ -> TYPEn
which means:
(\\ :TYPEn ( (ARG1 :TYPE1) (ARG2 :TYPE2) ... (ARGn-1 :TYPEn-1) ) EXP)
and:
[:TYPE]
which means:
List of objects of TYPE
and:
[:TYPE1 -> :TYPE2 -> ... -> :TYPEn]
means:
( (OBJ1 OBJ2 ... OBJn) ... )

Standard Symbols:
Symbol:     Type ID:
T           :SYM

NIL         :SYM

:TRUE       :BOOL

:FALSE      :BOOL

DEF         :SYM -> :OBJ -> :OBJ
    (DEF SYM VALUE) => VALUE or ERROR

DEFT        :SYM -> :OBJ -> :KEY -> :OBJ
    (DEF SYM VALUE :TYPE) => VALUE or ERROR

SET!        :SYM -> :OBJ -> :OBJ
    (SET! SYM VALUE) => VALUE or ERROR

SETT!        :SYM -> :OBJ -> :KEY -> :OBJ
    (SETT! SYM VALUE :TYPE) => VALUE or ERROR

\\          [:KEY -> [:SYM | :SYM -> :KEY] -> :OBJ] -> :LAMBDA
    (\\ (:TYPE-1 (ARGS-1) EXP-1)
        (:TYPE-2 (ARGS-2) EXP-2)
        ...) => LAMBDA EXPRESSION

WITH        :SYM -> :OBJ -> :OBJ -> :OBJ
    (WITH SYM VALUE EXP) => RETURN OF EXP

LET         [:SYM -> :OBJ] -> :OBJ -> :OBJ
    (LET (BINDS) EXP) => RETURN OF EXP

QUOTE       :OBJ -> :OBJ
    (QUOTE OBJ) => OBJ

SAY         :SYM -> :KEY -> :OBJ -> :OBJ
    (SAY SYM :TYPE EXP) => RETURN OF EXP

ASSERT      [:SYM -> :KEY] -> :OBJ -> :OBJ
    (ASSERT (TYPE BINDS) EXP) => RETURN OF EXP

TYPE-OF     :SYM -> :SYM -> :OBJ -> :OBJ
    (TYPE-OF SYM1 SYM2 EXP) => RETURN OF EXP

TYPE-OF-R   [:SYM -> :SYM] -> :OBJ -> :OBJ
    (TYPE-OF ((SYM1 SYM2) (SYM3 SYM4) ... (SYMn SYMn+1)) EXP) => RETURN OF EXP

MAP         :FN -> :CONS -> :CONS
    (MAP FN LST) -> List of result

FOLD        :FN -> :CONS -> :OBJ
    (FOLD FN LST) => Result

FOLDR       :FN -> :CONS -> :OBJ
    (FOLDR FN LST) => Result

CONS        :OBJ -> :OBJ -> :CONS
    (CONS HEAD TAIL) => Cons Structure

HEAD        :CONS -> :OBJ
    (HEAD CONS) => Head

TAIL        :CONS -> :OBJ
    (TAIL CONS) => TAIL

TUPLE       :OBJ -> :OBJ -> ... -> :OBJ -> :TUP
    (TUPLE OBJ1 OBJ2 ... OBJn) => Tuple

LIST        :TYPEa -> :TYPEa -> ... -> :TYPEa -> :LST
    (LIST OBJ1 OBJ2 ... OBJn) => List

MATCH       :OBJ -> :OBJ -> :CONS
    (MATCH EXP1 EXP2) => Temp ENV

TMATCH      :OBJ -> :OBJ -> :CONS
    (TMATCH TYPE-EXP EXP) => Temp ENV