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
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
|
# Functions for code generation
When running calculations, you can generate the code including [S-expressions](/docs/s_expressions) nodes. This uses a mechanism for packing the code in the [resource](../types/special.md). After building the code, you can insert it into the main program using the [EvaluateCode](#evaluatecode) function. For debugging purposes, you can convert the code to a string using the [FormatCode](#formatcode) function.
Possible node types in S-expressions that can be used for code generation:
* An atom is an untyped string of zero or more characters.
* A list is a sequence of zero or more nodes. It corresponds to the `tuple` type in SQL.
* A call of a built-in function consists of a name expressed by an atom and a sequence of zero or more nodes that are arguments to this function.
* Lambda function declaration consists of declaring the names of arguments and a node that is the root of the body for this lambda function.
* The lambda function argument is a node that can only be used inside the body of the lambda function.
* World is a special node that labels I/O operations.
The S-expressions nodes form a directed graph. Atoms are always leaf nodes, because they cannot contain child nodes.
In the text representation, S-expressions have the following format:
* Atom: `'"foo"`. The apostrophe character (') denotes quoting of the next line that is usually enclosed in quotation marks.
* List: `'("foo" "bar")`. The apostrophe character (') denotes that there will be no function call in parentheses.
* Calling the built-in function: `(foo "bar")`. The first item inside the brackets is the mandatory name of the function followed by the function arguments.
* Declaring a lambda function: `(lambda '(x y) (+ x y))`. The `lambda` keyword is followed by a list of argument names and then by the body of the lambda function.
* The lambda function argument is `x`. Unlike an atom, a string without an apostrophe character (') references a name in the current scope. When declaring a lambda function, the names of arguments are added to the body's visibility scope, and, if needed, the name is hidden from the global scope.
* The `world`.
## FormatCode
Serializing the code as [S-expressions](/docs/s_expressions). The code must not contain free arguments of functions, hence, to serialize the lambda function code, you must pass it completely, avoiding passing individual expressions that might contain lambda function arguments.
#### Examples
```yql
SELECT FormatCode(AtomCode("foo"));
-- (
-- (return '"foo")
-- )
```
## WorldCode
Build a code node with the `world` type.
#### Examples
```yql
SELECT FormatCode(WorldCode());
-- (
-- (return world)
-- )
```
## AtomCode
Build a code node with the `atom` type from a string passed to the argument.
#### Examples
```yql
SELECT FormatCode(AtomCode("foo"));
-- (
-- (return '"foo")
-- )
```
## ListCode
Build a code node with the `list` type from a set of nodes or lists of code nodes passed to arguments. In this case, lists of arguments are built in as separately listed code nodes.
#### Examples
```yql
SELECT FormatCode(ListCode(
AtomCode("foo"),
AtomCode("bar")));
-- (
-- (return '('"foo" '"bar"))
-- );
SELECT FormatCode(ListCode(AsList(
AtomCode("foo"),
AtomCode("bar"))));
-- (
-- (return '('"foo" '"bar"))
-- )
```
## FuncCode
Build a code node with the `built-in function call` from a string with the function name and a set of nodes or lists of code nodes passed to arguments. In this case, lists of arguments are built in as separately listed code nodes.
#### Examples
```yql
SELECT FormatCode(FuncCode(
"Baz",
AtomCode("foo"),
AtomCode("bar")));
-- (
-- (return (Baz '"foo" '"bar"))
-- )
SELECT FormatCode(FuncCode(
"Baz",
AsList(
AtomCode("foo"),
AtomCode("bar"))));
-- (
-- (return (Baz '"foo" '"bar"))
-- )
```
## LambdaCode
You can build a code node with the `lambda function declaration` type from:
* [a Lambda function](../syntax/expressions.md#lambda), if you know the number of arguments in advance. In this case, the nodes of the `argument` type will be passed as arguments to this lambda function.
* The number of arguments and a [lambda function](../syntax/expressions.md#lambda) with one argument. In this case, a list of nodes of the `argument`type will be passed as an argument to this lambda function.
#### Examples
```yql
SELECT FormatCode(LambdaCode(($x, $y) -> {
RETURN FuncCode("+", $x, $y);
}));
-- (
-- (return (lambda '($1 $2) (+ $1 $2)))
-- )
SELECT FormatCode(LambdaCode(2, ($args) -> {
RETURN FuncCode("*", Unwrap($args[0]), Unwrap($args[1]));
}));
-- (
-- (return (lambda '($1 $2) (* $1 $2)))
-- )
```
## EvaluateCode
Substituting the code node passed in the argument, into the main program code.
#### Examples
```yql
SELECT EvaluateCode(FuncCode("Int32", AtomCode("1"))); -- 1
$lambda = EvaluateCode(LambdaCode(($x, $y) -> {
RETURN FuncCode("+", $x, $y);
}));
SELECT $lambda(1, 2); -- 3
```
## ReprCode
Substituting the code node representing the result of evaluating an expression passed in the argument, into the main program.
#### Examples
```yql
$add3 = EvaluateCode(LambdaCode(($x) -> {
RETURN FuncCode("+", $x, ReprCode(1 + 2));
}));
SELECT $add3(1); -- 4
```
## QuoteCode
Substituting into the main program the code node that represents an expression or a [lambda function](../syntax/expressions.md#lambda) passed in the argument. If free arguments of lambda functions were found during the substitution, they are calculated and substituted into the code as in the [ReprCode](#reprcode) function.
#### Examples
```yql
$lambda = ($x, $y) -> { RETURN $x + $y };
$makeClosure = ($y) -> {
RETURN EvaluateCode(LambdaCode(($x) -> {
RETURN FuncCode("Apply", QuoteCode($lambda), $x, ReprCode($y))
}))
};
$closure = $makeClosure(2);
SELECT $closure(1); -- 3
```
|
