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
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
|
<head>
<link href="../favicon.ico" rel="shortcut icon" type="image/x-icon"/>
<link href="../style.css" rel="stylesheet"/>
<title>Control flow in BQN</title>
</head>
<div class="nav">(<a href="https://github.com/mlochbaum/BQN">github</a>) / <a href="../index.html">BQN</a> / <a href="index.html">doc</a></div>
<h1 id="control-flow-in-bqn"><a class="header" href="#control-flow-in-bqn">Control flow in BQN</a></h1>
<p>BQN does not have ALGOL-style control structures. Instead, functional techniques can be used to control when code is evaluated. This page describes how BQN functionality can be used to emulate something more familiar to an imperative programmer.</p>
<p>Control structures here are always functions that act on lists of functions, although alternatives might be presented. This is because stranded functions can be formatted in a very similar way to blocks in curly-brace languages. However, there are many ways to write control flow, including simple operators and a mix of operators and more control-structure-like code. Implementing a control structure rarely takes much code with any method, so there are usually several simple ways to implement a given flow or a variation of it.</p>
<p>The surfeit of ways to write control structures could be a bit of an issue for reading BQN. My hope is that the community can eventually settle on a smaller set of standard forms to recommend so that you won't have to recognize all the variants given here. On the other hand, the cost of using specialized control structures is lower in a large project without too many contributors. In this case BQN's flexibility allows developers to adapt to the project's particular demands (for example, some programs use switch/case statements heavily but most do not).</p>
<p>The useful control structures introduced here are collected as shortened definitions below. <code><span class='Function'>While</span></code> uses the slightly more complicated implementation that avoids stack overflow, and <code><span class='Function'>DoWhile</span></code> and <code><span class='Function'>For</span></code> are written in terms of it in order to share this property. The more direct versions with linear stack use appear in the main text.</p>
<pre><span class='Function'>If</span> <span class='Gets'>โ</span> <span class='Brace'>{</span><span class='Function'>๐</span><span class='Modifier2'>โ</span><span class='Function'>๐</span><span class='String'>@</span><span class='Brace'>}</span><span class='Modifier'>ยด</span> <span class='Comment'># Also Repeat
</span><span class='Function'>IfElse</span> <span class='Gets'>โ</span> <span class='Brace'>{</span><span class='Value'>c</span><span class='Ligature'>โฟ</span><span class='Function'>T</span><span class='Ligature'>โฟ</span><span class='Function'>F</span><span class='Value'>:</span> <span class='Value'>c</span><span class='Modifier2'>โถ</span><span class='Function'>F</span><span class='Ligature'>โฟ</span><span class='Function'>T</span><span class='String'>@</span><span class='Brace'>}</span>
<span class='Function'>While</span> <span class='Gets'>โ</span> <span class='Brace'>{</span><span class='Value'>๐ฉ</span><span class='Brace'>{</span><span class='Function'>๐ฝ</span><span class='Modifier2'>โ</span><span class='Function'>๐พ</span><span class='Modifier2'>โ</span><span class='Function'>๐ฝ</span><span class='Modifier2'>_๐ฃ_</span><span class='Function'>๐พ</span><span class='Modifier2'>โ</span><span class='Function'>๐ฝ</span><span class='Modifier2'>โ</span><span class='Function'>๐พ</span><span class='Value'>๐ฉ</span><span class='Brace'>}</span><span class='Value'>๐จ</span><span class='String'>@</span><span class='Brace'>}</span><span class='Modifier'>ยด</span> <span class='Comment'># While 1โฟ{... to run forever
</span><span class='Function'>DoWhile</span> <span class='Gets'>โ</span> <span class='Brace'>{</span><span class='Function'>๐</span><span class='String'>@</span> <span class='Separator'>โ</span> <span class='Function'>While</span> <span class='Value'>๐จ</span><span class='Ligature'>โฟ</span><span class='Value'>๐ฉ</span><span class='Brace'>}</span><span class='Modifier'>ยด</span>
<span class='Function'>For</span> <span class='Gets'>โ</span> <span class='Brace'>{</span><span class='Function'>I</span><span class='Ligature'>โฟ</span><span class='Function'>C</span><span class='Ligature'>โฟ</span><span class='Function'>P</span><span class='Ligature'>โฟ</span><span class='Function'>A</span><span class='Value'>:</span> <span class='Function'>I</span><span class='String'>@</span> <span class='Separator'>โ</span> <span class='Function'>While</span><span class='Bracket'>โจ</span><span class='Function'>C</span><span class='Separator'>,</span><span class='Function'>P</span><span class='Modifier2'>โ</span><span class='Function'>A</span><span class='Bracket'>โฉ</span><span class='Brace'>}</span>
<span class='Comment'># Switch/case statements have many variations; these are a few
</span><span class='Function'>Match</span> <span class='Gets'>โ</span> <span class='Brace'>{</span><span class='Function'>๐</span><span class='Value'>๐จ</span><span class='Brace'>}</span><span class='Modifier'>ยด</span>
<span class='Function'>Select</span> <span class='Gets'>โ</span> <span class='Brace'>{</span><span class='Paren'>(</span><span class='Function'>โ</span><span class='Value'>๐ฉ</span><span class='Paren'>)</span><span class='Modifier2'>โถ</span><span class='Paren'>(</span><span class='Number'>1</span><span class='Function'>โ</span><span class='Value'>๐ฉ</span><span class='Paren'>)</span><span class='String'>@</span><span class='Brace'>}</span>
<span class='Function'>Switch</span> <span class='Gets'>โ</span> <span class='Brace'>{</span><span class='Value'>c</span><span class='Gets'>โ</span><span class='Function'>โ</span><span class='Value'>๐ฉ</span> <span class='Separator'>โ</span> <span class='Value'>m</span><span class='Ligature'>โฟ</span><span class='Value'>a</span><span class='Gets'>โ</span><span class='Function'><</span><span class='Modifier'>ห</span><span class='Function'>โ</span><span class='Modifier2'>โ</span><span class='Ligature'>โฟ</span><span class='Number'>2</span><span class='Function'>โฅ</span><span class='Number'>1</span><span class='Function'>โ</span><span class='Value'>๐ฉ</span> <span class='Separator'>โ</span> <span class='Paren'>(</span><span class='Function'>โ</span><span class='Value'>a</span><span class='Function'>โC</span><span class='Paren'>)</span><span class='Modifier2'>โถ</span><span class='Value'>m</span><span class='String'>@</span><span class='Brace'>}</span>
<span class='Function'>Test</span> <span class='Gets'>โ</span> <span class='Brace'>{</span><span class='Value'>fn</span><span class='Gets'>โ</span><span class='Brace'>{</span><span class='Function'>C</span><span class='Ligature'>โฟ</span><span class='Function'>A๐</span><span class='Value'>e:</span><span class='Function'>C</span><span class='Modifier2'>โถ</span><span class='Function'>A</span><span class='Ligature'>โฟ</span><span class='Function'>E</span><span class='Brace'>}</span><span class='Modifier'>ยด</span><span class='Value'>๐ฉ</span><span class='Separator'>โ</span><span class='Function'>Fn</span><span class='String'>@</span><span class='Brace'>}</span>
</pre>
<h2 id="blocks-and-functions"><a class="header" href="#blocks-and-functions">Blocks and functions</a></h2>
<p>Control structures are generally defined to work with blocks of code, which they might skip, or execute one or more times. This might sound like a BQN immediate block, which also consists of a sequence of code to execute, but immediate blocks are always executed as soon as they are encountered and can't be manipulated the way that blocks in imperative languages can. They're intended to be used with <a href="lexical.html">lexical scoping</a> as a tool for encapsulation. Instead, the main tool we will use to get control structures is the block function.</p>
<p>Using functions as blocks is a little outside their intended purpose, and the fact that they have to be passed an argument and are expected to use it will be a minor annoyance. The following conventions signal a function that ignores its argument and is called purely for the side effects:</p>
<ul>
<li>Pass <code><span class='String'>@</span></code> to a function that ignores its argument. It's a nice signal that nothing is happening and is easy to type.</li>
<li>A headerless function that doesn't use an argument will be interpreted as an immediate block by default. Start it with the line <code><span class='Value'>๐ค</span></code> to avoid this (it's an instruction to navel gaze: the function contemplates its self, but does nothing about it). Other options like <code><span class='Function'>๐</span><span class='Value'>:</span></code>, <code><span class='Function'>F</span><span class='Value'>:</span></code>, or <code><span class='Value'>๐ฉ</span></code> also work, but are more visually distracting.</li>
</ul>
<p>Even with these workarounds, BQN's "niladic" function syntax is quite lightweight, comparing favorably to a low-boilerplate language like Javascript.</p>
<pre><span class='Value'>fn</span> <span class='Function'>=</span> <span class='Paren'>()</span><span class='Function'>=></span><span class='Brace'>{</span><span class='Value'>m</span><span class='Function'>+=</span><span class='Number'>1</span><span class='Value'>;n*</span><span class='Function'>=</span><span class='Number'>2</span><span class='Brace'>}</span><span class='Value'>;</span> <span class='Value'>fn</span><span class='Paren'>()</span>
<span class='Function'>Fn</span> <span class='Gets'>โ</span> <span class='Brace'>{</span><span class='Value'>๐ค</span><span class='Separator'>โ</span> <span class='Value'>m</span><span class='Function'>+</span><span class='Gets'>โฉ</span><span class='Number'>1</span><span class='Separator'>,</span><span class='Value'>n</span><span class='Function'>ร</span><span class='Gets'>โฉ</span><span class='Number'>2</span><span class='Brace'>}</span><span class='Separator'>,</span> <span class='Function'>Fn</span> <span class='String'>@</span>
</pre>
<p>Control structures are called "statements" below to match common usage, but they are actually expressions, and return a value that might be used later.</p>
<h2 id="if"><a class="header" href="#if">If</a></h2>
<p>The if statement conditionally performs some action. It is similar to the Repeat (<code><span class='Modifier2'>โ</span></code>) modifier with a right operand returning a boolean: <code><span class='Function'>Fn</span><span class='Modifier2'>โ</span><span class='Function'>Cond</span> <span class='Value'>๐ฉ</span></code> gives <code><span class='Function'>Fn</span> <span class='Value'>๐ฉ</span></code> if <code><span class='Function'>Cond</span> <span class='Value'>๐ฉ</span></code> is <code><span class='Number'>1</span></code>, and returns <code><span class='Value'>๐ฉ</span></code> without calling <code><span class='Function'>Fn</span></code> if <code><span class='Function'>Cond</span> <span class='Value'>๐ฉ</span></code> is <code><span class='Number'>0</span></code>. Here is how we might make it behave like a control structure.</p>
<pre><span class='Brace'>{</span><span class='Value'>๐ค</span><span class='Separator'>โ</span><span class='Value'>a</span><span class='Function'>+</span><span class='Gets'>โฉ</span><span class='Number'>10</span><span class='Brace'>}</span><span class='Modifier2'>โ</span><span class='Paren'>(</span><span class='Value'>a</span><span class='Function'><</span><span class='Number'>10</span><span class='Paren'>)</span> <span class='String'>@</span>
</pre>
<p>The condition <code><span class='Value'>a</span><span class='Function'><</span><span class='Number'>10</span></code> is always evaluated, so there's no need to wrap it in a function. However, the function <code><span class='Brace'>{</span><span class='Value'>๐ค</span><span class='Separator'>โ</span><span class='Value'>a</span><span class='Function'><</span><span class='Number'>10</span><span class='Brace'>}</span></code> could be used in place of <code><span class='Paren'>(</span><span class='Value'>a</span><span class='Function'><</span><span class='Number'>10</span><span class='Paren'>)</span></code>, making the entire structure into a function that could be incorporated into other control structures.</p>
<p>In the example shown, the value <code><span class='Number'>10</span></code> appears in both the condition and the action, so it can be pulled out by using it as an argument. Depending on context this might be more or less clear.</p>
<pre><span class='Brace'>{</span><span class='Value'>a</span><span class='Function'>+</span><span class='Gets'>โฉ</span><span class='Value'>๐ฉ</span><span class='Brace'>}</span><span class='Modifier2'>โ</span><span class='Paren'>(</span><span class='Value'>a</span><span class='Modifier2'>โธ</span><span class='Function'><</span><span class='Paren'>)</span> <span class='Number'>10</span>
</pre>
<p>For a more conventional presentation, the condition and action can be placed in a list, and <code><span class='Function'>If</span></code> defined as a function.</p>
<pre><span class='Function'>If</span> <span class='Gets'>โ</span> <span class='Brace'>{</span><span class='Function'>๐</span><span class='Modifier2'>โ</span><span class='Function'>๐</span><span class='String'>@</span><span class='Brace'>}</span><span class='Modifier'>ยด</span>
<span class='Function'>If</span> <span class='Paren'>(</span><span class='Value'>a</span><span class='Function'><</span><span class='Number'>10</span><span class='Paren'>)</span><span class='Ligature'>โฟ</span><span class='Brace'>{</span><span class='Value'>๐ค</span>
<span class='Value'>a</span> <span class='Function'>+</span><span class='Gets'>โฉ</span> <span class='Number'>10</span>
<span class='Brace'>}</span>
</pre>
<p>A final option is to use a <a href="block.html#returns">return</a> to exit a block early. This is really more of an "unless" statement; to get a proper "if" the condition needs to be negated. Repeat is still the easiest way to do the conditional logic, in this case deciding whether to return.</p>
<pre><span class='Brace'>{</span>
<span class='Function'>๐</span><span class='Gets'>โ</span><span class='Modifier2'>โ</span><span class='Paren'>(</span><span class='Function'>ยฌ</span><span class='Value'>a</span><span class='Function'><</span><span class='Number'>10</span><span class='Paren'>)</span> <span class='String'>@</span> <span class='Comment'># Return @ unless a<10
</span> <span class='Value'>a</span> <span class='Function'>+</span><span class='Gets'>โฉ</span> <span class='Number'>10</span>
<span class='Brace'>}</span>
</pre>
<p>In all cases, the result of an if statement is the result of the action if it's performed, and otherwise it's whatever argument was passed to the statement, which is <code><span class='String'>@</span></code> in most examples above.</p>
<h2 id="repeat"><a class="header" href="#repeat">Repeat</a></h2>
<p>There's no reason the condition in an if statement from the previous section has to be boolean: it could be any natural number, causing the action to be repeated that many times. If the action is never performed, the result is the statement's argument, and otherwise it's the result of the last time the action was performed.</p>
<p>Another option is to use a <a href="#for">for-each</a> statement with an argument of <code><span class='Function'>โ</span><span class='Value'>n</span></code>: in this case the result is the list of each action's result.</p>
<h2 id="if-else"><a class="header" href="#if-else">If-Else</a></h2>
<p>Despite the name, an if-else statement is most closely related to a <a href="#switch-case">switch-case</a> statement: in fact, it's just a special case where the two cases are true (<code><span class='Number'>1</span></code>) and false (<code><span class='Number'>0</span></code>). As a result, we can implement it either with Choose (<code><span class='Modifier2'>โถ</span></code>) or with <a href="block.html#case-headers">case headers</a> of <code><span class='Number'>1</span></code> and <code><span class='Number'>0</span></code>.</p>
<p>When using Choose, note that the natural ordering places the false case before the true one to match list index ordering. To get the typical if-else order, the condition should be negated or the statements reversed. Here's a function to get an if-else statement by swapping the conditions, and two ways its application might be written.</p>
<pre><span class='Function'>IfElse</span> <span class='Gets'>โ</span> <span class='Brace'>{</span><span class='Value'>cond</span><span class='Ligature'>โฟ</span><span class='Function'>True</span><span class='Ligature'>โฟ</span><span class='Function'>False</span><span class='Value'>:</span> <span class='Value'>cond</span><span class='Modifier2'>โถ</span><span class='Function'>False</span><span class='Ligature'>โฟ</span><span class='Function'>True</span> <span class='String'>@</span><span class='Brace'>}</span>
<span class='Function'>IfElse</span> <span class='Bracket'>โจ</span><span class='Value'>๐ฉ</span><span class='Function'><</span><span class='Value'>mid</span><span class='Function'>โ</span><span class='Value'>๐จ</span>
<span class='Brace'>{</span><span class='Value'>๐ค</span><span class='Separator'>โ</span> <span class='Value'>hi</span><span class='Gets'>โฉ</span><span class='Value'>mid</span><span class='Brace'>}</span>
<span class='Brace'>{</span><span class='Value'>๐ค</span><span class='Separator'>โ</span> <span class='Value'>lo</span><span class='Gets'>โฉ</span><span class='Value'>mid</span><span class='Brace'>}</span>
<span class='Bracket'>โฉ</span>
<span class='Function'>IfElse</span> <span class='Paren'>(</span><span class='Value'>๐ฉ</span><span class='Function'><</span><span class='Value'>mid</span><span class='Function'>โ</span><span class='Value'>๐จ</span><span class='Paren'>)</span><span class='Ligature'>โฟ</span><span class='Brace'>{</span><span class='Value'>๐ค</span>
<span class='Value'>hi</span><span class='Gets'>โฉ</span><span class='Value'>mid</span>
<span class='Brace'>}</span><span class='Ligature'>โฟ</span><span class='Brace'>{</span><span class='Value'>๐ค</span>
<span class='Value'>lo</span><span class='Gets'>โฉ</span><span class='Value'>mid</span>
<span class='Brace'>}</span>
</pre>
<p>Case headers have similar syntax, but the two cases are labelled explicitly. In this form, the two actions are combined in a single function, which could be assigned to call it on various conditions.</p>
<pre><span class='Brace'>{</span><span class='Function'>๐</span><span class='Value'>๐จ</span><span class='Brace'>}</span><span class='Modifier'>ยด</span> <span class='Paren'>(</span><span class='Value'>๐ฉ</span><span class='Function'><</span><span class='Value'>mid</span><span class='Function'>โ</span><span class='Value'>๐จ</span><span class='Paren'>)</span><span class='Ligature'>โฟ</span><span class='Brace'>{</span>
<span class='Number'>1</span><span class='Value'>:</span> <span class='Value'>hi</span><span class='Gets'>โฉ</span><span class='Value'>mid</span>
<span class='Value'>;</span>
<span class='Number'>0</span><span class='Value'>:</span> <span class='Value'>lo</span><span class='Gets'>โฉ</span><span class='Value'>mid</span>
<span class='Brace'>}</span>
</pre>
<p>The result of an if-else statement is just the result of whichever branch was used; chained if-else and switch-case statements will work the same way.</p>
<h3 id="chained-if-else"><a class="header" href="#chained-if-else">Chained If-Else</a></h3>
<p>One pattern in imperative languages is to check one condition and apply an action if it succeeds, but check a different condition if it fails, in sequence until some condition succeeds or every one has been checked. Languages might make this pattern easier by making if-else right associative, so that the programmer can write an <code><span class='Value'>if</span></code> statement followed by a sequence of <code><span class='Value'>else</span> <span class='Value'>if</span></code> "statements", or might just provide a unified <code><span class='Value'>elif</span></code> keyword that works similarly (while this <em>is</em> a common pattern, I suspect it's used more often than it's really wanted because of this syntactic support).</p>
<p>In BQN it's possible to nest <code><span class='Function'>IfElse</span></code> expressions, but it's also possible to write a control structure that chains them all at one level. For this statement the input will be a sequence of <code><span class='Bracket'>โจ</span><span class='Function'>Test</span><span class='Separator'>,</span><span class='Function'>Action</span><span class='Bracket'>โฉ</span></code> pairs, followed by a final action to perform if no test succeeds. The first test is always performed; other tests should be wrapped in blocks because otherwise they'll be executed even if an earlier test succeeded.</p>
<pre><span class='Function'>Test</span> <span class='Gets'>โ</span> <span class='Brace'>{</span><span class='Value'>fn</span><span class='Gets'>โ</span><span class='Brace'>{</span><span class='Function'>Cond</span><span class='Ligature'>โฟ</span><span class='Function'>Act</span> <span class='Function'>๐</span> <span class='Value'>else:</span> <span class='Function'>Cond</span><span class='Modifier2'>โถ</span><span class='Function'>Else</span><span class='Ligature'>โฟ</span><span class='Function'>Act</span><span class='Brace'>}</span><span class='Modifier'>ยด</span><span class='Value'>๐ฉ</span> <span class='Separator'>โ</span> <span class='Function'>Fn</span><span class='String'>@</span><span class='Brace'>}</span>
<span class='Function'>Test</span> <span class='Bracket'>โจ</span>
<span class='Paren'>(</span> <span class='Value'>a</span><span class='Function'><</span><span class='Value'>b</span><span class='Paren'>)</span><span class='Ligature'>โฟ</span><span class='Brace'>{</span><span class='Value'>๐ค</span><span class='Separator'>โ</span><span class='Value'>a</span><span class='Function'>+</span><span class='Gets'>โฉ</span><span class='Number'>1</span><span class='Brace'>}</span>
<span class='Brace'>{</span><span class='Value'>๐ค</span><span class='Separator'>โ</span><span class='Value'>a</span><span class='Function'><</span><span class='Value'>c</span><span class='Brace'>}</span><span class='Ligature'>โฟ</span><span class='Brace'>{</span><span class='Value'>๐ค</span><span class='Separator'>โ</span><span class='Value'>c</span><span class='Function'>-</span><span class='Gets'>โฉ</span><span class='Number'>1</span><span class='Brace'>}</span>
<span class='Brace'>{</span><span class='Value'>๐ค</span><span class='Separator'>โ</span><span class='Value'>a</span><span class='Function'>-</span><span class='Gets'>โฉ</span><span class='Number'>2</span><span class='Brace'>}</span>
<span class='Bracket'>โฉ</span>
</pre>
<h2 id="switch-case"><a class="header" href="#switch-case">Switch-Case</a></h2>
<p>The simplest way to write a switch-case statement is with <a href="block.html#case-headers">case headers</a> in a monadic function. A function with case headers tests its input against the headers in order until one matches, then executes the code there. To make it into a control structure, we just want to call the function on a given value.</p>
<pre><span class='Function'>Match</span> <span class='Gets'>โ</span> <span class='Brace'>{</span><span class='Function'>๐</span><span class='Value'>๐จ</span><span class='Brace'>}</span><span class='Modifier'>ยด</span>
<span class='Function'>Match</span> <span class='Value'>value</span><span class='Ligature'>โฟ</span><span class='Brace'>{</span>
<span class='Number'>0</span><span class='Ligature'>โฟ</span><span class='Value'>b:</span> <span class='Value'>n</span><span class='Function'>-</span><span class='Gets'>โฉ</span><span class='Value'>b</span>
<span class='Value'>;</span>
<span class='Value'>a</span><span class='Ligature'>โฟ</span><span class='Value'>b:</span> <span class='Value'>n</span><span class='Function'>+</span><span class='Gets'>โฉ</span><span class='Value'>a</span><span class='Function'>-</span><span class='Value'>b</span>
<span class='Value'>;</span>
<span class='Value'>๐ฉ:</span> <span class='Value'>n</span><span class='Function'>โพ</span><span class='Gets'>โฉ</span><span class='Value'>๐ฉ</span>
<span class='Brace'>}</span>
</pre>
<p>A simplified version of a switch-case statement is possible if the cases are natural numbers <code><span class='Number'>0</span></code>, <code><span class='Number'>1</span></code>, and so on. The Choose (<code><span class='Modifier2'>โถ</span></code>) modifier does just what we want. The <code><span class='Function'>Select</span></code> statement below generalizes <code><span class='Function'>IfElse</span></code>, except that it doesn't rearrange the cases relative to Choose while <code><span class='Function'>IfElse</span></code> swaps them.</p>
<pre><span class='Function'>Select</span> <span class='Gets'>โ</span> <span class='Brace'>{</span><span class='Paren'>(</span><span class='Function'>โ</span><span class='Value'>๐ฉ</span><span class='Paren'>)</span><span class='Modifier2'>โถ</span><span class='Paren'>(</span><span class='Number'>1</span><span class='Function'>โ</span><span class='Value'>๐ฉ</span><span class='Paren'>)</span><span class='String'>@</span><span class='Brace'>}</span>
<span class='Function'>Select</span> <span class='Value'>number</span><span class='Ligature'>โฟ</span><span class='Brace'>{</span>
<span class='Value'>name</span> <span class='Gets'>โฉ</span> <span class='String'>"zero"</span>
<span class='Brace'>}</span><span class='Ligature'>โฟ</span><span class='Brace'>{</span>
<span class='Value'>name</span> <span class='Gets'>โฉ</span> <span class='String'>"one"</span>
<span class='Brace'>}</span><span class='Ligature'>โฟ</span><span class='Brace'>{</span>
<span class='Value'>name</span> <span class='Gets'>โฉ</span> <span class='String'>"two"</span>
<span class='Brace'>}</span>
</pre>
<p>To test against other possible values, the following statement takes interleaved lists of values and actions, and disentangles them. It searches through the values with <code><span class='Function'>โ</span></code>.</p>
<pre><span class='Function'>Switch</span> <span class='Gets'>โ</span> <span class='Brace'>{</span><span class='Value'>c</span><span class='Gets'>โ</span><span class='Function'>โ</span><span class='Value'>๐ฉ</span> <span class='Separator'>โ</span> <span class='Value'>m</span><span class='Ligature'>โฟ</span><span class='Value'>a</span><span class='Gets'>โ</span><span class='Function'><</span><span class='Modifier'>ห</span><span class='Function'>โ</span><span class='Modifier2'>โ</span><span class='Ligature'>โฟ</span><span class='Number'>2</span><span class='Function'>โฅ</span><span class='Number'>1</span><span class='Function'>โ</span><span class='Value'>๐ฉ</span> <span class='Separator'>โ</span> <span class='Paren'>(</span><span class='Function'>โ</span><span class='Value'>a</span><span class='Function'>โC</span><span class='Paren'>)</span><span class='Modifier2'>โถ</span><span class='Value'>m</span><span class='String'>@</span><span class='Brace'>}</span>
<span class='Function'>Switch</span> <span class='Bracket'>โจ</span><span class='Value'>value</span>
<span class='String'>"increment"</span> <span class='Separator'>โ</span> <span class='Brace'>{</span><span class='Value'>๐ค</span><span class='Separator'>โ</span> <span class='Value'>v</span><span class='Function'>+</span><span class='Gets'>โฉ</span><span class='Number'>1</span><span class='Brace'>}</span>
<span class='String'>"decrement"</span> <span class='Separator'>โ</span> <span class='Brace'>{</span><span class='Value'>๐ค</span><span class='Separator'>โ</span> <span class='Value'>v</span><span class='Function'>-</span><span class='Gets'>โฉ</span><span class='Number'>1</span><span class='Brace'>}</span>
<span class='String'>"double"</span> <span class='Separator'>โ</span> <span class='Brace'>{</span><span class='Value'>๐ค</span><span class='Separator'>โ</span> <span class='Value'>v</span><span class='Function'>ร</span><span class='Gets'>โฉ</span><span class='Number'>2</span><span class='Brace'>}</span>
<span class='String'>"halve"</span> <span class='Separator'>โ</span> <span class='Brace'>{</span><span class='Value'>๐ค</span><span class='Separator'>โ</span> <span class='Value'>v</span><span class='Function'>รท</span><span class='Gets'>โฉ</span><span class='Number'>2</span><span class='Brace'>}</span>
<span class='Bracket'>โฉ</span>
</pre>
<p>Finally, the most general form of a switch statement is a <a href="#chained-if-else">chained if-else</a>!</p>
<h2 id="loop-forever"><a class="header" href="#loop-forever">Loop forever</a></h2>
<p>It's not a particularly common pattern, but this is a good simple case to warm up for the while loop. BQN primitives usually take a predictable amount of time, and none of them will run forever! Recursion is the tool to use here. If there's a particular function that we'd like to run infinity times, we can just add <code><span class='Value'>๐จ</span><span class='Function'>๐</span><span class='Value'>๐ฉ</span></code> to the end:</p>
<pre><span class='Brace'>{</span>
<span class='Comment'># Stuff to do forever
</span> <span class='Value'>๐จ</span><span class='Function'>๐</span><span class='Value'>๐ฉ</span>
<span class='Brace'>}</span> <span class='Value'>arg</span>
</pre>
<p>To convert this to a control structure format, we want to take an action <code><span class='Function'>A</span></code>, and produce a function that runs <code><span class='Function'>A</span></code>, then runs itself. Finally we want to call that function on some argument, say <code><span class='String'>@</span></code>. The argument is a single function, so to call Forever, we need to convert that function to a subject role.</p>
<pre><span class='Function'>Forever</span> <span class='Gets'>โ</span> <span class='Brace'>{</span><span class='Function'>๐</span><span class='Value'>a:</span><span class='Brace'>{</span><span class='Function'>๐A</span><span class='Value'>๐ฉ</span><span class='Brace'>}</span><span class='String'>@</span><span class='Brace'>}</span>
<span class='Function'>Forever</span> <span class='Number'>1</span><span class='Function'>โ</span><span class='String'>@</span><span class='Ligature'>โฟ</span><span class='Brace'>{</span><span class='Value'>๐ค</span>
<span class='Comment'># Stuff to do forever
</span><span class='Brace'>}</span>
</pre>
<p>A slicker method is to pass <code><span class='Value'>๐ฉ</span></code> as an operand to a modifier. In a modifier, <code><span class='Function'>๐</span></code> has the operands built in (just like <code><span class='Brace'>{</span><span class='Function'>๐A</span><span class='Value'>๐ฉ</span><span class='Brace'>}</span></code> above has the environment containing <code><span class='Function'>A</span></code> built in), so it will work the same way with no need for an explicit variable assignment.</p>
<pre><span class='Function'>Forever</span> <span class='Gets'>โ</span> <span class='Brace'>{</span><span class='Value'>๐ฉ</span><span class='Brace'>{</span><span class='Function'>๐๐ฝ</span><span class='Value'>๐ฉ</span><span class='Brace'>}</span><span class='String'>@</span><span class='Brace'>}</span>
</pre>
<p>The syntax here is awkward enough that it's actually better to use a while loop, with a constant condition of <code><span class='Number'>1</span></code>!</p>
<pre><span class='Function'>While</span> <span class='Number'>1</span><span class='Ligature'>โฟ</span><span class='Brace'>{</span><span class='Value'>๐ค</span>
<span class='Comment'># Stuff to do forever
</span><span class='Brace'>}</span>
</pre>
<h2 id="while"><a class="header" href="#while">While</a></h2>
<p>The same modifier technique used in <code><span class='Function'>Forever</span></code> works for a while loop as well. Because there are now two componentsโthe condition and actionโwe'll use a 2-modifier instead of a 1-modifier.</p>
<pre><span class='Function'>While</span> <span class='Gets'>โ</span> <span class='Brace'>{</span><span class='Value'>๐จ</span><span class='Brace'>{</span><span class='Function'>๐</span><span class='Modifier2'>โ</span><span class='Function'>๐พ</span><span class='Modifier2'>โ</span><span class='Function'>๐ฝ</span><span class='Value'>๐ฉ</span><span class='Brace'>}</span><span class='Value'>๐ฉ</span><span class='String'>@</span><span class='Brace'>}</span><span class='Modifier'>ยด</span>
<span class='Function'>While</span> <span class='Brace'>{</span><span class='Value'>๐ค</span><span class='Separator'>โ</span><span class='Value'>a</span><span class='Function'><</span><span class='Number'>15</span><span class='Brace'>}</span><span class='Ligature'>โฟ</span><span class='Brace'>{</span><span class='Value'>๐ค</span>
<span class='Value'>a</span><span class='Function'>ร</span><span class='Gets'>โฉ</span><span class='Number'>2</span>
<span class='Brace'>}</span>
</pre>
<p><code><span class='Function'>๐ฝ</span></code> is the condition and <code><span class='Function'>๐พ</span></code> is the action. So the inner modifier tests for the condition <code><span class='Function'>๐ฝ</span></code>; if it's true then it runs <code><span class='Function'>๐พ</span></code> followed by <code><span class='Function'>๐</span></code>. For a do-while loop, which is a while loop that always runs the action at least once, we just need to move the test after the action:</p>
<pre><span class='Function'>DoWhile</span> <span class='Gets'>โ</span> <span class='Brace'>{</span><span class='Value'>๐จ</span><span class='Brace'>{</span><span class='Function'>๐</span><span class='Modifier2'>โ</span><span class='Function'>๐ฝ๐พ</span><span class='Value'>๐ฉ</span><span class='Brace'>}</span><span class='Value'>๐ฉ</span><span class='String'>@</span><span class='Brace'>}</span><span class='Modifier'>ยด</span>
</pre>
<p>Because the condition is run repeatedly, it has to be a function, and can't be a plain expression as in an if conditional.</p>
<h3 id="low-stack-version"><a class="header" href="#low-stack-version">Low-stack version</a></h3>
<p>The above version of <code><span class='Function'>While</span></code> will fail in a fairly small number of iterations, because it consumes a new stack frame with each iteration. While tail call optimization could solve this, detecting the tail call in a compound function like <code><span class='Function'>๐</span><span class='Modifier2'>โ</span><span class='Function'>๐พ</span><span class='Modifier2'>โ</span><span class='Function'>๐ฝ</span></code> is technically difficult and would introduce overhead into a BQN interpreter. However, there is a method to make the number of required stack frames logarithmic in the number of iterations instead of linear:</p>
<pre><span class='Function'>While</span> <span class='Gets'>โ</span> <span class='Brace'>{</span><span class='Value'>๐ฉ</span><span class='Brace'>{</span><span class='Function'>๐ฝ</span><span class='Modifier2'>โ</span><span class='Function'>๐พ</span><span class='Modifier2'>โ</span><span class='Function'>๐ฝ</span><span class='Modifier2'>_๐ฃ_</span><span class='Function'>๐พ</span><span class='Modifier2'>โ</span><span class='Function'>๐ฝ</span><span class='Modifier2'>โ</span><span class='Function'>๐พ</span><span class='Value'>๐ฉ</span><span class='Brace'>}</span><span class='Value'>๐จ</span><span class='String'>@</span><span class='Brace'>}</span><span class='Modifier'>ยด</span>
</pre>
<p>The innovation is to use <code><span class='Brace'>{</span><span class='Function'>๐ฝ</span><span class='Modifier2'>โ</span><span class='Function'>๐พ</span><span class='Modifier2'>โ</span><span class='Function'>๐ฝ</span><span class='Modifier2'>_๐ฃ_</span><span class='Function'>๐พ</span><span class='Modifier2'>โ</span><span class='Function'>๐ฝ</span><span class='Modifier2'>โ</span><span class='Function'>๐พ</span><span class='Value'>๐ฉ</span><span class='Brace'>}</span></code> instead of the equivalent <code><span class='Brace'>{</span><span class='Function'>๐ฝ</span><span class='Modifier2'>_๐ฃ_</span><span class='Function'>๐พ</span><span class='Modifier2'>โ</span><span class='Function'>๐ฝ</span><span class='Modifier2'>โ</span><span class='Function'>๐พ</span><span class='Value'>๐ฉ</span><span class='Brace'>}</span></code> or <code><span class='Brace'>{</span><span class='Function'>๐</span><span class='Modifier2'>โ</span><span class='Function'>๐ฝ</span><span class='Modifier2'>โ</span><span class='Function'>๐พ</span><span class='Value'>๐ฉ</span><span class='Brace'>}</span></code> (these are the same, as <code><span class='Function'>๐</span></code> in a modifier is defined as <code><span class='Function'>๐ฝ</span><span class='Modifier2'>_๐ฃ_</span><span class='Function'>๐พ</span></code>). Here <code><span class='Function'>๐ฝ</span></code> performs one iteration and <code><span class='Function'>๐พ</span></code> tests whether to continue. The simplest approach is to perform one iteration and recurse with the same two functions. The modified approach replaces <code><span class='Function'>๐ฝ</span></code> with <code><span class='Function'>๐ฝ</span><span class='Modifier2'>โ</span><span class='Function'>๐พ</span><span class='Modifier2'>โ</span><span class='Function'>๐ฝ</span></code>, that is, it doubles it while making sure the condition is still checked each iteration. The doublings compound so that recursion level <code><span class='Value'>n</span></code> performs <code><span class='Function'>๐ฝ</span></code> up to <code><span class='Number'>2</span><span class='Function'>โ</span><span class='Value'>n</span></code> times while using on the order of <code><span class='Value'>n</span></code> additional stack frames. Only a hundred or two stack frames are needed to give a practically unlimited number of iterations.</p>
<h2 id="for"><a class="header" href="#for">For</a></h2>
<p>To begin with, are you sure you don't want a for-each loop instead? In BQN that's just a function with Each (<code><span class='Modifier'>ยจ</span></code>), and it covers most common uses of a for loop.</p>
<pre><span class='Function'>Fn</span><span class='Modifier'>ยจ</span> <span class='Value'>v</span> <span class='Comment'># for (๐ฉ in v)
</span><span class='Function'>Fn</span><span class='Modifier'>ยจ</span> <span class='Function'>โ</span><span class='Value'>n</span> <span class='Comment'># for (๐ฉ=0; ๐ฉ<n; ๐ฉ++)
</span><span class='Function'>Fn</span><span class='Modifier'>ยจ</span> <span class='Value'>k</span><span class='Function'>โโ</span><span class='Value'>n</span> <span class='Comment'># for (๐ฉ=k; ๐ฉ<n; ๐ฉ++) with 0โคk
</span><span class='Function'>Fn</span><span class='Modifier'>ยจ</span> <span class='Value'>k</span><span class='Function'>+โ</span><span class='Value'>n</span><span class='Function'>-</span><span class='Value'>k</span> <span class='Comment'># for (๐ฉ=k; ๐ฉ<n; ๐ฉ++) with kโคn
</span><span class='Function'>Fn</span><span class='Modifier'>ยจ</span> <span class='Function'>โฝ</span><span class='Value'>n</span> <span class='Comment'># for (๐ฉ=n; --๐ฉ; )
</span></pre>
<p>Very wellโฆ a for loop is just a while loop with some extra pre- and post-actions.</p>
<pre><span class='Function'>For</span> <span class='Gets'>โ</span> <span class='Brace'>{</span><span class='Function'>Pre</span><span class='Ligature'>โฟ</span><span class='Function'>Cond</span><span class='Ligature'>โฟ</span><span class='Function'>Post</span><span class='Ligature'>โฟ</span><span class='Function'>Act</span><span class='Value'>:</span> <span class='Function'>Pre</span><span class='String'>@</span> <span class='Separator'>โ</span> <span class='Brace'>{</span><span class='Function'>๐</span><span class='Modifier2'>โ</span><span class='Function'>Post</span><span class='Modifier2'>โ</span><span class='Function'>Act</span><span class='Modifier2'>โ</span><span class='Function'>Cond</span> <span class='Value'>๐ฉ</span><span class='Brace'>}</span><span class='String'>@</span><span class='Brace'>}</span>
<span class='Function'>For</span> <span class='Paren'>(</span><span class='Value'>c</span><span class='Gets'>โ</span><span class='Number'>27</span><span class='Function'>โฃ</span><span class='Value'>n</span><span class='Gets'>โ</span><span class='Number'>0</span><span class='Paren'>)</span><span class='Ligature'>โฟ</span><span class='Brace'>{</span><span class='Value'>๐ค</span><span class='Separator'>โ</span><span class='Number'>1</span><span class='Function'><</span><span class='Value'>c</span><span class='Brace'>}</span><span class='Ligature'>โฟ</span><span class='Brace'>{</span><span class='Value'>๐ค</span><span class='Separator'>โ</span><span class='Value'>n</span><span class='Function'>+</span><span class='Gets'>โฉ</span><span class='Number'>1</span><span class='Brace'>}</span><span class='Ligature'>โฟ</span><span class='Brace'>{</span><span class='Value'>๐ค</span>
<span class='Brace'>{</span><span class='Function'>๐</span><span class='Value'>๐จ</span><span class='Brace'>}</span><span class='Modifier'>ยด</span> <span class='Paren'>(</span><span class='Number'>2</span><span class='Function'>|</span><span class='Value'>c</span><span class='Paren'>)</span><span class='Ligature'>โฟ</span><span class='Brace'>{</span>
<span class='Number'>0</span><span class='Value'>:</span> <span class='Value'>c</span><span class='Function'>รท</span><span class='Gets'>โฉ</span><span class='Number'>2</span>
<span class='Value'>;</span>
<span class='Number'>1</span><span class='Value'>:</span> <span class='Value'>c</span><span class='Gets'>โฉ</span><span class='Number'>1</span><span class='Function'>+</span><span class='Number'>3</span><span class='Function'>ร</span><span class='Value'>c</span>
<span class='Brace'>}</span>
<span class='Brace'>}</span>
</pre>
<p>The initialization can be a simple expression as shown; in fact it's a little silly to make initialization one of the arguments to <code><span class='Function'>For</span></code> at all.Unlike in C, it's impossible to declare a variable that's local to the whole <code><span class='Function'>For</span></code> loop but not its surroundings. Hopefully this is obvious from the structure of the code! Only curly braces can create a new scope, so to localize some variables in the <code><span class='Function'>For</span></code> loop, just surround it in an extra set of curly braces.</p>
<p>The <code><span class='Function'>While</span></code> loop alone allows syntax similar to the <code><span class='Function'>For</span></code> loop. Perform any initialization outside of the loop, and compose the post-action with the main body using the reverse composition <code><span class='Brace'>{</span><span class='Function'>๐พ</span><span class='Modifier2'>โ</span><span class='Function'>๐ฝ</span><span class='Brace'>}</span></code>. Because the composition binds less tightly than stranding, the bracketed <a href="arrayrepr.html#brackets">list notation</a> has to be used here.</p>
<pre><span class='Value'>c</span><span class='Gets'>โ</span><span class='Number'>27</span> <span class='Separator'>โ</span> <span class='Value'>n</span><span class='Gets'>โ</span><span class='Number'>0</span>
<span class='Function'>While</span> <span class='Bracket'>โจ</span><span class='Brace'>{</span><span class='Value'>๐ค</span><span class='Separator'>โ</span><span class='Number'>1</span><span class='Function'><</span><span class='Value'>c</span><span class='Brace'>}</span><span class='Separator'>,</span> <span class='Brace'>{</span><span class='Value'>๐ค</span><span class='Separator'>โ</span><span class='Value'>n</span><span class='Function'>+</span><span class='Gets'>โฉ</span><span class='Number'>1</span><span class='Brace'>}{</span><span class='Function'>๐พ</span><span class='Modifier2'>โ</span><span class='Function'>๐ฝ</span><span class='Brace'>}{</span><span class='Value'>๐ค</span>
<span class='Function'>Match</span> <span class='Paren'>(</span><span class='Number'>2</span><span class='Function'>|</span><span class='Value'>c</span><span class='Paren'>)</span><span class='Ligature'>โฟ</span><span class='Brace'>{</span>
<span class='Number'>0</span><span class='Value'>:</span> <span class='Value'>c</span><span class='Function'>รท</span><span class='Gets'>โฉ</span><span class='Number'>2</span>
<span class='Value'>;</span>
<span class='Number'>1</span><span class='Value'>:</span> <span class='Value'>c</span><span class='Gets'>โฉ</span><span class='Number'>1</span><span class='Function'>+</span><span class='Number'>3</span><span class='Function'>ร</span><span class='Value'>c</span>
<span class='Brace'>}</span>
<span class='Brace'>}</span><span class='Bracket'>โฉ</span>
</pre>
<h3 id="break-and-continue"><a class="header" href="#break-and-continue">Break and continue</a></h3>
<p>In a <code><span class='Function'>While</span></code> or <code><span class='Function'>For</span></code> loop, <a href="block.html#returns">returns</a> can be used for either the break or the continue statement (or, for that matter, a multiline break) if available. Returning from the main body, either with <code><span class='Function'>๐</span><span class='Gets'>โ</span></code> or a labelled return, is a functional version of a continue statement. To escape from the loop as a whole, it should be wrapped in a labelled immediate block. Returning from that block using its label breaks the loop. For example, the following loop</p>
<pre><span class='Brace'>{</span><span class='Value'>brk:</span>
<span class='Value'>sum</span> <span class='Gets'>โ</span> <span class='Number'>0</span> <span class='Separator'>โ</span> <span class='Value'>even</span> <span class='Gets'>โ</span> <span class='Bracket'>โจโฉ</span>
<span class='Function'>While</span> <span class='Brace'>{</span><span class='Value'>๐ค</span><span class='Separator'>โ</span><span class='Value'>sum</span><span class='Function'><</span><span class='Number'>100</span><span class='Brace'>}</span><span class='Ligature'>โฟ</span><span class='Brace'>{</span><span class='Function'>Cnt</span><span class='Value'>:</span>
<span class='Value'>brk</span><span class='Gets'>โ</span><span class='Modifier2'>โ</span><span class='Paren'>(</span><span class='Number'>15</span><span class='Function'>โค</span><span class='Value'>n</span><span class='Paren'>)</span> <span class='String'>@</span>
<span class='Value'>sum</span> <span class='Function'>+</span><span class='Gets'>โฉ</span> <span class='Value'>n</span>
<span class='Function'>Cnt</span><span class='Gets'>โ</span><span class='Modifier2'>โ</span><span class='Paren'>(</span><span class='Number'>2</span><span class='Function'>|</span><span class='Value'>n</span><span class='Paren'>)</span> <span class='String'>@</span>
<span class='Value'>even</span> <span class='Function'>โพ</span><span class='Gets'>โฉ</span> <span class='Value'>n</span>
<span class='Brace'>}</span>
<span class='Brace'>}</span>
</pre>
|
