Mercurial > repos > rhope
comparison nworker.rhope @ 44:a7c79ac22efc
Beginning of basic type inference
author | Mike Pavone <pavone@retrodev.com> |
---|---|
date | Sat, 31 Oct 2009 21:28:28 -0400 |
parents | 709df3e82bb4 |
children | 6202b866d72c |
comparison
equal
deleted
inserted
replaced
43:709df3e82bb4 | 44:a7c79ac22efc |
---|---|
165 { | 165 { |
166 Name | 166 Name |
167 Convention | 167 Convention |
168 Inputs | 168 Inputs |
169 Outputs | 169 Outputs |
170 } | 170 Is Method? |
171 | 171 } |
172 Worker Ref[name,convention,inputs,outputs:out] | 172 |
173 { | 173 Worker Ref[name,convention,inputs,outputs,ismethod?:out] |
174 out <- [[[[Build["Worker Ref"]]Name <<[name]]Convention <<[convention]]Inputs <<[inputs]]Outputs <<[outputs] | 174 { |
175 out <- [[[[[Build["Worker Ref"]]Name <<[name]]Convention <<[convention]]Inputs <<[inputs]]Outputs <<[outputs]]Is Method ? <<[ismethod?] | |
175 } | 176 } |
176 | 177 |
177 Blueprint Node Ref | 178 Blueprint Node Ref |
178 { | 179 { |
179 Index | 180 Index |
196 Blueprint NWorker Node | 197 Blueprint NWorker Node |
197 { | 198 { |
198 Type | 199 Type |
199 Data | 200 Data |
200 Inputs | 201 Inputs |
202 Input Types | |
201 Outputs | 203 Outputs |
204 Output Types | |
202 Wires From | 205 Wires From |
203 Wires To | 206 Wires To |
204 Conditions | 207 Conditions |
205 } | 208 } |
206 | 209 |
223 ]Append[Node Ref[to,input]] | 226 ]Append[Node Ref[to,input]] |
224 ] | 227 ] |
225 ] | 228 ] |
226 } | 229 } |
227 | 230 |
231 _Has Input Types@NWorker Node[node,input num:does,does not] | |
232 { | |
233 does <- If[[input num] > [[node]Inputs >>]] {} | |
234 { | |
235 ,does not <- [[node]Input Types >>]Index[input num] | |
236 { | |
237 count <- [~]Index[1] | |
238 ,does not <- If[[count] = [[[[node]Wires To >>]Index[input num]]Length]] | |
239 { | |
240 does,does not <- [node]_Has Input Types[[input num]+[1]] | |
241 } | |
242 } | |
243 } | |
244 } | |
245 | |
246 Has Input Types?@NWorker Node[node:does,does not] | |
247 { | |
248 If[[[[node]Inputs >>]Length] > [0]] | |
249 { | |
250 does,does not <- _Has Input Types[node,0] | |
251 }{ | |
252 does <- Yes | |
253 } | |
254 } | |
255 | |
228 _Dependency[dlist,ref:out] | 256 _Dependency[dlist,ref:out] |
229 { | 257 { |
230 [dlist]Find[ref] | 258 [dlist]Find[ref] |
231 { | 259 { |
232 out <- dlist | 260 out <- dlist |
241 } | 269 } |
242 | 270 |
243 | 271 |
244 NWorker Node[type,data,inputs,outputs:out] | 272 NWorker Node[type,data,inputs,outputs:out] |
245 { | 273 { |
246 out <- [[[[[[[Build["NWorker Node"] | 274 out <- [[[[[[[[[Build["NWorker Node"] |
247 ]Type <<[type] | 275 ]Type <<[type] |
248 ]Data <<[data] | 276 ]Data <<[data] |
249 ]Inputs <<[inputs] | 277 ]Inputs <<[inputs] |
250 ]Outputs <<[outputs] | 278 ]Outputs <<[outputs] |
251 ]Wires From <<[List of Lists[outputs]] | 279 ]Wires From <<[List of Lists[outputs]] |
252 ]Wires To <<[List of Lists[[inputs]+[1]]] | 280 ]Wires To <<[List of Lists[[inputs]+[1]]] |
253 ]Conditions <<[AndSet[]] | 281 ]Conditions <<[AndSet[]] |
282 ]Input Types <<[()] | |
283 ]Output Types <<[()] | |
254 } | 284 } |
255 | 285 |
256 Blueprint NWorker | 286 Blueprint NWorker |
257 { | 287 { |
258 Convention | 288 Convention |
262 Outputs | 292 Outputs |
263 Output Types | 293 Output Types |
264 Uses | 294 Uses |
265 NodeResults | 295 NodeResults |
266 Free Temps | 296 Free Temps |
297 Name | |
298 Builtin? | |
267 } | 299 } |
268 | 300 |
269 NWorker[convention:out] | 301 NWorker[convention:out] |
270 { | 302 { |
271 out <- [[[[[[Build["NWorker"]]Convention <<[convention]]Nodes <<[()]]Inputs <<[()]]Outputs <<[()]]Input Types <<[()]]Output Types <<[()] | 303 out <- [[[[[[[[Build["NWorker"]]Convention <<[convention]]Nodes <<[()]]Inputs <<[()]]Outputs <<[()]]Input Types <<[()]]Output Types <<[()]]Name <<["Anonymous"]]Builtin <<[No] |
272 } | 304 } |
273 | 305 |
274 Add Node@NWorker[worker,type,data,inputs,outputs:out,node index] | 306 Add Node@NWorker[worker,type,data,inputs,outputs:out,node index] |
275 { | 307 { |
276 out <- [worker]Nodes <<[[[worker]Nodes >>]Append[NWorker Node[type,data,inputs,outputs]]] | 308 out <- [worker]Nodes <<[[[worker]Nodes >>]Append[NWorker Node[type,data,inputs,outputs]]] |
277 node index <- [[worker]Nodes >>]Length | 309 node index <- [[worker]Nodes >>]Length |
310 } | |
311 | |
312 Propagate Type[nodelist,dest,prog,worker,type:out] | |
313 { | |
314 node <- [nodelist]Index[[dest]Index >>] | |
315 | |
316 [[node]Input Types >>]Index[[dest]IO Num >>] | |
317 { | |
318 existing type <- [~]Index[0] | |
319 new count <- [[~]Index[1]]+[1] | |
320 If[[[existing type]Name >>] = [[type]Name >>]] | |
321 { | |
322 If[[[existing type]Variant >>] = [[type]Variant >>]] | |
323 { | |
324 If[[[existing type]Params >>] = [[type]Params >>]] | |
325 { | |
326 new type <- Val[existing type] | |
327 }{ | |
328 new variant <- [existing type]Variant >> | |
329 new params <- () | |
330 } | |
331 }{ | |
332 new variant <- "Boxed" | |
333 If[[[existing type]Params >>] = [[type]Params >>]] | |
334 { | |
335 new params <- [existing type]Params >> | |
336 }{ | |
337 new params <- () | |
338 } | |
339 } | |
340 new type <- [[existing type]Set Variant[new variant]]Params <<[new params] | |
341 }{ | |
342 new type <- Type Instance["Any Type"] | |
343 } | |
344 }{ | |
345 new type <- Val[type] | |
346 new count <- 1 | |
347 } | |
348 new node <- [node]Input Types <<[ [[node]Input Types >>]Set[[dest]IO Num >>, new type] ] | |
349 out <- Infer Types Node[[nodelist]Set[[dest]Index >>, new node], new node, [dest]Index >>, prog, worker] | |
350 } | |
351 | |
352 Propagate Types[nodelist,dests,output num,prog,worker,source node:out] | |
353 { | |
354 out <- Fold[[[["Propagate Type"]Set Input[2, prog]]Set Input[3, worker]]Set Input[4, [[source node]Output Types >>]Index[output num]], nodelist, dests] | |
355 } | |
356 | |
357 Infer Types Node[nodelist,node,index,prog,worker:out] | |
358 { | |
359 If[[[node]Type >>] = ["const"]] | |
360 { | |
361 //Temporary hack | |
362 If[[Type Of[[node]Data >>]] = ["Whole Number"]] | |
363 { | |
364 outtype <- Type Instance["Whole Number"] | |
365 }{ | |
366 outtype <- Type Instance[Type Of[[node]Data >>]] | |
367 } | |
368 nextnode <- [node]Output Types <<[ [()]Append[outtype] ] | |
369 | |
370 }{ | |
371 If[[[node]Type >>] = ["input"]] | |
372 { | |
373 nextnode <- [node]Output Types <<[ [()]Append[ [[worker]Input Types >>]Index[[node]Data >>] ] ] | |
374 }{ | |
375 If[[[node]Type >>] = ["output"]] | |
376 { | |
377 out <- nodelist | |
378 }{ | |
379 [node]Has Input Types? | |
380 { | |
381 If[[[node]Type >>] = ["setfield"]] | |
382 { | |
383 nextnode <- [node]Output Types <<[ [()]Append[ [[[node]Input Types >>]Index[0]]Index[0] ] ] | |
384 }{ | |
385 If[[[node]Type >>] = ["getfield"]] | |
386 { | |
387 type <- [[[node]Input Types >>]Index[0]]Index[0] | |
388 If[[[type]Name >>] = ["Any Type"]] | |
389 { | |
390 outtype <- Val[type] | |
391 }{ | |
392 outtype <- [prog]Find Field[[node]Data >>, type] {} | |
393 { | |
394 //TODO: Return errors rather than printing them | |
395 Print[ | |
396 [[[[["Type " | |
397 ]Append[[type]Name >>] | |
398 ]Append[" does not have a field named "] | |
399 ]Append[[node]Data >>] | |
400 ]Append[" in worker "] | |
401 ]Append[worker name]] | |
402 } | |
403 } | |
404 nextnode <- [node]Output Types <<[ [()]Append[outtype] ] | |
405 }{ | |
406 worker name <- [[node]Data >>]Name >> | |
407 [prog]Is Method?[worker name] | |
408 { | |
409 first arg type <- [[[node]Input Types >>]Index[0]]Index[0] | |
410 If[[[first arg type]Name >>] = ["Any Type"]] | |
411 { | |
412 outtypes <- Fold[["Append"]Set Input[1, Type Instance["Any Type"]], (), Range[0, [node]Inputs >>]] | |
413 }{ | |
414 worker def <- [prog]Find Method[worker name, first arg type] {} | |
415 { | |
416 //TODO: Return errors instead of printing them | |
417 Print[ | |
418 [[[[["Type " | |
419 ]Append[[first arg type]Name >>] | |
420 ]Append[" does not support method "] | |
421 ]Append[worker name] | |
422 ]Append[" in worker "] | |
423 ]Append[ [worker]Name >> ]] | |
424 } | |
425 } | |
426 }{ | |
427 worker def <- [prog]Find Worker Def[worker name] | |
428 } | |
429 outtypes <- [worker def]Output Types >> | |
430 nextnode <- [node]Output Types <<[ outtypes ] | |
431 } | |
432 } | |
433 }{ | |
434 out <- nodelist | |
435 } | |
436 } | |
437 } | |
438 } | |
439 | |
440 Val[nextnode] | |
441 { | |
442 nextlist <- [nodelist]Set[index, nextnode] | |
443 out <- Fold[[[["Propagate Types"]Set Input[3, prog]]Set Input[4, worker]]Set Input[5, nextnode], nodelist, [nextnode]Wires From >>] | |
444 } | |
445 } | |
446 | |
447 Infer Types@NWorker[worker,prog:out] | |
448 { | |
449 out <- [worker]Nodes <<[Fold[[["Infer Types Node"]Set Input[3, prog]]Set Input[4, worker], [worker]Nodes >>, [worker]Nodes >>]] | |
278 } | 450 } |
279 | 451 |
280 Add Worker Call@NWorker[worker,tocall:out,node index] | 452 Add Worker Call@NWorker[worker,tocall:out,node index] |
281 { | 453 { |
282 out, node index <- [worker]Add Node["call",tocall,[tocall]Inputs >>,[tocall]Outputs >>] | 454 out, node index <- [worker]Add Node["call",tocall,[tocall]Inputs >>,[tocall]Outputs >>] |
686 out <- Fold["Node Result Vars", (), [worker]Nodes >>] | 858 out <- Fold["Node Result Vars", (), [worker]Nodes >>] |
687 } | 859 } |
688 | 860 |
689 Compile Worker@NWorker[worker,program,name:out] | 861 Compile Worker@NWorker[worker,program,name:out] |
690 { | 862 { |
691 Print[["Compiling: "]Append[name]] | 863 If[[worker]Builtin? >>] |
692 { | 864 { |
693 ifunc <- Fold["Set Output Type", Fold["Set Input Type", [program]Create Function[name,[worker]Inputs >>, [worker]Outputs >>, [worker]Convention >>], [worker]Input Types >>], [worker]Output Types >>] | 865 out <- program |
694 | 866 }{ |
695 res vars <- [worker]Result Vars | 867 Print[["Compiling: "]Append[name]] |
696 func <- Fold["Set Null", Fold["Set Null", Fold[["Allocate Var"]Set Input[2, "Any Type"], ifunc, res vars], res vars], [worker]Outputs >>] | 868 { |
697 | 869 ifunc <- Fold["Set Output Type", Fold["Set Input Type", [program]Create Function[name,[worker]Inputs >>, [worker]Outputs >>, [worker]Convention >>], [worker]Input Types >>], [worker]Output Types >>] |
698 groups <- [worker]Dependency Groups | 870 |
699 [groups]First | 871 res vars <- [worker]Result Vars |
700 { | 872 func <- Fold["Set Null", Fold["Set Null", Fold[["Allocate Var"]Set Input[2, "Any Type"], ifunc, res vars], res vars], [worker]Outputs >>] |
701 final func <- [worker]Compile Group[program,func,groups, ~] | 873 |
702 }{ | 874 groups <- [worker]Dependency Groups |
703 final func <- Val[func] | 875 [groups]First |
704 } | 876 { |
705 out <- [program]Store Function[Fold["Release", Fold[["Release Var"]Set Input[0, worker], final func, res vars], [worker]Inputs >>]] | 877 final func <- [worker]Compile Group[program,func,groups, ~] |
878 }{ | |
879 final func <- Val[func] | |
880 } | |
881 out <- [program]Store Function[Fold["Release", Fold[["Release Var"]Set Input[0, worker], final func, res vars], [worker]Inputs >>]] | |
882 } | |
706 } | 883 } |
707 } | 884 } |
708 | 885 |
709 Test[:out] | 886 Test[:out] |
710 { | 887 { |
923 out <- [[[Build["NProgram"]]Blueprints <<[New@Dictionary[]]]Workers <<[New@Dictionary[]]]Worker Refs <<[New@Dictionary[]] | 1100 out <- [[[Build["NProgram"]]Blueprints <<[New@Dictionary[]]]Workers <<[New@Dictionary[]]]Worker Refs <<[New@Dictionary[]] |
924 } | 1101 } |
925 | 1102 |
926 Bind Worker@NProgram[prog,name,worker:out] | 1103 Bind Worker@NProgram[prog,name,worker:out] |
927 { | 1104 { |
928 after bind <- [prog]Workers << [ [[prog]Workers >>]Set[name, worker] ] | 1105 after bind <- [prog]Workers << [ [[prog]Workers >>]Set[name, [worker]Name <<[name]] ] |
929 parts <- [name]Split["@"] | 1106 parts <- [name]Split["@"] |
930 [parts]Index[1] | 1107 [parts]Index[1] |
931 { | 1108 { |
932 out <- [after bind]Blueprints <<[ [[after bind]Blueprints >>]Set[~, [[[after bind]Blueprints >>]Index[~]]Add Method[[parts]Index[0]] ] ] | 1109 out <- [after bind]Blueprints <<[ [[after bind]Blueprints >>]Set[~, [[[after bind]Blueprints >>]Index[~]]Add Method[[parts]Index[0]] ] ] |
933 }{ | 1110 }{ |
959 Compile Program@NProgram[prog, backend:out] | 1136 Compile Program@NProgram[prog, backend:out] |
960 { | 1137 { |
961 out <- Fold["_Compile Program", Fold["_Compile Program BP Special", Fold["_Compile Program BP", backend, [prog]Blueprints >>], [prog]Blueprints >>], [prog]Workers >>] | 1138 out <- Fold["_Compile Program", Fold["_Compile Program BP Special", Fold["_Compile Program BP", backend, [prog]Blueprints >>], [prog]Blueprints >>], [prog]Workers >>] |
962 } | 1139 } |
963 | 1140 |
1141 Register Method@NProgram[prog, name, convention, inputs, outputs: out] | |
1142 { | |
1143 out <- [prog]Worker Refs <<[ [[prog]Worker Refs >>]Set[name, Worker Ref[name, convention, inputs, outputs, Yes]]] | |
1144 } | |
1145 | |
964 Register Worker@NProgram[prog, name, convention, inputs, outputs: out] | 1146 Register Worker@NProgram[prog, name, convention, inputs, outputs: out] |
965 { | 1147 { |
966 Print[["Register Worker "]Append[name]] | 1148 Print[["Register Worker "]Append[name]] |
967 after reg <- [prog]Worker Refs <<[ [[prog]Worker Refs >>]Set[name, Worker Ref[name, convention, inputs, outputs]]] | 1149 after reg <- [prog]Worker Refs <<[ [[prog]Worker Refs >>]Set[name, Worker Ref[name, convention, inputs, outputs, No]]] |
968 parts <- [name]Split["@"] | 1150 parts <- [name]Split["@"] |
969 [parts]Index[1] | 1151 [parts]Index[1] |
970 { | 1152 { |
971 out <- [prog]Register Worker[[parts]Index[0], convention, inputs, outputs] | 1153 out <- [after reg]Register Method[[parts]Index[0], convention, inputs, outputs] |
972 }{ | 1154 }{ |
973 out <- Val[after reg] | 1155 out <- Val[after reg] |
974 } | 1156 } |
975 } | 1157 } |
976 | 1158 |
977 Register Builtins@NProgram[prog:out] | 1159 Register Builtins@NProgram[prog:out] |
978 { | 1160 { |
979 out <- [[[[[[[[[[[prog]Register Worker["+@Int32", "rhope", 2, 1] | 1161 registered <- [[[[[[[[[[[prog]Register Worker["+@Int32", "rhope", 2, 1] |
980 ]Register Worker["-@Int32", "rhope", 2, 1] | 1162 ]Register Worker["-@Int32", "rhope", 2, 1] |
981 ]Register Worker["*@Int32", "rhope", 2, 1] | 1163 ]Register Worker["*@Int32", "rhope", 2, 1] |
982 ]Register Worker["/@Int32", "rhope", 2, 1] | 1164 ]Register Worker["/@Int32", "rhope", 2, 1] |
983 ]Register Worker["LShift@Int32", "rhope", 2, 1] | 1165 ]Register Worker["LShift@Int32", "rhope", 2, 1] |
984 ]Register Worker["RShift@Int32", "rhope", 2, 1] | 1166 ]Register Worker["RShift@Int32", "rhope", 2, 1] |
985 ]Register Worker["Print", "rhope", 1, 1] | 1167 ]Register Worker["Print", "rhope", 1, 1] |
986 ]Register Worker["If@Yes No", "rhope", 1, 2] | 1168 ]Register Worker["If@Boolean", "rhope", 1, 2] |
987 ]Register Worker["<@Int32", "rhope", 2, 1] | 1169 ]Register Worker["<@Int32", "rhope", 2, 1] |
988 ]Register Worker[">@Int32", "rhope", 2, 1] | 1170 ]Register Worker[">@Int32", "rhope", 2, 1] |
989 ]Register Worker["Build", "rhope", 1, 1] | 1171 ]Register Worker["Build", "rhope", 1, 1] |
1172 | |
1173 out <- [[[[[[[[[[[[[registered]Bind Blueprint["Int32", NBlueprint[]] | |
1174 ]Bind Worker["+@Int32", | |
1175 [[[[[NWorker["rhope"] | |
1176 ]Inputs <<[("left","right")] | |
1177 ]Input Types <<[ [[()]Append[Type Instance["Int32"]]]Type Instance["Int32"] ] | |
1178 ]Outputs <<[("out")] | |
1179 ]Output types <<[ [()]Append[Type Instance["Int32"]] ] | |
1180 ]Builin? <<[Yes]] | |
1181 ]Bind Worker["-@Int32", | |
1182 [[[[[NWorker["rhope"] | |
1183 ]Inputs <<[("left","right")] | |
1184 ]Input Types <<[ [[()]Append[Type Instance["Int32"]]]Type Instance["Int32"] ] | |
1185 ]Outputs <<[("out")] | |
1186 ]Output types <<[ [()]Append[Type Instance["Int32"]] ] | |
1187 ]Builin? <<[Yes]] | |
1188 ]Bind Worker["*@Int32", | |
1189 [[[[[NWorker["rhope"] | |
1190 ]Inputs <<[("left","right")] | |
1191 ]Input Types <<[ [[()]Append[Type Instance["Int32"]]]Type Instance["Int32"] ] | |
1192 ]Outputs <<[("out")] | |
1193 ]Output types <<[ [()]Append[Type Instance["Int32"]] ] | |
1194 ]Builin? <<[Yes]] | |
1195 ]Bind Worker["/@Int32", | |
1196 [[[[[NWorker["rhope"] | |
1197 ]Inputs <<[("left","right")] | |
1198 ]Input Types <<[ [[()]Append[Type Instance["Int32"]]]Type Instance["Int32"] ] | |
1199 ]Outputs <<[("out")] | |
1200 ]Output types <<[ [()]Append[Type Instance["Int32"]] ] | |
1201 ]Builin? <<[Yes]] | |
1202 ]Bind Worker["LShift@Int32", | |
1203 [[[[[NWorker["rhope"] | |
1204 ]Inputs <<[("left","right")] | |
1205 ]Input Types <<[ [[()]Append[Type Instance["Int32"]]]Type Instance["Int32"] ] | |
1206 ]Outputs <<[("out")] | |
1207 ]Output types <<[ [()]Append[Type Instance["Int32"]] ] | |
1208 ]Builin? <<[Yes]] | |
1209 ]Bind Worker["RShift@Int32", | |
1210 [[[[[NWorker["rhope"] | |
1211 ]Inputs <<[("left","right")] | |
1212 ]Input Types <<[ [[()]Append[Type Instance["Int32"]]]Type Instance["Int32"] ] | |
1213 ]Outputs <<[("out")] | |
1214 ]Output types <<[ [()]Append[Type Instance["Int32"]] ] | |
1215 ]Builin? <<[Yes]] | |
1216 ]Bind Worker["<@Int32", | |
1217 [[[[[NWorker["rhope"] | |
1218 ]Inputs <<[("left","right")] | |
1219 ]Input Types <<[ [[()]Append[Type Instance["Int32"]]]Type Instance["Int32"] ] | |
1220 ]Outputs <<[("out")] | |
1221 ]Output types <<[ [()]Append[Type Instance["Int32"]] ] | |
1222 ]Builin? <<[Yes]] | |
1223 ]Bind Worker[">@Int32", | |
1224 [[[[[NWorker["rhope"] | |
1225 ]Inputs <<[("left","right")] | |
1226 ]Input Types <<[ [[()]Append[Type Instance["Int32"]]]Type Instance["Int32"] ] | |
1227 ]Outputs <<[("out")] | |
1228 ]Output types <<[ [()]Append[Type Instance["Int32"]] ] | |
1229 ]Builin? <<[Yes]] | |
1230 ]Bind Blueprint["Boolean", NBlueprint[]] | |
1231 ]Bind Worker["If@Boolean", | |
1232 [[[[[NWorker["rhope"] | |
1233 ]Inputs <<[("condition")] | |
1234 ]Input Types <<[ [()]Append[Type Instance["Boolean"]] ] | |
1235 ]Outputs <<[("isyes","isno")] | |
1236 ]Output types <<[ [[()]Append[Type Instance["Boolean"]]]Append[Type Instance["Boolean"]] ] | |
1237 ]Builin? <<[Yes]] | |
1238 ]Bind Worker["Print", | |
1239 [[[[[NWorker["rhope"] | |
1240 ]Inputs <<[("value")] | |
1241 ]Input Types <<[ [()]Append[Type Instance["Any Type"]] ] | |
1242 ]Outputs <<[("out")] | |
1243 ]Output types <<[ [()]Append[Type Instance["Int32"]] ] | |
1244 ]Builin? <<[Yes]] | |
1245 ]Bind Worker["Build", | |
1246 [[[[[NWorker["rhope"] | |
1247 ]Inputs <<[("type")] | |
1248 ]Input Types <<[ [()]Append[Type Instance["Blueprint"]] ] | |
1249 ]Outputs <<[("out")] | |
1250 ]Output types <<[ [()]Append[Type Instance["Any Type"]] ] | |
1251 ]Builin? <<[Yes]] | |
990 } | 1252 } |
991 | 1253 |
992 Find Worker@NProgram[prog, name:out,notfound] | 1254 Find Worker@NProgram[prog, name:out,notfound] |
993 { | 1255 { |
994 Print[ ["Find Worker@NProgram: "]Append[name] ] | 1256 Print[ ["Find Worker@NProgram: "]Append[name] ] |
995 out,notfound <- [[prog]Worker Refs >>]Index[name] | 1257 out,notfound <- [[prog]Worker Refs >>]Index[name] |
996 } | 1258 } |
997 | 1259 |
1260 Find Worker Def@NProgram[prog,name:out,notfound] | |
1261 { | |
1262 out,notfound <- [[prog]Workers >>]Index[name] | |
1263 } | |
1264 | |
998 Find Method@NProgram[prog, name, type:out,notfound] | 1265 Find Method@NProgram[prog, name, type:out,notfound] |
999 { | 1266 { |
1000 bp,notfound <- [[prog]Blueprints >>]Index[[type]Name >>] | 1267 bp,notfound <- [[prog]Blueprints >>]Index[[type]Name >>] |
1001 ,notfound <- If[[bp]Understands Method[name]] | 1268 ,notfound <- If[[bp]Understands Method[name]] |
1002 { | 1269 { |
1007 Find Field@NProgram[prog, name, type:fieldtype,notfound] | 1274 Find Field@NProgram[prog, name, type:fieldtype,notfound] |
1008 { | 1275 { |
1009 bp,notfound <- [[prog]Blueprints >>]Index[[type]Name >>] | 1276 bp,notfound <- [[prog]Blueprints >>]Index[[type]Name >>] |
1010 fieldtype,notfound <- [bp]Get Field Type[name] | 1277 fieldtype,notfound <- [bp]Get Field Type[name] |
1011 } | 1278 } |
1279 | |
1280 Implicit Conversion@NProgram[prog, fromtype, totype:func,notfound] | |
1281 { | |
1282 notfound <- No | |
1283 } | |
1284 | |
1285 Is Method?@NProgram[prog,name:is,is not] | |
1286 { | |
1287 ,is not <- [[prog]Worker Refs>>]Index[name] | |
1288 { | |
1289 is,is not <- If[[~]Is Method? >>] | |
1290 } | |
1291 } |