summary refs log blame commit diff stats
path: root/doc/pydoc/ranger.container.html
blob: 28cd9e854d6ef3f0bd2cb79c1da8e36b02b3b64b (plain) (tree) 
f07bb12f ^


ef0157ff ^

f07bb12f ^







ef0157ff ^

f07bb12f ^










3e18db75 ^




f07bb12f ^


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


                                                              
                                                                   






                                                                                                                                                                                 
                                                                                                                                                                                                                         









                                                                                                                                              



                                                                                           

                                                                    
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<html><head><title>Python: package ranger.container</title>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
</head><body bgcolor="#f0f0f8">

<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="heading">
<tr bgcolor="#7799ee">
<td valign=bottom>&nbsp;<br>
<font color="#ffffff" face="helvetica, arial">&nbsp;<br><big><big><strong><a href="ranger.html"><font color="#ffffff">ranger</font></a>.container</strong></big></big></font></td
><td align=right valign=bottom
><font color="#ffffff" face="helvetica, arial"><a href=".">index</a><br><a href="file:/home/hut/code/ranger/ranger/container/__init__.py">/home/hut/code/ranger/ranger/container/__init__.py</a></font></td></tr></table>
    <p><tt>This&nbsp;package&nbsp;includes&nbsp;container-objects&nbsp;which&nbsp;are<br>
used&nbsp;to&nbsp;manage&nbsp;stored&nbsp;data</tt></p>
<p>
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="section">
<tr bgcolor="#aa55cc">
<td colspan=3 valign=bottom>&nbsp;<br>
<font color="#ffffff" face="helvetica, arial"><big><strong>Package Contents</strong></big></font></td></tr>
    
<tr><td bgcolor="#aa55cc"><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</tt></td><td>&nbsp;</td>
<td width="100%"><table width="100%" summary="list"><tr><td width="25%" valign=top><a href="ranger.container.bookmarks.html">bookmarks</a><br>
<a href="ranger.container.history.html">history</a><br>
</td><td width="25%" valign=top><a href="ranger.container.keybuffer.html">keybuffer</a><br>
<a href="ranger.container.keymap.html">keymap</a><br>
</td><td width="25%" valign=top><a href="ranger.container.tags.html">tags</a><br>
</td><td width="25%" valign=top></td></tr></table></td></tr></table>
</body></html>
generated by cgit-pink 1.4.1-2-gfad0 (git 2.36.2.497.gbbea4dcf42) at 2024-11-14 19:16:31 +0000
eb59487d1012f837bd07ec336f5'>1ead3562 ^ 
7a84094a ^

60448ff1 ^

1ead3562 ^

60448ff1 ^




7a84094a ^


60448ff1 ^

63bd37bc ^


1ead3562 ^

b436291f ^

7a84094a ^

63bd37bc ^

1ead3562 ^

63bd37bc ^




7a84094a ^


63bd37bc ^

a87118d9 ^

5059f32d ^

07de3e95 ^




5059f32d ^


07de3e95 ^


a87118d9 ^









a87118d9 ^


60448ff1 ^


7afe09fb ^

60448ff1 ^



6c96a437 ^

60448ff1 ^

04a2a292 ^


60448ff1 ^

04a2a292 ^

60448ff1 ^


a542b5a9 ^



2b250717 ^

a542b5a9 ^

60448ff1 ^

a542b5a9 ^




2b250717 ^

a542b5a9 ^

60448ff1 ^




04a2a292 ^




a542b5a9 ^











60448ff1 ^

65c119d4 ^

60448ff1 ^

63bd37bc ^

53930831 ^

65c119d4 ^




b55b15a9 ^



65c905fe ^

6c96a437 ^

af023b32 ^

63bd37bc ^

e7f23901 ^

63bd37bc ^

af023b32 ^

60448ff1 ^

e7f23901 ^






6c96a437 ^

af023b32 ^



6dd67576 ^

af023b32 ^

60448ff1 ^



65c119d4 ^



















e7f23901 ^






af023b32 ^

65c119d4 ^

6dd67576 ^


090cad5c ^

6dd67576 ^


3473c63a ^

c6034af3 ^

53930831 ^


af023b32 ^

53930831 ^

b74744cd ^

7afe09fb ^

4f32f024 ^



1ead3562 ^

7a84094a ^

4f32f024 ^



7a84094a ^

4f32f024 ^




e0659ab3 ^

7cdd5187 ^



1ead3562 ^

7cdd5187 ^


d52406cc ^

7cdd5187 ^




e0659ab3 ^

7cdd5187 ^

4d238fd7 ^



1b76245c ^

7cdd5187 ^


4d238fd7 ^


6c96a437 ^

7cdd5187 ^



6c96a437 ^

7cdd5187 ^





4f5bb5b6 ^

6dd67576 ^



01ce563d ^

760f683f ^

6dd67576 ^

760f683f ^

6dd67576 ^


b89b8224 ^

6dd67576 ^



504292f6 ^

4f5bb5b6 ^












7f707a51 ^

4f5bb5b6 ^







6c96a437 ^

61880904 ^

2b250717 ^

61880904 ^



4f5bb5b6 ^


61880904 ^









71190ea5 ^



816ffe20 ^

71190ea5 ^

67c10a17 ^



71190ea5 ^

816ffe20 ^

71190ea5 ^








67c10a17 ^































































































































































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

210
211

212
213
214
215
216
217
218
219
220

221
222

223
224

225

226
227
228

229

230

231
232

233

234

235
236

237
238
239

240

241

242

243
244
245
246

247

248

249
250
251
252

253
254
255
256

257
258
259
260
261
262
263
264
265
266
267

268

269

270

271

272

273
274
275
276

277
278
279

280

281

282

283

284

285

286

287

288
289
290
291
292
293

294

295
296
297

298

299

300
301
302

303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321

322
323
324
325
326
327

328

329

330
331

332

333
334

335

336

337
338

339

340

341

342

343
344
345

346

347

348
349
350

351

352
353
354
355

356

357
358
359

360

361
362

363

364
365
366
367

368

369

370
371
372

373

374
375

376
377

378

379
380
381

382

383
384
385
386
387

388

389
390
391

392

393

394

395

396
397

398

399
400
401

402

403
404
405
406
407
408
409
410
411
412
413
414

415

416
417
418
419
420
421
422

423

424

425

426
427
428

429
430

431
432
433
434
435
436
437
438
439

440
441
442

443

444

445
446
447

448

449

450
451
452
453
454
455
456
457

458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616




                                                                           
                               
          
                     
 
                      





                              
                                       



                                                                       
 





                                                                          
       



                                                                            
                                           
                                           
 
                                                                                              
                                                  
                                                 
                                                      
                                                                                    
                                                   






                                                                                 
                                                           







                                                                           

                         
 
                                                                    
 






                                             
                                                                                                                     


                                              
                                                                                                                                                                  











                                                                                                                    



                                                                                                                                   

                                                                      

                                                                           

                                                                   
                                                          



                                           

 











                                                  












                                          










                                      
































                                                                              



                                        
          
                     
 
                          



                  

                                                                      
 

                                      
          
                                        
                                                
 
                          



                  

                                                                                                 
 
                                                                                   
                                                                                                    



                                                                 

                                                                    

                                                                                                                         








                                                                    

 

                                                                        
       


                                                                                                                  
                                                  
                                                 

                                                                  
                                                   
                                                               

                                                                                                                       


                                                                                                                                     
                                                                                                                                                         
       
     



                                                                                               
                                                                                                                                     
       



     



                                                                                   










                                                                
                                       
                 
                                                                                    
                                  
                                            



                                     


                                                                    
                                        
                                                             
                                                       
                                            
                         
     
                                                                         
   





                                                                   
                                                           


                                                                      
                                                                
   


                       


















                                                  





                                                       
 
       

                                                        
                                       

 
                                     
                            

                                     
                                            
   
                                                              
 


                                          
          
                             


                                                                                                              
                      



                  
                                                                                                                  


                                            
          

                                                                            
                        



                  
                                                                                   
 


                                              
                                                                                                                             

                 

                                               
                                                                                        


                                                                     
                                                                                  




                                                               
 


                                                    
                      
                                                                 
 
                        

                  
                  


         
                                                             











                                             
                                                      






                                                                               
                                                      
                                               
                                                                                                                                                              


                                                                         

   








                                                         


                                                             
                                                       
 


                                   
          
                                      







                                                    






























































































































































                                                                                                                                                                                                                                 
//: So far we've been calling a fixed recipe in each instruction, but we'd
//: also like to make the recipe a variable, pass recipes to "higher-order"
//: recipes, return recipes from recipes and so on.

:(scenario call_literal_recipe)
def main [
  1:num <- call f, 34
]
def f x:num -> y:num [
  local-scope
  load-ingredients
  y <- copy x
]
+mem: storing 34 in location 1

:(before "End Mu Types Initialization")
put(Type_ordinal, "recipe-literal", 0);
// 'recipe' variables can store recipe-literal
type_ordinal recipe = put(Type_ordinal, "recipe", Next_type_ordinal++);
get_or_insert(Type, recipe).name = "recipe";

:(after "Deduce Missing Type(x, caller)")
if (!x.type)
  try_initialize_recipe_literal(x, caller);
:(before "Type Check in Type-ingredient-aware check_or_set_types_by_name")
if (!x.type)
  try_initialize_recipe_literal(x, variant);
:(code)
void try_initialize_recipe_literal(reagent& x, const recipe& caller) {
  if (x.type) return;
  if (!contains_key(Recipe_ordinal, x.name)) return;
  if (contains_reagent_with_non_recipe_literal_type(caller, x.name)) return;
  x.type = new type_tree("recipe-literal");
  x.set_value(get(Recipe_ordinal, x.name));
}
bool contains_reagent_with_non_recipe_literal_type(const recipe& caller, const string& name) {
  for (int i = 0;  i < SIZE(caller.steps);  ++i) {
    const instruction& inst = caller.steps.at(i);
    for (int i = 0;  i < SIZE(inst.ingredients);  ++i)
      if (is_matching_non_recipe_literal(inst.ingredients.at(i), name)) return true;
    for (int i = 0;  i < SIZE(inst.products);  ++i)
      if (is_matching_non_recipe_literal(inst.products.at(i), name)) return true;
  }
  return false;
}
bool is_matching_non_recipe_literal(const reagent& x, const string& name) {
  if (x.name != name) return false;
  if (!x.type) return false;
  return !x.type->atom || x.type->name != "recipe-literal";
}

//: It's confusing to use variable names that are also recipe names. Always
//: assume variable types override recipe literals.
:(scenario error_on_recipe_literal_used_as_a_variable)
% Hide_errors = true;
def main [
  local-scope
  a:bool <- equal break 0
  break:bool <- copy 0
]
+error: main: missing type for 'break' in 'a:bool <- equal break, 0'

:(before "End Primitive Recipe Declarations")
CALL,
:(before "End Primitive Recipe Numbers")
put(Recipe_ordinal, "call", CALL);
:(before "End Primitive Recipe Checks")
case CALL: {
  if (inst.ingredients.empty()) {
    raise << maybe(get(Recipe, r).name) << "'call' requires at least one ingredient (the recipe to call)\n" << end();
    break;
  }
  if (!is_mu_recipe(inst.ingredients.at(0))) {
    raise << maybe(get(Recipe, r).name) << "first ingredient of 'call' should be a recipe, but got '" << inst.ingredients.at(0).original_string << "'\n" << end();
    break;
  }
  break;
}
:(before "End Primitive Recipe Implementations")
case CALL: {
  // Begin Call
  if (Trace_stream) {
    ++Trace_stream->callstack_depth;
    trace("trace") << "indirect 'call': incrementing callstack depth to " << Trace_stream->callstack_depth << end();
    assert(Trace_stream->callstack_depth < 9000);  // 9998-101 plus cushion
  }
  if (!ingredients.at(0).at(0)) {
    raise << maybe(current_recipe_name()) << "tried to call empty recipe in '" << to_string(current_instruction()) << "'" << end();
    break;
  }
  const call& caller_frame = current_call();
  instruction/*copy*/ call_instruction = to_instruction(caller_frame);
  call_instruction.operation = ingredients.at(0).at(0);
  call_instruction.ingredients.erase(call_instruction.ingredients.begin());
  Current_routine->calls.push_front(call(ingredients.at(0).at(0)));
  ingredients.erase(ingredients.begin());  // drop the callee
  finish_call_housekeeping(call_instruction, ingredients);
  // not done with caller
  write_products = false;
  fall_through_to_next_instruction = false;
  break;
}

:(scenario call_variable)
def main [
  {1: (recipe number -> number)} <- copy f
  2:num <- call {1: (recipe number -> number)}, 34
]
def f x:num -> y:num [
  local-scope
  load-ingredients
  y <- copy x
]
+mem: storing 34 in location 2

:(scenario call_literal_recipe_repeatedly)
def main [
  1:num <- call f, 34
  1:num <- call f, 35
]
def f x:num -> y:num [
  local-scope
  load-ingredients
  y <- copy x
]
+mem: storing 34 in location 1
+mem: storing 35 in location 1

:(scenario call_shape_shifting_recipe)
def main [
  1:num <- call f, 34
]
def f x:_elem -> y:_elem [
  local-scope
  load-ingredients
  y <- copy x
]
+mem: storing 34 in location 1

:(scenario call_shape_shifting_recipe_inside_shape_shifting_recipe)
def main [
  1:num <- f 34
]
def f x:_elem -> y:_elem [
  local-scope
  load-ingredients
  y <- call g x
]
def g x:_elem -> y:_elem [
  local-scope
  load-ingredients
  y <- copy x
]
+mem: storing 34 in location 1

:(scenario call_shape_shifting_recipe_repeatedly_inside_shape_shifting_recipe)
def main [
  1:num <- f 34
]
def f x:_elem -> y:_elem [
  local-scope
  load-ingredients
  y <- call g x
  y <- call g x
]
def g x:_elem -> y:_elem [
  local-scope
  load-ingredients
  y <- copy x
]
+mem: storing 34 in location 1

//:: check types for 'call' instructions

:(scenario call_check_literal_recipe)
% Hide_errors = true;
def main [
  1:num <- call f, 34
]
def f x:point -> y:point [
  local-scope
  load-ingredients
  y <- copy x
]
+error: main: ingredient 0 has the wrong type at '1:num <- call f, 34'
+error: main: product 0 has the wrong type at '1:num <- call f, 34'

:(scenario call_check_variable_recipe)
% Hide_errors = true;
def main [
  {1: (recipe point -> point)} <- copy f
  2:num <- call {1: (recipe point -> point)}, 34
]
def f x:point -> y:point [
  local-scope
  load-ingredients
  y <- copy x
]
+error: main: ingredient 0 has the wrong type at '2:num <- call {1: (recipe point -> point)}, 34'
+error: main: product 0 has the wrong type at '2:num <- call {1: (recipe point -> point)}, 34'

:(before "End resolve_ambiguous_call(r, index, inst, caller_recipe) Special-cases")
if (inst.name == "call" && !inst.ingredients.empty() && is_recipe_literal(inst.ingredients.at(0))) {
  resolve_indirect_ambiguous_call(r, index, inst, caller_recipe);
  return;
}
:(code)
bool is_recipe_literal(const reagent& x) {
  return x.type && x.type->atom && x.type->name == "recipe-literal";
}
void resolve_indirect_ambiguous_call(const recipe_ordinal r, int index, instruction& inst, const recipe& caller_recipe) {
  instruction inst2;
  inst2.name = inst.ingredients.at(0).name;
  for (int i = /*skip recipe*/1;  i < SIZE(inst.ingredients);  ++i)
    inst2.ingredients.push_back(inst.ingredients.at(i));
  for (int i = 0;  i < SIZE(inst.products);  ++i)
    inst2.products.push_back(inst.products.at(i));
  resolve_ambiguous_call(r, index, inst2, caller_recipe);
  inst.ingredients.at(0).name = inst2.name;
  inst.ingredients.at(0).set_value(get(Recipe_ordinal, inst2.name));
}

:(after "Transform.push_back(check_instruction)")
Transform.push_back(check_indirect_calls_against_header);  // idempotent
:(code)
void check_indirect_calls_against_header(const recipe_ordinal r) {
  trace(9991, "transform") << "--- type-check 'call' instructions inside recipe " << get(Recipe, r).name << end();
  const recipe& caller = get(Recipe, r);
  for (int i = 0;  i < SIZE(caller.steps);  ++i) {
    const instruction& inst = caller.steps.at(i);
    if (!is_indirect_call(inst.operation)) continue;
    if (inst.ingredients.empty()) continue;  // error raised above
    const reagent& callee = inst.ingredients.at(0);
    if (!is_mu_recipe(callee)) continue;  // error raised above
    const recipe callee_header = is_literal(callee) ? get(Recipe, callee.value) : from_reagent(inst.ingredients.at(0));
    if (!callee_header.has_header) continue;
    if (is_indirect_call_with_ingredients(inst.operation)) {
      for (long int i = /*skip callee*/1;  i < min(SIZE(inst.ingredients), SIZE(callee_header.ingredients)+/*skip callee*/1);  ++i) {
        if (!types_coercible(callee_header.ingredients.at(i-/*skip callee*/1), inst.ingredients.at(i)))
          raise << maybe(caller.name) << "ingredient " << i-/*skip callee*/1 << " has the wrong type at '" << to_original_string(inst) << "'\n" << end();
      }
    }
    if (is_indirect_call_with_products(inst.operation)) {
      for (long int i = 0;  i < min(SIZE(inst.products), SIZE(callee_header.products));  ++i) {
        if (is_dummy(inst.products.at(i))) continue;
        if (!types_coercible(callee_header.products.at(i), inst.products.at(i)))
          raise << maybe(caller.name) << "product " << i << " has the wrong type at '" << to_original_string(inst) << "'\n" << end();
      }
    }
  }
}

bool is_indirect_call(const recipe_ordinal r) {
  return is_indirect_call_with_ingredients(r) || is_indirect_call_with_products(r);
}

bool is_indirect_call_with_ingredients(const recipe_ordinal r) {
  if (r == CALL) return true;
  // End is_indirect_call_with_ingredients Special-cases
  return false;
}
bool is_indirect_call_with_products(const recipe_ordinal r) {
  if (r == CALL) return true;
  // End is_indirect_call_with_products Special-cases
  return false;
}

recipe from_reagent(const reagent& r) {
  assert(r.type);
  recipe result_header;  // will contain only ingredients and products, nothing else
  result_header.has_header = true;
  // Begin Reagent->Recipe(r, recipe_header)
  if (r.type->atom) {
    assert(r.type->name == "recipe");
    return result_header;
  }
  const type_tree* root_type = r.type->atom ? r.type : r.type->left;
  assert(root_type->atom);
  assert(root_type->name == "recipe");
  const type_tree* curr = r.type->right;
  for (/*nada*/;  curr && !curr->atom;  curr = curr->right) {
    if (curr->left->atom && curr->left->name == "->") {
      curr = curr->right;  // skip delimiter
      goto read_products;
    }
    result_header.ingredients.push_back(next_recipe_reagent(curr->left));
  }
  if (curr) {
    assert(curr->atom);
    result_header.ingredients.push_back(next_recipe_reagent(curr));
    return result_header;  // no products
  }
  read_products:
  for (/*nada*/;  curr && !curr->atom;  curr = curr->right)
    result_header.products.push_back(next_recipe_reagent(curr->left));
  if (curr) {
    assert(curr->atom);
    result_header.products.push_back(next_recipe_reagent(curr));
  }
  return result_header;
}

:(before "End Unit Tests")
void test_from_reagent_atomic() {
  reagent a("{f: recipe}");
  recipe r_header = from_reagent(a);
  CHECK(r_header.ingredients.empty());
  CHECK(r_header.products.empty());
}
void test_from_reagent_non_atomic() {
  reagent a("{f: (recipe number -> number)}");
  recipe r_header = from_reagent(a);
  CHECK_EQ(SIZE(r_header.ingredients), 1);
  CHECK_EQ(SIZE(r_header.products), 1);
}
void test_from_reagent_reads_ingredient_at_end() {
  reagent a("{f: (recipe number number)}");
  recipe r_header = from_reagent(a);
  CHECK_EQ(SIZE(r_header.ingredients), 2);
  CHECK(r_header.products.empty());
}
void test_from_reagent_reads_sole_ingredient_at_end() {
  reagent a("{f: (recipe number)}");
  recipe r_header = from_reagent(a);
  CHECK_EQ(SIZE(r_header.ingredients), 1);
  CHECK(r_header.products.empty());
}

:(code)
reagent next_recipe_reagent(const type_tree* curr) {
  if (!curr->left) return reagent("recipe:"+curr->name);
  return reagent(new type_tree(*curr));
}

bool is_mu_recipe(const reagent& r) {
  if (!r.type) return false;
  if (r.type->atom) {
    // End is_mu_recipe Atom Cases(r)
    return r.type->name == "recipe-literal";
  }
  return r.type->left->atom && r.type->left->name == "recipe";
}

:(scenario copy_typecheck_recipe_variable)
% Hide_errors = true;
def main [
  3:num <- copy 34  # abc def
  {1: (recipe number -> number)} <- copy f  # store literal in a matching variable
  {2: (recipe boolean -> boolean)} <- copy {1: (recipe number -> number)}  # mismatch between recipe variables
]
def f x:num -> y:num [
  local-scope
  load-ingredients
  y <- copy x
]
+error: main: can't copy '{1: (recipe number -> number)}' to '{2: (recipe boolean -> boolean)}'; types don't match

:(scenario copy_typecheck_recipe_variable_2)
% Hide_errors = true;
def main [
  {1: (recipe number -> number)} <- copy f  # mismatch with a recipe literal
]
def f x:bool -> y:bool [
  local-scope
  load-ingredients
  y <- copy x
]
+error: main: can't copy 'f' to '{1: (recipe number -> number)}'; types don't match

:(before "End Matching Types For Literal(to)")
if (is_mu_recipe(to)) {
  if (!contains_key(Recipe, from.value)) {
    raise << "trying to store recipe " << from.name << " into " << to_string(to) << " but there's no such recipe\n" << end();
    return false;
  }
  const recipe& rrhs = get(Recipe, from.value);
  const recipe& rlhs = from_reagent(to);
  for (long int i = 0;  i < min(SIZE(rlhs.ingredients), SIZE(rrhs.ingredients));  ++i) {
    if (!types_match(rlhs.ingredients.at(i), rrhs.ingredients.at(i)))
      return false;
  }
  for (long int i = 0;  i < min(SIZE(rlhs.products), SIZE(rrhs.products));  ++i) {
    if (!types_match(rlhs.products.at(i), rrhs.products.at(i)))
      return false;
  }
  return true;
}

:(scenario call_variable_compound_ingredient)
def main [
  {1: (recipe (address number) -> number)} <- copy f
  2:&:num <- copy null
  3:num <- call {1: (recipe (address number) -> number)}, 2:&:num
]
def f x:&:num -> y:num [
  local-scope
  load-ingredients
  y <- deaddress x
]
$error: 0

//: make sure we don't accidentally break on a recipe literal
:(scenario jump_forbidden_on_recipe_literals)
% Hide_errors = true;
def foo [
  local-scope
]
def main [
  local-scope
  {
    break-if foo
  }
]
# error should be as if foo is not a recipe
+error: main: missing type for 'foo' in 'break-if foo'

:(before "End JUMP_IF Checks")
check_for_recipe_literals(inst, get(Recipe, r));
:(before "End JUMP_UNLESS Checks")
check_for_recipe_literals(inst, get(Recipe, r));
:(code)
void check_for_recipe_literals(const instruction& inst, const recipe& caller) {
  for (int i = 0;  i < SIZE(inst.ingredients);  ++i) {
    if (is_mu_recipe(inst.ingredients.at(i))) {
      raise << maybe(caller.name) << "missing type for '" << inst.ingredients.at(i).original_string << "' in '" << to_original_string(inst) << "'\n" << end();
      if (is_present_in_ingredients(caller, inst.ingredients.at(i).name))
        raise << "  did you forget 'load-ingredients'?\n" << end();
    }
  }
}

:(scenario load_ingredients_missing_error_3)
% Hide_errors = true;
def foo {f: (recipe num -> num)} [
  local-scope
  b:num <- call f, 1
]
+error: foo: missing type for 'f' in 'b:num <- call f, 1'
+error:   did you forget 'load-ingredients'?

:(before "End Mu Types Initialization")
put(Type_abbreviations, "function", new_type_tree("recipe"));
put(Type_abbreviations, "fn", new_type_tree("recipe"));

//: copying functions to variables

:(scenario copy_recipe_to_variable)
def main [
  {1: (fn number -> number)} <- copy f
  2:num <- call {1: (function number -> number)}, 34
]
def f x:num -> y:num [
  local-scope
  load-ingredients
  y <- copy x
]
+mem: storing 34 in location 2

:(scenario copy_overloaded_recipe_to_variable)
def main [
  local-scope
  {x: (fn num -> num)} <- copy f
  1:num/raw <- call x, 34
]
# variant f
def f x:bool -> y:bool [
  local-scope
  load-ingredients
  y <- copy x
]
# variant f_2
def f x:num -> y:num [
  local-scope
  load-ingredients
  y <- copy x
]
# x contains f_2
+mem: storing 34 in location 1

:(before "End resolve_ambiguous_call(r, index, inst, caller_recipe) Special-cases")
if (inst.name == "copy") {
  for (int i = 0;  i < SIZE(inst.ingredients);  ++i) {
    if (!is_recipe_literal(inst.ingredients.at(i))) continue;
    if (non_ghost_size(get_or_insert(Recipe_variants, inst.ingredients.at(i).name)) < 1) continue;
    // potentially overloaded recipe
    string new_name = resolve_ambiguous_call(inst.ingredients.at(i).name, inst.products.at(i), r, index, caller_recipe);
    if (new_name == "") continue;
    inst.ingredients.at(i).name = new_name;
    inst.ingredients.at(i).value = get(Recipe_ordinal, new_name);
  }
  return;
}
:(code)
string resolve_ambiguous_call(const string& recipe_name, const reagent& call_types, const recipe_ordinal r, int index, const recipe& caller_recipe) {
  instruction inst;
  inst.name = recipe_name;
  if (!is_mu_recipe(call_types)) return "";  // error raised elsewhere
  if (is_recipe_literal(call_types)) return "";  // error raised elsewhere
  construct_fake_call(call_types, inst);
  resolve_ambiguous_call(r, index, inst, caller_recipe);
  return inst.name;
}
void construct_fake_call(const reagent& recipe_var, instruction& out) {
  assert(recipe_var.type->left->name == "recipe");
  type_tree* stem = NULL;
  for (stem = recipe_var.type->right;  stem && stem->left->name != "->";  stem = stem->right)
    out.ingredients.push_back(copy(stem->left));
  if (stem == NULL) return;
  for (/*skip '->'*/stem = stem->right;  stem;  stem = stem->right)
    out.products.push_back(copy(stem->left));
}

:(scenario copy_shape_shifting_recipe_to_variable)
def main [
  local-scope
  {x: (fn num -> num)} <- copy f
  1:num/raw <- call x, 34
]
def f x:_elem -> y:_elem [
  local-scope
  load-inputs
  y <- copy x
]
+mem: storing 34 in location 1

//: passing function literals to (higher-order) functions

:(scenario pass_overloaded_recipe_literal_to_ingredient)
# like copy_overloaded_recipe_to_variable except we bind 'x' in the course of
# a 'call' rather than 'copy'
def main [
  1:num <- g f
]
def g {x: (fn num -> num)} -> result:num [
  local-scope
  load-ingredients
  result <- call x, 34
]
# variant f
def f x:bool -> y:bool [
  local-scope
  load-ingredients
  y <- copy x
]
# variant f_2
def f x:num -> y:num [
  local-scope
  load-ingredients
  y <- copy x
]
# x contains f_2
+mem: storing 34 in location 1

:(after "End resolve_ambiguous_call(r, index, inst, caller_recipe) Special-cases")
for (int i = 0;  i < SIZE(inst.ingredients);  ++i) {
  if (!is_mu_recipe(inst.ingredients.at(i))) continue;
  if (non_ghost_size(get_or_insert(Recipe_variants, inst.ingredients.at(i).name)) < 1) continue;
  if (get(Recipe_ordinal, inst.name) < MAX_PRIMITIVE_RECIPES) continue;
  if (non_ghost_size(get_or_insert(Recipe_variants, inst.name)) > 1) {
    raise << maybe(caller_recipe.name) << "sorry, we're not yet smart enough to simultaneously guess which overloads you want for '" << inst.name << "' and '" << inst.ingredients.at(i).name << "'\n" << end();
    return;
  }
  const recipe& callee = get(Recipe, get(Recipe_ordinal, inst.name));
  if (!callee.has_header) {
    raise << maybe(caller_recipe.name) << "sorry, we're not yet smart enough to guess which variant of '" << inst.ingredients.at(i).name << "' you want, when the caller '" << inst.name << "' doesn't have a header\n" << end();
    return;
  }
  string new_name = resolve_ambiguous_call(inst.ingredients.at(i).name, callee.ingredients.at(i), r, index, caller_recipe);
  if (new_name != "") {
    inst.ingredients.at(i).name = new_name;
    inst.ingredients.at(i).value = get(Recipe_ordinal, new_name);
  }
}

:(scenario return_overloaded_recipe_literal_to_caller)
def main [
  local-scope
  {x: (fn num -> num)} <- g
  1:num/raw <- call x, 34
]
def g -> {x: (fn num -> num)} [
  local-scope
  return f
]
# variant f
def f x:bool -> y:bool [
  local-scope
  load-ingredients
  y <- copy x
]
# variant f_2
def f x:num -> y:num [
  local-scope
  load-ingredients
  y <- copy x
]
# x contains f_2
+mem: storing 34 in location 1

:(before "End resolve_ambiguous_call(r, index, inst, caller_recipe) Special-cases")
if (inst.name == "return" || inst.name == "reply") {
  for (int i = 0;  i < SIZE(inst.ingredients);  ++i) {
    if (!is_recipe_literal(inst.ingredients.at(i))) continue;
    if (non_ghost_size(get_or_insert(Recipe_variants, inst.ingredients.at(i).name)) < 1) continue;
    // potentially overloaded recipe
    if (!caller_recipe.has_header) {
      raise << maybe(caller_recipe.name) << "sorry, we're not yet smart enough to guess which variant of '" << inst.ingredients.at(i).name << "' you want, without a recipe header\n" << end();
      return;
    }
    string new_name = resolve_ambiguous_call(inst.ingredients.at(i).name, caller_recipe.products.at(i), r, index, caller_recipe);
    if (new_name == "") continue;
    inst.ingredients.at(i).name = new_name;
    inst.ingredients.at(i).value = get(Recipe_ordinal, new_name);
  }
  return;
}
generated by cgit-pink 1.4.1-2-gfad0 (git 2.36.2.497.gbbea4dcf42) at 2024-11-14 19:16:29 +0000