|
0
|
1
|
|
|
2 Val[in:out]
|
|
|
3 {
|
|
|
4 out <- in
|
|
|
5 }
|
|
|
6
|
|
|
7 _Map[list,index,worker:out]
|
|
|
8 {
|
|
|
9 newval <- [
|
|
|
10 [worker]Do[
|
|
|
11 [()]Append[ [list]Index[index] ]
|
|
|
12 ]
|
|
|
13 ]Index[0]
|
|
|
14
|
|
|
15 [list]Next[index]
|
|
|
16 {
|
|
|
17 out <- [_Map[list, ~, worker]]Set[index, newval]
|
|
|
18 }{
|
|
|
19 out <- [list]Set[index, newval]
|
|
|
20 }
|
|
|
21 }
|
|
|
22
|
|
|
23 Map[list,worker:out]
|
|
|
24 {
|
|
|
25 [list]First
|
|
|
26 {
|
|
|
27 out <- _Map[list, ~, worker]
|
|
|
28 }{
|
|
|
29 out <- list
|
|
|
30 }
|
|
|
31 }
|
|
|
32
|
|
|
33 _Key Value Map[list,index,newlist,worker:out]
|
|
|
34 {
|
|
|
35 [worker]Do[
|
|
|
36 [[()]Append[ [list]Index[index] ]]Append[index]
|
|
|
37 ]
|
|
|
38 {
|
|
|
39 newval <- [~]Index[0]
|
|
|
40 newkey <- [~]Index[1]
|
|
|
41 }
|
|
|
42
|
|
|
43 next <- [newlist]Set[newkey, newval]
|
|
|
44
|
|
|
45 [list]Next[index]
|
|
|
46 {
|
|
|
47 out <- _Key Value Map[list, ~, next, worker]
|
|
|
48 }{
|
|
|
49 out <- Val[next]
|
|
|
50 }
|
|
|
51 }
|
|
|
52
|
|
|
53 New Like@List[in:out]
|
|
|
54 {
|
|
|
55 out <- ()
|
|
|
56 }
|
|
|
57
|
|
|
58 New Like@Dictionary[in:out]
|
|
|
59 {
|
|
|
60 out <- New@Dictionary[]
|
|
|
61 }
|
|
|
62
|
|
|
63 Key Value Map[list,worker:out]
|
|
|
64 {
|
|
|
65 [list]First
|
|
|
66 {
|
|
|
67 out <- _Key Value Map[list, ~, New Like[list], worker]
|
|
|
68 }{
|
|
|
69 out <- New Like[list]
|
|
|
70 }
|
|
|
71 }
|
|
|
72
|
|
|
73 In[needle,haystack:found?]
|
|
|
74 {
|
|
|
75 [haystack]Get DString[needle]
|
|
|
76 {
|
|
|
77 found? <- Yes
|
|
|
78 } {} {} {
|
|
|
79 found? <- No
|
|
|
80 }
|
|
|
81 }
|
|
|
82
|
|
|
83 Left Trim[string,trim:trimmed]
|
|
|
84 {
|
|
|
85 If[ [[string]Length] > [0] ]
|
|
|
86 {
|
|
|
87 first,rest <- [string]Slice[1]
|
|
|
88 If[ [first]In[trim] ]
|
|
|
89 {
|
|
|
90 trimmed <- Left Trim[rest, trim]
|
|
|
91 }{
|
|
|
92 trimmed <- string
|
|
|
93 }
|
|
|
94 }{
|
|
|
95 trimmed <- string
|
|
|
96 }
|
|
|
97 }
|
|
|
98
|
|
|
99 Right Trim[string,trim:trimmed]
|
|
|
100 {
|
|
|
101 If[ [[string]Length] > [0] ]
|
|
|
102 {
|
|
|
103 rest,last <- [string]Slice[ [[string]Length] - [1]]
|
|
|
104 If[ [last]In[trim] ]
|
|
|
105 {
|
|
|
106 trimmed <- Right Trim[rest, trim]
|
|
|
107 }{
|
|
|
108 trimmed <- string
|
|
|
109 }
|
|
|
110 }{
|
|
|
111 trimmed <- string
|
|
|
112 }
|
|
|
113 }
|
|
|
114
|
|
|
115 Trim[string,trim:trimmed]
|
|
|
116 {
|
|
|
117 left <- Left Trim[string, trim]
|
|
|
118 trimmed <- Right Trim[left, trim]
|
|
|
119 }
|
|
|
120
|
|
|
121 Max[a,b:max]
|
|
|
122 {
|
|
|
123 If[[a] > [b]]
|
|
|
124 {
|
|
|
125 max <- a
|
|
|
126 }{
|
|
|
127 max <- b
|
|
|
128 }
|
|
|
129 }
|
|
|
130
|
|
|
131 Count Substring[string,substring:out]
|
|
|
132 {
|
|
|
133 out <- Max[[[[string]Split[substring]]Length] - [1], 0]
|
|
|
134 }
|
|
|
135
|
|
|
136 _Key Value Join[dict,key,key sep,val sep,string:out]
|
|
|
137 {
|
|
|
138 new string <- [[[string]Append[key]]Append[key sep]]Append[ [dict]Index[key] ]
|
|
|
139 [dict]Next[key]
|
|
|
140 {
|
|
|
141 out <- _Key Value Join[dict, ~, key sep, val sep, [new string]Append[val sep]]
|
|
|
142 }{
|
|
|
143 out <- Val[new string]
|
|
|
144 }
|
|
|
145 }
|
|
|
146
|
|
|
147 Key Value Join[dict,key sep,val sep:out]
|
|
|
148 {
|
|
|
149 [dict]First
|
|
|
150 {
|
|
|
151 out <- _Key Value Join[dict, ~, key sep, val sep, ""]
|
|
|
152 }{
|
|
|
153 out <- ""
|
|
|
154 }
|
|
|
155 }
|
|
|
156
|
|
|
157 _Combine[source,dest,key:out]
|
|
|
158 {
|
|
|
159 new dest <- [dest]Set[key, [source]Index[key]]
|
|
|
160 [source]Next[key]
|
|
|
161 {
|
|
|
162 out <- _Combine[source, new dest, ~]
|
|
|
163 }{
|
|
|
164 out <- Val[new dest]
|
|
|
165 }
|
|
|
166 }
|
|
|
167
|
|
|
168 Combine[source,dest:out]
|
|
|
169 {
|
|
|
170 [source]First
|
|
|
171 {
|
|
|
172 out <- _Combine[source, dest, ~]
|
|
|
173 }{
|
|
|
174 out <- dest
|
|
|
175 }
|
|
|
176 }
|
|
|
177
|
|
|
178 _Fold[list,index,current,worker:out]
|
|
|
179 {
|
|
|
180 newval <- [
|
|
|
181 [worker]Do[
|
|
|
182 [[[()]Append[ current ]]Append[ [list]Index[index] ]]Append[index]
|
|
|
183 ]
|
|
|
184 ]Index[0]
|
|
|
185
|
|
|
186 [list]Next[index]
|
|
|
187 {
|
|
|
188 out <- _Fold[list, ~, newval, worker]
|
|
|
189 }{
|
|
|
190 out <- Val[newval]
|
|
|
191 }
|
|
|
192 }
|
|
|
193
|
|
|
194 Fold[worker,start,list:out]
|
|
|
195 {
|
|
|
196 [list]First
|
|
|
197 {
|
|
|
198 out <- _Fold[list, ~, start, worker]
|
|
|
199 }{
|
|
|
200 out <- start
|
|
|
201 }
|
|
|
202 }
|
|
|
203
|
|
|
204 _Dict Split[dict,entry,index,keydelim:out]
|
|
|
205 {
|
|
|
206 parts <- [entry]Split[keydelim]
|
|
|
207 out <- [dict]Set[[parts]Index[0],[parts]Index[1]]
|
|
|
208 }
|
|
|
209
|
|
|
210 Dict Split[string,keydelim,entrydelim:out]
|
|
|
211 {
|
|
|
212 out <- Fold[["_Dict Split"]Set Input[3, keydelim], New@Dictionary[], [string]Split[entrydelim]]
|
|
|
213 }
|
|
|
214
|
|
|
215 Previous@List[list,index:prev index,not found]
|
|
|
216 {
|
|
|
217 prev <- [index] - [1]
|
|
|
218 If[[prev] < [0]]
|
|
|
219 {
|
|
|
220 not found <- list
|
|
|
221 }{
|
|
|
222 [list]Index[prev]
|
|
|
223 {
|
|
|
224 prev index <- Val[prev]
|
|
|
225 }{
|
|
|
226 prev index, not found <- [list]Previous[prev]
|
|
|
227 }
|
|
|
228 }
|
|
|
229 }
|
|
|
230
|
|
|
231 Last@List[list:out,not found]
|
|
|
232 {
|
|
|
233 out, not found <- [list]Previous[[list]Length]
|
|
|
234 }
|
|
|
235
|
|
|
236 _Reverse Fold[list,index,start,worker:out]
|
|
|
237 {
|
|
|
238 newval <- [
|
|
|
239 [worker]Do[
|
|
|
240 [[[()]Append[ start ]]Append[ [list]Index[index] ]]Append[index]
|
|
|
241 ]
|
|
|
242 ]Index[0]
|
|
|
243
|
|
|
244 [list]Previous[index]
|
|
|
245 {
|
|
|
246 out <- _Reverse Fold[list, ~, newval, worker]
|
|
|
247 }{
|
|
|
248 out <- Val[newval]
|
|
|
249 }
|
|
|
250 }
|
|
|
251
|
|
|
252 Reverse Fold[worker,start,list:out]
|
|
|
253 {
|
|
|
254 [list]Last
|
|
|
255 {
|
|
|
256 out <- _Reverse Fold[list, ~, start, worker]
|
|
|
257 }{
|
|
|
258 out <- list
|
|
|
259 }
|
|
|
260 }
|
|
|
261
|
|
|
262 _Join[list,delim,current,index:out]
|
|
|
263 {
|
|
|
264 [list]Next[index]
|
|
|
265 {
|
|
|
266 out <- _Join[list, delim, [[current]Append[delim]]Append[[list]Index[~]], ~]
|
|
|
267 }{
|
|
|
268 out <- current
|
|
|
269 }
|
|
|
270 }
|
|
|
271
|
|
|
272 Join[list,delim:out]
|
|
|
273 {
|
|
|
274 [list]First
|
|
|
275 {
|
|
|
276 out <- _Join[list, delim, [list]Index[~], ~]
|
|
|
277 }{
|
|
|
278 out <- ""
|
|
|
279 }
|
|
|
280 }
|
|
|
281
|
|
|
282 Replace[string,find,replace:replaced]
|
|
|
283 {
|
|
|
284 replaced <- [[string]Split[find]]Join[replace]
|
|
|
285 }
|
|
|
286
|
|
|
287 Concatenate[left,right:out]
|
|
|
288 {
|
|
|
289 out <- Fold[["Append"]<String@Worker, left, right]
|
|
|
290 }
|
|
|
291
|
|
|
292 Starts With[thing,starts with:out]
|
|
|
293 {
|
|
|
294 out <- [[thing]Slice[[starts with]Length]] = [starts with]
|
|
|
295 }
|
|
|
296
|
|
|
297 Ends With[thing,ends with:out]
|
|
|
298 {
|
|
|
299 ,compare <- [thing]Slice[ [[thing]Length] - [[ends with]Length] ]
|
|
|
300 out <- [compare] = [ends with]
|
|
|
301 }
|
|
|
302
|
|
|
303 As List@String[string:list]
|
|
|
304 {
|
|
|
305 list <- [()]Append[string]
|
|
|
306 }
|
|
|
307
|
|
|
308 As List@List[in:out]
|
|
|
309 {
|
|
|
310 out <- in
|
|
|
311 }
|
|
|
312
|
|
|
313 _Filter[list,index,worker,destlist:out]
|
|
|
314 {
|
|
|
315 filter? <- [
|
|
|
316 [worker]Do[
|
|
|
317 [()]Append[ [list]Index[index] ]
|
|
|
318 ]
|
|
|
319 ]Index[0]
|
|
|
320 If[filter?]
|
|
|
321 {
|
|
|
322 newlist <- [destlist]Append[[list]Index[index]]
|
|
|
323 }{
|
|
|
324 newlist <- destlist
|
|
|
325 }
|
|
|
326
|
|
|
327 [list]Next[index]
|
|
|
328 {
|
|
|
329 out <- _Filter[list, ~, worker, newlist]
|
|
|
330 }{
|
|
|
331 out <- Val[newlist]
|
|
|
332 }
|
|
|
333 }
|
|
|
334
|
|
|
335 Filter[list,worker:out]
|
|
|
336 {
|
|
|
337 [list]First
|
|
|
338 {
|
|
|
339 out <- _Filter[list, ~, worker, ()]
|
|
|
340 }{
|
|
|
341 out <- list
|
|
|
342 }
|
|
|
343 }
|
|
|
344
|
|
|
345 Pop@List[list:out]
|
|
|
346 {
|
|
|
347 [list]Last
|
|
|
348 {
|
|
|
349 out <- [list]Remove[~]
|
|
|
350 }{
|
|
|
351 out <- list
|
|
|
352 }
|
|
|
353 }
|
|
|
354
|
|
|
355 Peek@List[list:out,empty]
|
|
|
356 {
|
|
|
357 [list]Last
|
|
|
358 {
|
|
|
359 out <- [list]Index[~]
|
|
|
360 }{
|
|
|
361 empty <- list
|
|
|
362 }
|
|
|
363 }
|
|
|
364
|
|
|
365 Contains[haystack,needle:out]
|
|
|
366 {
|
|
|
367 [haystack]Get DString[needle]
|
|
|
368 {
|
|
|
369 out <- Yes
|
|
|
370 } {} {} {
|
|
|
371 out <- No
|
|
|
372 }
|
|
|
373 }
|
|
|
374
|
|
|
375 _Find[haystack,needle,index:outindex,notfound]
|
|
|
376 {
|
|
|
377 If[[[haystack]Index[index]] = [needle]]
|
|
|
378 {
|
|
|
379 outindex <- index
|
|
|
380 }{
|
|
|
381 [haystack]Next[index]
|
|
|
382 {
|
|
|
383 outindex,notfound <- _Find[haystack,needle,~]
|
|
|
384 }{
|
|
|
385 notfound <- needle
|
|
|
386 }
|
|
|
387 }
|
|
|
388 }
|
|
|
389
|
|
|
390 Find[haystack,needle:index,not found]
|
|
|
391 {
|
|
|
392 [haystack]First
|
|
|
393 {
|
|
|
394 index,not found <- _Find[haystack, needle, ~]
|
|
|
395 }{
|
|
|
396 not found <- needle
|
|
|
397 }
|
|
|
398
|
|
|
399 }
|
|
|
400
|
|
|
401 Get Pretty Print Value[value:print,index,print indent,done,out value]
|
|
|
402 {
|
|
|
403 If[[Type Of[value]] = ["List"]]
|
|
|
404 {
|
|
|
405 out value <- value
|
|
|
406 list <- value
|
|
|
407 object <- value
|
|
|
408 }{
|
|
|
409 If[[Type Of[value]] = ["Dictionary"]]
|
|
|
410 {
|
|
|
411 out value <- value
|
|
|
412 list <- value
|
|
|
413 object <- value
|
|
|
414 }{
|
|
|
415 If[[Type Of[value]] = ["String"]]
|
|
|
416 {
|
|
|
417 out value <- value
|
|
|
418 print <- value
|
|
|
419 done <- 1
|
|
|
420 }{
|
|
|
421 If[[Type Of[value]] = ["Whole Number"]]
|
|
|
422 {
|
|
|
423 out value <- value
|
|
|
424 print <- value
|
|
|
425 done <- 1
|
|
|
426 }{
|
|
|
427 If[[Type Of[value]] = ["Yes No"]]
|
|
|
428 {
|
|
|
429 out value <- value
|
|
|
430 print <- value
|
|
|
431 done <- 1
|
|
|
432 }{
|
|
|
433 If[[Type Of[value]] = ["Real Number"]]
|
|
|
434 {
|
|
|
435 out value <- value
|
|
|
436 print <- value
|
|
|
437 done <- 1
|
|
|
438 }{
|
|
|
439 object <- value
|
|
|
440 fieldlist <- [Blueprint Of[value]]Get Fields
|
|
|
441 [fieldlist]First
|
|
|
442 {
|
|
|
443 list <- _Object to Dict[value, fieldlist, ~, New@Dictionary[]]
|
|
|
444 out value <- Val[list]
|
|
|
445 }{
|
|
|
446 out value <- value
|
|
|
447 done <- 1
|
|
|
448 }
|
|
|
449 }
|
|
|
450 }
|
|
|
451 }
|
|
|
452 }
|
|
|
453
|
|
|
454 }
|
|
|
455 }
|
|
|
456 print <- Type Of[object]
|
|
|
457 index <- [list]First {}
|
|
|
458 {
|
|
|
459 print indent <- "{Empty}"
|
|
|
460 }
|
|
|
461
|
|
|
462 }
|
|
|
463
|
|
|
464 Pretty Print Helper[list,tabs,index:out]
|
|
|
465 {
|
|
|
466 newtabs <- [tabs]Append[" "]
|
|
|
467 print,new index,indented,done,value <- Get Pretty Print Value[[list]Index[index]]
|
|
|
468 Print[ [[[tabs]Append[index]]Append[": "]]Append[print] ]
|
|
|
469 {
|
|
|
470 done <- Pretty Print Helper[value,newtabs ,new index]
|
|
|
471 done <- Print[[newtabs]Append[indented]]
|
|
|
472
|
|
|
473 Val[done]
|
|
|
474 {
|
|
|
475 [list]Next[index]
|
|
|
476 {
|
|
|
477 out <- Pretty Print Helper[list, tabs, ~]
|
|
|
478 }{
|
|
|
479 out <- 1
|
|
|
480 }
|
|
|
481 }
|
|
|
482 }
|
|
|
483
|
|
|
484 }
|
|
|
485
|
|
|
486 Pretty Print[toprint,tabs:out]
|
|
|
487 {
|
|
|
488 newtabs <- [tabs]Append[" "]
|
|
|
489 ,index,indented,,value <- Get Pretty Print Value[toprint]
|
|
|
490 {
|
|
|
491 Print[[tabs]Append[~]]
|
|
|
492 {
|
|
|
493 Pretty Print Helper[value,newtabs ,index]
|
|
|
494 Print[[newtabs]Append[indented]]
|
|
|
495 }
|
|
|
496 }
|
|
|
497 out <- 1
|
|
|
498 }
|
|
|
499
|
|
|
500 _Object to Dict[object,field list,index,dict:out]
|
|
|
501 {
|
|
|
502 field <- [field list]Index[index]
|
|
|
503 [object]Get Field[field]
|
|
|
504 {
|
|
|
505 nextdict <- [dict]Set[field, ~]
|
|
|
506 }{
|
|
|
507 nextdict <- dict
|
|
|
508 }
|
|
|
509 [field list]Next[index]
|
|
|
510 {
|
|
|
511 out <- _Object to Dict[object, field list, ~, nextdict]
|
|
|
512 }{
|
|
|
513 out <- Val[nextdict]
|
|
|
514 }
|
|
|
515 }
|
|
|
516
|
|
|
517 _Keys[list,val,key:out]
|
|
|
518 {
|
|
|
519 out <- [list]Append[key]
|
|
|
520 }
|
|
|
521
|
|
|
522 Keys[container:out]
|
|
|
523 {
|
|
|
524 out <- Fold["_Keys", New@List[], container]
|
|
|
525 }
|
|
|
526
|
