blob: ec6b177577e83239f21ed5b41facc5cae2b401ef (
plain)
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
|
# neb
### an attempt at a language
## ideas
- **Lisp-y**: I hope you like parentheses!
- **Strongly typed**: types are Good, and could enable future compilation
- **We <3 Linux**: strong support for pipelines and shell-ing out
- **Immutable variables**: mutability is scary and makes for strange bugs
- **Pure functions**: side effects are also scary
## things that (hopefully) work
### housekeeping
- TODO `(exit [[status :int]]) => :bool`
### io
- `(print [out :string]) => :bool ; print to stdout`
- TODO `(print-all [strings :list]) => :bool ; a list of strings`
### math
- `(+ [arg :number] [many :number]) => :number`
- `(- [arg :number] [many :number]) => :number`
- `(* [arg :number] [many :number]) => :number`
- `(/ [num :number] [denom :number]) => :number`
### string
- TODO `(concat [arg :string] [many :string]) => :string`
### flow control
- `(if [cond :bool] [t-branch :any|:expr] [[f-branch :any|:expr]]) => :any`
- `(for-count [count :int] [many :expr]) => :any ; creates 'idx' variable with loop count`
- `(| [first :expr] [many :expr]) => :any ; creates 'items' variable`
- `(branch ([cond1 :bool] [expr1 :any]) [([condN: :bool] [exprN :any])]) => :any`
### type checking TODO
- `(string? [arg :any]) => :bool`
- `(int? [arg :any]) => :bool`
- `(float? [arg :any]) => :bool`
- `(number? [arg :any]) => :bool ; returns #true for :int or :float`
- `(bool? [arg :any]) => :bool`
### type conversion TODO
- `(int->string [arg :int]) => :string`
- `(float->string [arg :float]) => :string`
- `(number->string [arg :number]) => :string`
- `(bool->string [arg :bool]) => :string`
- `(->string [arg :literal]) => :string ; works for all literals`
### global variables
- `(def [name :string] [value :expr]) => ?`
### shell TODO
- `($ [command :string]) => :list ; doesn't support pipes, first item is return code`
- `($| [commands :list]) => :bool ; pipes together multiple shell commands`
### functions
- `(lambda (args) (expr1) (expr2) ... (exprN)) => :any
### other
- pretty much nothing else
## TODO (this section may be incomplete)
### types
- [ ] revisit type system when i understand *gestures broadly*
### parsing
- [x] build an AST like a real person (sorta?)
### math
- [ ] division (float)
- [ ] division (int)
- [ ] mod (int)
- [ ] exponent
### strings
- [x] concat
- [ ] substring
- [ ] lower/uppercase
### flow control
- [x] if
- [x] if with empty else
- [ ] branch
- [x] pipe
### lists
- [x] lex
- [x] parse
- [x] evaluate
### other structure things
- [ ] generic struct?
- [ ] dict?
### symbols
- [x] define
- [x] access
### shell
- [x] call out
- [x] pipe
|
