MQ-1: a positional fold step lowers like the named form (position from std.algebra's fold signature)

dag/std/algebra.dag

@@ -359,6 +359,37 @@ fn collection_filter_shape() -> AlgebraFieldTemplate {
   { name: "filter", param_types: [ReceiverSelf, CallableOf { params: [ReceiverElement], return_type: NamedTemplate { name: "Bool" } }], return_type: ReceiverSelf, size_effect: Present { value: IdentityEffect }, cost_shape: Present { value: ShapeIterateBody }, callback_element_position: Present { value: 0 } }
 }
 
+// Collection fold is this one template, declared once for both collection profiles that carry it,
+// and its param_types IS the free-call signature, receiver first, the same convention as `map` and
+// `filter` (and the one v1.compiler.method pair_declared_names reads when it pairs `names: ["xs", ..]`
+// with a row). The receiver slot was missing here while every sibling carried it, so the row did not
+// say where the step sits in `fold(xs, init, step)`; v2.compiler.fold_lowering reads that position
+// from this row through template_step_position rather than from a literal index.
+fn collection_fold_shape() -> AlgebraFieldTemplate {
+  { name: "fold", param_types: [ReceiverSelf, AlgebraTypeVariable { id: "FoldAccumulator" }, CallableOf { params: [AlgebraTypeVariable { id: "FoldAccumulator" }, ReceiverElement], return_type: AlgebraTypeVariable { id: "FoldAccumulator" } }], return_type: AlgebraTypeVariable { id: "FoldAccumulator" }, size_effect: none, cost_shape: Present { value: ShapeIterateBody }, callback_element_position: Present { value: 1 } }
+}
+
+type StepPositionScan {
+  next: Int
+  found: Int?
+}
+
+// The position of a template's step -- its first callable parameter -- in the free-call signature
+// the row declares. Absent when the row takes no callable.
+fn template_step_position(t: AlgebraFieldTemplate) -> Int? {
+  let scan = fold(t.param_types, init: StepPositionScan { next: 0, found: none }, f: fn(acc, p) {
+    match acc.found {
+      Present { value: _ } => acc
+      Absent =>
+        match p {
+          CallableOf { params: _, return_type: _ } => StepPositionScan { next: acc.next + 1, found: Present { value: acc.next } }
+          _ => StepPositionScan { next: acc.next + 1, found: none }
+        }
+    }
+  })
+  scan.found
+}
+
 fn is_collection_filter_template(t: AlgebraFieldTemplate) -> Bool {
   let proto = collection_filter_shape()
   t.return_type == proto.return_type
@@ -768,7 +799,7 @@ fn finite_power_set_templates() -> List<AlgebraFieldTemplate> {
     collection_filter_shape(),
     { name: "map", param_types: [ReceiverSelf, CallableOf { params: [ReceiverElement], return_type: AlgebraTypeVariable { id: "MappedElement" } }], return_type: ContainerOf { source: SameAsReceiver, element: AlgebraTypeVariable { id: "MappedElement" } }, size_effect: none, cost_shape: Present { value: ShapeIterateBody }, callback_element_position: Present { value: 0 } },
     { name: "flat_map", param_types: [ReceiverSelf, CallableOf { params: [ReceiverElement], return_type: ContainerOf { source: SameAsReceiver, element: AlgebraTypeVariable { id: "MappedElement" } } }], return_type: ContainerOf { source: SameAsReceiver, element: AlgebraTypeVariable { id: "MappedElement" } }, size_effect: none, cost_shape: Present { value: ShapeIterateBody }, callback_element_position: Present { value: 0 } },
-    { name: "fold", param_types: [AlgebraTypeVariable { id: "FoldAccumulator" }, CallableOf { params: [AlgebraTypeVariable { id: "FoldAccumulator" }, ReceiverElement], return_type: AlgebraTypeVariable { id: "FoldAccumulator" } }], return_type: AlgebraTypeVariable { id: "FoldAccumulator" }, size_effect: none, cost_shape: Present { value: ShapeIterateBody }, callback_element_position: Present { value: 1 } },
+    collection_fold_shape(),
     { name: "any", param_types: [ReceiverSelf, CallableOf { params: [ReceiverElement], return_type: NamedTemplate { name: "Bool" } }], return_type: NamedTemplate { name: "Bool" }, size_effect: none, cost_shape: Present { value: ShapeIterateBody }, callback_element_position: Present { value: 0 } },
     { name: "all", param_types: [ReceiverSelf, CallableOf { params: [ReceiverElement], return_type: NamedTemplate { name: "Bool" } }], return_type: NamedTemplate { name: "Bool" }, size_effect: none, cost_shape: Present { value: ShapeIterateBody }, callback_element_position: Present { value: 0 } },
     { name: "count", param_types: [ReceiverSelf], return_type: NamedTemplate { name: "std.nat.Nat" }, size_effect: none, cost_shape: Present { value: ShapeLinearScan }, callback_element_position: none },
@@ -813,7 +844,7 @@ fn free_monoid_collection_templates() -> List<AlgebraFieldTemplate> {
     { name: "map", param_types: [ReceiverSelf, CallableOf { params: [ReceiverElement], return_type: AlgebraTypeVariable { id: "MappedElement" } }], return_type: ContainerOf { source: SameAsReceiver, element: AlgebraTypeVariable { id: "MappedElement" } }, size_effect: none, cost_shape: Present { value: ShapeIterateBody }, callback_element_position: Present { value: 0 } },
     collection_filter_shape(),
     { name: "flat_map", param_types: [ReceiverSelf, CallableOf { params: [ReceiverElement], return_type: ContainerOf { source: SameAsReceiver, element: AlgebraTypeVariable { id: "MappedElement" } } }], return_type: ContainerOf { source: SameAsReceiver, element: AlgebraTypeVariable { id: "MappedElement" } }, size_effect: none, cost_shape: Present { value: ShapeIterateBody }, callback_element_position: Present { value: 0 } },
-    { name: "fold", param_types: [AlgebraTypeVariable { id: "FoldAccumulator" }, CallableOf { params: [AlgebraTypeVariable { id: "FoldAccumulator" }, ReceiverElement], return_type: AlgebraTypeVariable { id: "FoldAccumulator" } }], return_type: AlgebraTypeVariable { id: "FoldAccumulator" }, size_effect: none, cost_shape: Present { value: ShapeIterateBody }, callback_element_position: Present { value: 1 } },
+    collection_fold_shape(),
     { name: "any", param_types: [ReceiverSelf, CallableOf { params: [ReceiverElement], return_type: NamedTemplate { name: "Bool" } }], return_type: NamedTemplate { name: "Bool" }, size_effect: none, cost_shape: Present { value: ShapeIterateBody }, callback_element_position: Present { value: 0 } },
     { name: "all", param_types: [ReceiverSelf, CallableOf { params: [ReceiverElement], return_type: NamedTemplate { name: "Bool" } }], return_type: NamedTemplate { name: "Bool" }, size_effect: none, cost_shape: Present { value: ShapeIterateBody }, callback_element_position: Present { value: 0 } },
     { name: "count", param_types: [ReceiverSelf], return_type: NamedTemplate { name: "std.nat.Nat" }, size_effect: none, cost_shape: Present { value: ShapeLinearScan }, callback_element_position: none },

src/v1/stage0/src/std_algebra.rs

@@ -469,6 +469,66 @@ pub fn collection_filter_shape() -> Rc<AlgebraFieldTemplate> {
     })
 }
 
+pub fn collection_fold_shape() -> Rc<AlgebraFieldTemplate> {
+    Rc::new(AlgebraFieldTemplate {
+        name: "fold".to_string(),
+        param_types: Rc::new(vec![
+            Rc::new(AlgebraTypeTemplate::ReceiverSelf),
+            Rc::new(AlgebraTypeTemplate::AlgebraTypeVariable {
+                id: "FoldAccumulator".to_string(),
+            }),
+            Rc::new(AlgebraTypeTemplate::CallableOf {
+                params: Rc::new(vec![
+                    Rc::new(AlgebraTypeTemplate::AlgebraTypeVariable {
+                        id: "FoldAccumulator".to_string(),
+                    }),
+                    Rc::new(AlgebraTypeTemplate::ReceiverElement),
+                ]),
+                return_type: Rc::new(AlgebraTypeTemplate::AlgebraTypeVariable {
+                    id: "FoldAccumulator".to_string(),
+                }),
+            }),
+        ]),
+        return_type: Rc::new(AlgebraTypeTemplate::AlgebraTypeVariable {
+            id: "FoldAccumulator".to_string(),
+        }),
+        size_effect: std::option::Option::None,
+        cost_shape: Some(CostShape::ShapeIterateBody),
+        callback_element_position: Some(1),
+    })
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct StepPositionScan {
+    pub next: i64,
+    pub found: Option<i64>,
+}
+
+pub fn template_step_position(t: Rc<AlgebraFieldTemplate>) -> Option<i64> {
+    {
+        let scan = t.param_types.clone().iter().cloned().fold(
+            StepPositionScan {
+                next: 0,
+                found: std::option::Option::None,
+            },
+            |acc: StepPositionScan, p: Rc<AlgebraTypeTemplate>| match acc.found.clone() {
+                Some(_) => acc.clone(),
+                std::option::Option::None => match (*p.clone()).clone() {
+                    AlgebraTypeTemplate::CallableOf { .. } => StepPositionScan {
+                        next: v1_rt::int_add(acc.next.clone(), 1),
+                        found: Some(acc.next.clone()),
+                    },
+                    _ => StepPositionScan {
+                        next: v1_rt::int_add(acc.next.clone(), 1),
+                        found: std::option::Option::None,
+                    },
+                },
+            },
+        );
+        scan.found.clone()
+    }
+}
+
 pub fn is_collection_filter_template(t: Rc<AlgebraFieldTemplate>) -> bool {
     {
         let proto = collection_filter_shape();
@@ -1217,31 +1277,7 @@ pub fn finite_power_set_templates() -> Rc<Vec<Rc<AlgebraFieldTemplate>>> {
             cost_shape: Some(CostShape::ShapeIterateBody),
             callback_element_position: Some(0),
         }),
-        Rc::new(AlgebraFieldTemplate {
-            name: "fold".to_string(),
-            param_types: Rc::new(vec![
-                Rc::new(AlgebraTypeTemplate::AlgebraTypeVariable {
-                    id: "FoldAccumulator".to_string(),
-                }),
-                Rc::new(AlgebraTypeTemplate::CallableOf {
-                    params: Rc::new(vec![
-                        Rc::new(AlgebraTypeTemplate::AlgebraTypeVariable {
-                            id: "FoldAccumulator".to_string(),
-                        }),
-                        Rc::new(AlgebraTypeTemplate::ReceiverElement),
-                    ]),
-                    return_type: Rc::new(AlgebraTypeTemplate::AlgebraTypeVariable {
-                        id: "FoldAccumulator".to_string(),
-                    }),
-                }),
-            ]),
-            return_type: Rc::new(AlgebraTypeTemplate::AlgebraTypeVariable {
-                id: "FoldAccumulator".to_string(),
-            }),
-            size_effect: std::option::Option::None,
-            cost_shape: Some(CostShape::ShapeIterateBody),
-            callback_element_position: Some(1),
-        }),
+        collection_fold_shape(),
         Rc::new(AlgebraFieldTemplate {
             name: "any".to_string(),
             param_types: Rc::new(vec![
@@ -1597,31 +1633,7 @@ pub fn free_monoid_collection_templates() -> Rc<Vec<Rc<AlgebraFieldTemplate>>> {
             cost_shape: Some(CostShape::ShapeIterateBody),
             callback_element_position: Some(0),
         }),
-        Rc::new(AlgebraFieldTemplate {
-            name: "fold".to_string(),
-            param_types: Rc::new(vec![
-                Rc::new(AlgebraTypeTemplate::AlgebraTypeVariable {
-                    id: "FoldAccumulator".to_string(),
-                }),
-                Rc::new(AlgebraTypeTemplate::CallableOf {
-                    params: Rc::new(vec![
-                        Rc::new(AlgebraTypeTemplate::AlgebraTypeVariable {
-                            id: "FoldAccumulator".to_string(),
-                        }),
-                        Rc::new(AlgebraTypeTemplate::ReceiverElement),
-                    ]),
-                    return_type: Rc::new(AlgebraTypeTemplate::AlgebraTypeVariable {
-                        id: "FoldAccumulator".to_string(),
-                    }),
-                }),
-            ]),
-            return_type: Rc::new(AlgebraTypeTemplate::AlgebraTypeVariable {
-                id: "FoldAccumulator".to_string(),
-            }),
-            size_effect: std::option::Option::None,
-            cost_shape: Some(CostShape::ShapeIterateBody),
-            callback_element_position: Some(1),
-        }),
+        collection_fold_shape(),
         Rc::new(AlgebraFieldTemplate {
             name: "any".to_string(),
             param_types: Rc::new(vec![

src/v2/compiler/fold_lowering.dag

@@ -2,6 +2,7 @@ module v2.compiler.fold_lowering
 
 import v2.extdeps.languages.dag {
   dag_call_named_arg_value_optional,
+  dag_call_positional_arg_value_optional,
   dag_lex_token_symbol,
   parse_production_captured_child_optional,
   parse_production_emitted_identity_optional
@@ -24,6 +25,7 @@ import v2.std.diagnostic {
   outcome_accepted,
   outcome_rejected
 }
+import std.algebra { collection_fold_shape, template_step_position }
 import v2.std.grammar { node_atom_identity_optional }
 import std.algebra { Cons, Empty }
 import v2.std.collection { List }
@@ -130,6 +132,37 @@ fn fold_step_argument_name(head: Symbol) -> Optional<Symbol> {
   }
 }
 
+// THE STEP'S POSITION IS READ FROM THE PRIMITIVE'S DECLARED SIGNATURE, NEVER FROM A LITERAL
+// INDEX. `fold` is the collection primitive whose free-call signature std.algebra
+// collection_fold_shape declares, receiver first, so `fold(xs, 0, fn(acc, y) { .. })` places its
+// step where template_step_position reads it off that row; both spellings then reach the same
+// step node and lower to the same Loop through the one path below.
+//
+// fold_list, fold_list_right and fold_node answer Absent, and that is a declared frontier rather
+// than an omission: their signatures are ordinary v2.std.algebra / v2.std.node fn declarations with
+// no data projection this stage can read, and no positional call site of any of them exists (DESIGN
+// section 3c). A positional one keeps reading as StepByName -- the counted
+// FoldCallStepFormUnresolved state -- until those signatures are readable here. The row also carries
+// no parameter NAMES, so the name above stays authored per head; the two facts are separate.
+fn some_step_argument_position(position: Int) -> Optional<Int> {
+  Present { value: position }
+}
+
+fn no_step_argument_position() -> Optional<Int> {
+  Absent
+}
+
+fn fold_step_argument_position(head: Symbol) -> Optional<Int> {
+  if head == ^fold {
+    match template_step_position(t: collection_fold_shape()) {
+      Present { value: k } => some_step_argument_position(position: k)
+      Absent => no_step_argument_position()
+    }
+  } else {
+    no_step_argument_position()
+  }
+}
+
 // Descends the CAPTURED-CHILD CHAIN of the step argument's value and nothing else: an expr
 // wrapper chain has exactly one captured child per link, so this reaches the step's own
 // production or runs out. It never folds over siblings, which is what stops a literal written
@@ -157,6 +190,17 @@ fn fold_call_step_form(fold_call: Node, head: Symbol) -> FoldStepForm {
     Absent => StepByName
     Present { value: step_name } =>
       match dag_call_named_arg_value_optional(node: fold_call, name: step_name) {
+        Present { value: step_value } => fold_step_form_at(node: step_value)
+        Absent => fold_call_positional_step_form(fold_call: fold_call, head: head)
+      }
+  }
+}
+
+fn fold_call_positional_step_form(fold_call: Node, head: Symbol) -> FoldStepForm {
+  match fold_step_argument_position(head: head) {
+    Absent => StepByName
+    Present { value: position } =>
+      match dag_call_positional_arg_value_optional(node: fold_call, position: position) {
         Absent => StepByName
         Present { value: step_value } => fold_step_form_at(node: step_value)
       }

src/v2/extdeps/languages/dag.dag

@@ -5615,6 +5615,67 @@ fn dag_call_named_arg_value_under_children(node: Node, name: Symbol) -> Optional
   })
 }
 
+// The DIRECT argument at one declared POSITION of one call, under the same stopping rule as the
+// named lookup above: the walk counts each ^dag_surface_arg it reaches, in source order, and never
+// descends into one. A NAMED argument sitting at that position answers Absent -- its slot is
+// decided by its name, never by where it was written -- so a call reaches its step by exactly one
+// of the two readings.
+type DagPositionalArgScan {
+  seen: Int
+  decided: Bool
+  found: Optional<Node>
+}
+
+fn dag_call_positional_arg_value_optional(node: Node, position: Int) -> Optional<Node> {
+  let scan = dag_call_positional_arg_scan(
+    node: node,
+    position: position,
+    acc: DagPositionalArgScan { seen: 0, decided: false, found: dag_named_arg_value_absent() }
+  )
+  scan.found
+}
+
+fn dag_call_positional_arg_scan(node: Node, position: Int, acc: DagPositionalArgScan) -> DagPositionalArgScan {
+  if acc.decided {
+    acc
+  } else {
+    match parse_production_emitted_identity_optional(node: node) {
+      Present { value: id } =>
+        if id == ^dag_surface_arg {
+          dag_call_positional_arg_visit(node: node, position: position, acc: acc)
+        } else {
+          dag_call_positional_arg_scan_children(node: node, position: position, acc: acc)
+        }
+      Absent => dag_call_positional_arg_scan_children(node: node, position: position, acc: acc)
+    }
+  }
+}
+
+fn dag_call_positional_arg_visit(node: Node, position: Int, acc: DagPositionalArgScan) -> DagPositionalArgScan {
+  if acc.seen == position {
+    DagPositionalArgScan { seen: acc.seen + 1, decided: true, found: dag_positional_arg_value(arg: node) }
+  } else {
+    DagPositionalArgScan { seen: acc.seen + 1, decided: false, found: acc.found }
+  }
+}
+
+fn dag_positional_arg_value(arg: Node) -> Optional<Node> {
+  match parse_production_captured_child_optional(node: arg) {
+    Absent => dag_named_arg_value_absent()
+    Present { value: arg_capture } =>
+      match dag_named_arg_value_optional(arg_capture: arg_capture) {
+        Present { value: _ } => dag_named_arg_value_absent()
+        Absent => dag_named_arg_value_present(node: arg_capture)
+      }
+  }
+}
+
+fn dag_call_positional_arg_scan_children(node: Node, position: Int, acc: DagPositionalArgScan) -> DagPositionalArgScan {
+  fold(node.children, init: acc, f: fn(inner, e) {
+    dag_call_positional_arg_scan(node: e.target, position: position, acc: inner)
+  })
+}
+
 fn dag_named_arg_value_absent() -> Optional<Node> {
   Absent
 }