blob: af17b74e3e570a63141d937e68683f7521bf0f1e (
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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
|
# Function
---
```text
INVOCATION : UNKNOWN | SYNC | ASYNC
STATELESS : INCOMPLETE | NATIVE | NATIVE_INLINE | PROCESS | GENERATOR | REGEX_GENERATOR
STATEFUL : TASK | ITERATOR | CLOSURE | BOUND | REGEX
FLAGS : INVOCATION | STATELESS | STATEFUL
Function[[FLAGS]; Body; RETURN_TYPE; Collection[VAR_LIST; TYPE.SYMBOL]]
```
## Type Body Object Definitions
```c
typedef struct {
kpl_ptr body, return_type, var_list;
} kpl_type_body_function;
```
# Alias
```text
Fn[Generic.T; Collection[VAR_TREE_LIST; TYPE.SYMBOL]] `alias Function[[FLAGS]; STATE; List; Generic.T; Collection[VAR_TREE_LIST; TYPE.SYMBOL]]
```
# Inline Definition
```text
([x; y] x + y) // Fn[Any; Any.x; Any.y]
([I64.x; y] x + y) // Fn[Any; I64.x; Any.y]
```
# Function Classes
## Unknown
Placeholder before evaluation
## Incomplete
A function with an incomplete type, type checking occurs at invocation
## Native
Native C code that can be called async
## Native Inline
Native C code that cannot be called async
## Task
A queue-able function in a process or iterator
## Process
A list of tasks with state
## Generator
A function for creating an iterator
## Regex Generator
A function for creating Regular Expression matcher
## Iterator
A task creator with state, cannot take arguments, can be called until done
## Closure
A task creator with state that can take arguments
## Bound
A function with some arguments already set
## Regex
Invoked regular expression matcher
# Returning
## \`return
## Transient Union Return Chaining
# Iterating
## \`yield
Yielding wraps the value in the transient union `Next`
Return `Void` to stop iteration
```text
fn : ([n] @ 1 < n {[x] `yield 2 * x; n +: 1 } )
it : fn `sync 10
// invoking
@ it {[v] `log v } // 2 4 6 8 10 12 14 16 18 20
// same as above
@ {
# `sync it {
.value {[v] `log v }
.done { `break }
}
}
```
## Range `..`
# Calling
## \`async
Asynchronous call
```text
task : `async fn
value : `await task
```
## \`sync
Synchronous call
If the callee is a process, an inline await with async is used
```text
fn `sync args // can be turned into `await fn `async args
```
# Binding
## \`bind
|
