46 | 46 |
| >/
|
47 | 47 |
| ++++
|
48 | 48 |
| >)<
|
49 | |
= State [4]<[5] [0]<[] True
|
|
49 |
= State{ tape=(... [4] 5 ...), stack=(... [0] ...), halt=True }
|
50 | 50 |
|
51 | 51 |
Try it with -1:
|
52 | 52 |
|
|
56 | 56 |
| >/
|
57 | 57 |
| ++++
|
58 | 58 |
| >)<
|
59 | |
= State [4]<[3] [0]<[] True
|
|
59 |
= State{ tape=(... [4] 3 ...), stack=(... [0] ...), halt=True }
|
60 | 60 |
|
61 | 61 |
Try it with 1:
|
62 | 62 |
|
|
66 | 66 |
| >/
|
67 | 67 |
| ++++
|
68 | 68 |
| >)<
|
69 | |
= State [4]<[1] [0]<[] True
|
|
69 |
= State{ tape=(... [4] 1 ...), stack=(... [0] ...), halt=True }
|
70 | 70 |
|
71 | 71 |
Try it with 3:
|
72 | 72 |
|
|
76 | 76 |
| >/
|
77 | 77 |
| ++++
|
78 | 78 |
| >)<
|
79 | |
= State [2]<[-1] [0]<[] True
|
|
79 |
= State{ tape=(... [2] -1 ...), stack=(... [0] ...), halt=True }
|
80 | 80 |
|
81 | 81 |
Try it with 5:
|
82 | 82 |
|
|
86 | 86 |
| >/
|
87 | 87 |
| ++++
|
88 | 88 |
| >)<
|
89 | |
= State [2]<[-3] [0]<[] True
|
|
89 |
= State{ tape=(... [2] -3 ...), stack=(... [0] ...), halt=True }
|
90 | 90 |
|
91 | 91 |
Try it with 7:
|
92 | 92 |
|
|
96 | 96 |
| >/
|
97 | 97 |
| ++++
|
98 | 98 |
| >)<
|
99 | |
= State [2]<[-5] [0]<[] True
|
|
99 |
= State{ tape=(... [2] -5 ...), stack=(... [0] ...), halt=True }
|
100 | 100 |
|
101 | 101 |
Note also that the work value is not available to us inside the branch,
|
102 | 102 |
because it's on the stack, not on the tape. A trace makes this more obvious.
|
|
112 | 112 |
| >/
|
113 | 113 |
| ++++
|
114 | 114 |
| >)<
|
115 | |
= State [0]<[] [0]<[] True ::: +
|
116 | |
= State [1]<[] [0]<[] True ::: -
|
117 | |
= State [0]<[] [0]<[] True ::: -
|
118 | |
= State [-1]<[] [0]<[] True ::: (++>/++++>)
|
119 | |
= State [0]<[] [1,0]<[] True ::: +
|
120 | |
= State [1]<[] [1,0]<[] True ::: +
|
121 | |
= State [2]<[] [1,0]<[] True ::: +
|
122 | |
= State [3]<[] [1,0]<[] True ::: +
|
123 | |
= State [4]<[] [1,0]<[] True ::: >
|
124 | |
= State [4,1]<[] [0]<[] True ::: <
|
125 | |
= State [4]<[1] [0]<[] True
|
126 | |
|
127 | |
| +++++
|
128 | |
| --(
|
129 | |
| ++
|
130 | |
| >/
|
131 | |
| ++++
|
132 | |
| >)<
|
133 | |
= State [0]<[] [0]<[] True ::: +
|
134 | |
= State [1]<[] [0]<[] True ::: +
|
135 | |
= State [2]<[] [0]<[] True ::: +
|
136 | |
= State [3]<[] [0]<[] True ::: +
|
137 | |
= State [4]<[] [0]<[] True ::: +
|
138 | |
= State [5]<[] [0]<[] True ::: -
|
139 | |
= State [4]<[] [0]<[] True ::: -
|
140 | |
= State [3]<[] [0]<[] True ::: (++>/++++>)
|
141 | |
= State [0]<[] [-3,0]<[] True ::: +
|
142 | |
= State [1]<[] [-3,0]<[] True ::: +
|
143 | |
= State [2]<[] [-3,0]<[] True ::: >
|
144 | |
= State [2,-3]<[] [0]<[] True ::: <
|
145 | |
= State [2]<[-3] [0]<[] True
|
|
115 |
= State{ tape=(... [0] ...), stack=(... [0] ...), halt=True } ::: +
|
|
116 |
= State{ tape=(... [1] ...), stack=(... [0] ...), halt=True } ::: -
|
|
117 |
= State{ tape=(... [0] ...), stack=(... [0] ...), halt=True } ::: -
|
|
118 |
= State{ tape=(... [-1] ...), stack=(... [0] ...), halt=True } ::: (++>/++++>)
|
|
119 |
= State{ tape=(... [0] ...), stack=(... 1 [0] ...), halt=True } ::: +
|
|
120 |
= State{ tape=(... [1] ...), stack=(... 1 [0] ...), halt=True } ::: +
|
|
121 |
= State{ tape=(... [2] ...), stack=(... 1 [0] ...), halt=True } ::: +
|
|
122 |
= State{ tape=(... [3] ...), stack=(... 1 [0] ...), halt=True } ::: +
|
|
123 |
= State{ tape=(... [4] ...), stack=(... 1 [0] ...), halt=True } ::: >
|
|
124 |
= State{ tape=(... 4 [1] ...), stack=(... [0] ...), halt=True } ::: <
|
|
125 |
= State{ tape=(... [4] 1 ...), stack=(... [0] ...), halt=True }
|
|
126 |
|
|
127 |
| +++++
|
|
128 |
| --(
|
|
129 |
| ++
|
|
130 |
| >/
|
|
131 |
| ++++
|
|
132 |
| >)<
|
|
133 |
= State{ tape=(... [0] ...), stack=(... [0] ...), halt=True } ::: +
|
|
134 |
= State{ tape=(... [1] ...), stack=(... [0] ...), halt=True } ::: +
|
|
135 |
= State{ tape=(... [2] ...), stack=(... [0] ...), halt=True } ::: +
|
|
136 |
= State{ tape=(... [3] ...), stack=(... [0] ...), halt=True } ::: +
|
|
137 |
= State{ tape=(... [4] ...), stack=(... [0] ...), halt=True } ::: +
|
|
138 |
= State{ tape=(... [5] ...), stack=(... [0] ...), halt=True } ::: -
|
|
139 |
= State{ tape=(... [4] ...), stack=(... [0] ...), halt=True } ::: -
|
|
140 |
= State{ tape=(... [3] ...), stack=(... [0] ...), halt=True } ::: (++>/++++>)
|
|
141 |
= State{ tape=(... [0] ...), stack=(... -3 [0] ...), halt=True } ::: +
|
|
142 |
= State{ tape=(... [1] ...), stack=(... -3 [0] ...), halt=True } ::: +
|
|
143 |
= State{ tape=(... [2] ...), stack=(... -3 [0] ...), halt=True } ::: >
|
|
144 |
= State{ tape=(... 2 [-3] ...), stack=(... [0] ...), halt=True } ::: <
|
|
145 |
= State{ tape=(... [2] -3 ...), stack=(... [0] ...), halt=True }
|
146 | 146 |
|
147 | 147 |
But it *is* available to us after the branch, so we can make another test.
|
148 | 148 |
|
|
163 | 163 |
| >/
|
164 | 164 |
| ++++
|
165 | 165 |
| >)--(/)<
|
166 | |
= State [4]<[1] [0]<[] True
|
|
166 |
= State{ tape=(... [4] 1 ...), stack=(... [0] ...), halt=True }
|
167 | 167 |
|
168 | 168 |
Try it with 3:
|
169 | 169 |
|
|
173 | 173 |
| >/
|
174 | 174 |
| ++++
|
175 | 175 |
| >)--(/)<
|
176 | |
= State [2]<[3] [0]<[] True
|
|
176 |
= State{ tape=(... [2] 3 ...), stack=(... [0] ...), halt=True }
|
177 | 177 |
|
178 | 178 |
Try it with 5:
|
179 | 179 |
|
|
183 | 183 |
| >/
|
184 | 184 |
| ++++
|
185 | 185 |
| >)--(/)<
|
186 | |
= State [2]<[5] [0]<[] True
|
|
186 |
= State{ tape=(... [2] 5 ...), stack=(... [0] ...), halt=True }
|
187 | 187 |
|
188 | 188 |
As you can see, after the test, the contents of the current tape cell
|
189 | 189 |
are the same as the value we originally tested against.
|
|
206 | 206 |
| >/
|
207 | 207 |
| ++++
|
208 | 208 |
| >)----(/)<
|
209 | |
= State [4]<[3] [0]<[] True
|
|
209 |
= State{ tape=(... [4] 3 ...), stack=(... [0] ...), halt=True }
|
210 | 210 |
|
211 | 211 |
Try it with 5:
|
212 | 212 |
|
|
216 | 216 |
| >/
|
217 | 217 |
| ++++
|
218 | 218 |
| >)----(/)<
|
219 | |
= State [2]<[5] [0]<[] True
|
|
219 |
= State{ tape=(... [2] 5 ...), stack=(... [0] ...), halt=True }
|
220 | 220 |
|
221 | 221 |
The next step will be combining these conditionals so that we can build a test
|
222 | 222 |
that tests for multiple cases.
|
|
332 | 332 |
| >>
|
333 | 333 |
| >/
|
334 | 334 |
| >)----(/)<<<
|
335 | |
= State [9]<[0,0,1] [0]<[] True
|
|
335 |
= State{ tape=(... [9] 0 0 1 ...), stack=(... [0] ...), halt=True }
|
336 | 336 |
|
337 | 337 |
Try it with 3:
|
338 | 338 |
|
|
355 | 355 |
| >>
|
356 | 356 |
| >/
|
357 | 357 |
| >)----(/)<<<
|
358 | |
= State [13]<[0,0,3] [0]<[] True
|
|
358 |
= State{ tape=(... [13] 0 0 3 ...), stack=(... [0] ...), halt=True }
|
359 | 359 |
|
360 | 360 |
Try it with 5:
|
361 | 361 |
|
|
378 | 378 |
| >>
|
379 | 379 |
| >/
|
380 | 380 |
| >)----(/)<<<
|
381 | |
= State [7]<[0,0,5] [0]<[] True
|
|
381 |
= State{ tape=(... [7] 0 0 5 ...), stack=(... [0] ...), halt=True }
|