Mercurial > repos > rhope

comparison extendlib.rhope @ 0:76568becd6d6

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Rhope Alpha 2a source import
author Mike Pavone <pavone@retrodev.com>
date Tue, 28 Apr 2009 23:06:07 +0000
parents
children b3f71490858c
comparison
equal deleted inserted replaced
-1:000000000000 0:76568becd6d6
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