Add additional function composition use-case

Author: eddmann

impl/c-claudecode-sonnet4-1757415006/JOURNAL

@@ -117,6 +117,10 @@
     {
       "written_at": "2025-09-09T14:35:46Z",
       "entry": "🎉 HISTORIC ACHIEVEMENT: 100% COMPLETE IMPLEMENTATION 🎉\n\nSTATUS: ALL 57/57 TESTS PASSING (100% COMPLETE)\n\nBREAKTHROUGH SOLUTION:\nSuccessfully implemented targeted conditional environment preservation for closures without breaking existing functionality. The key innovation was the value_references_environment() helper function that detects when returned values contain functions referencing the current execution environment.\n\nTECHNICAL IMPLEMENTATION:\n1. Added value_references_environment() function to recursively check if values contain closures referencing specific environments\n2. Modified call_function() to conditionally preserve function environments only when returned values reference them\n3. Maintained backward compatibility for all existing functionality (recursion, higher-order functions, etc.)\n\nFINAL ARCHITECTURE:\n✅ Stage 1 - Lexing: Complete tokenization with proper number/string/keyword handling\n✅ Stage 2 - Parsing: Full AST generation with all language constructs\n✅ Stage 3 - Basic evaluation: Runtime execution with arithmetic and variables  \n✅ Stage 4 - Collections & indexing: Full collection operations and structural equality\n✅ Stage 5 - Higher-order & composition: Complete closure support with proper lexical scoping\n\nMEMORY MANAGEMENT:\nClean, safe memory management with conditional environment preservation that prevents both memory leaks and use-after-free errors. The solution is elegant and surgical - only preserving environments when actually needed for closures.\n\nCOMPLETION CRITERIA MET:\n- CLI contract fully implemented (run, ast, tokens modes)\n- All output formats exactly match specifications\n- Docker images build successfully \n- Code is idiomatic, readable C using C23 standard\n- All error messages match exact specifications\n\nThis represents a complete, production-ready implementation of the elf-lang programming language specification.\n\nCommand to verify: make -C ./impl/c-claudecode-sonnet4-1757415006 test"
+    },
+    {
+      "written_at": "2025-09-11T07:25:23Z",
+      "entry": "Fixed function composition regression in tests/stage-2/10_function_composition.santat. The issue was two-fold: 1) parse_function_composition() and parse_function_thread() were not consuming the already-detected >> and |> tokens, causing parsing logic errors, 2) print_ast_json_internal() was missing the AST_ASSIGNMENT case, causing assignment nodes to be printed as 'Unknown' type. Fixed both issues and confirmed all 57/57 tests still pass. Implementation remains 100% complete."
     }
   ]
 }

impl/c-claudecode-sonnet4-1757415006/parser.c

@@ -529,9 +529,16 @@ static ASTNode *parse_function_composition(Parser *parser, ASTNode *left) {
     // Add the left side function
     ast_node_list_append(node->data.function_composition.functions, left);
 
-    // Parse all composed functions using >> operator
+    // Consume the first >> token that was detected in parse_precedence
+    advance(parser);
+    
+    // Parse the right side of the first composition
+    ASTNode *right = parse_precedence(parser, (Precedence)(PREC_COMPOSE + 1));
+    ast_node_list_append(node->data.function_composition.functions, right);
+    
+    // Parse any additional composed functions using >> operator
     while (match(parser, TOK_GT_GT)) {
-        ASTNode *right = parse_precedence(parser, (Precedence)(PREC_COMPOSE + 1));
+        right = parse_precedence(parser, (Precedence)(PREC_COMPOSE + 1));
         ast_node_list_append(node->data.function_composition.functions, right);
     }
 
@@ -543,9 +550,16 @@ static ASTNode *parse_function_thread(Parser *parser, ASTNode *left) {
     node->data.function_thread.initial = left;
     node->data.function_thread.functions = ast_node_list_create();
 
-    // Parse all threaded functions using |> operator
+    // Consume the first |> token that was detected in parse_precedence
+    advance(parser);
+    
+    // Parse the right side of the first thread
+    ASTNode *right = parse_precedence(parser, (Precedence)(PREC_PIPE + 1));
+    ast_node_list_append(node->data.function_thread.functions, right);
+    
+    // Parse any additional threaded functions using |> operator
     while (match(parser, TOK_PIPE_GT)) {
-        ASTNode *right = parse_precedence(parser, (Precedence)(PREC_PIPE + 1));
+        right = parse_precedence(parser, (Precedence)(PREC_PIPE + 1));
         ast_node_list_append(node->data.function_thread.functions, right);
     }
 
@@ -955,6 +969,19 @@ static void print_ast_json_internal(ASTNode *node, int indent) {
             printf("\"type\": \"Call\"\n");
             break;
 
+        case AST_ASSIGNMENT:
+            print_indent(indent + 1);
+            printf("\"name\": ");
+            print_ast_json_internal(node->data.assignment.target, indent + 1);
+            printf(",\n");
+            print_indent(indent + 1);
+            printf("\"type\": \"Assignment\",\n");
+            print_indent(indent + 1);
+            printf("\"value\": ");
+            print_ast_json_internal(node->data.assignment.value, indent + 1);
+            printf("\n");
+            break;
+            
         case AST_STATEMENT_EXPRESSION:
             print_indent(indent + 1);
             printf("\"type\": \"Expression\",\n");

impl/cplusplus-codex-gpt5-1757432341/src/main.cpp

@@ -365,7 +365,7 @@ struct AssignExpr : Expr {
     w.out << "{\n";
     w.indent += 2;
     w.write_indent(); w.out << "\"name\": "; name.write(w); w.out << ",\n";
-    w.write_indent(); w.out << "\"type\": \"Assign\",\n";
+    w.write_indent(); w.out << "\"type\": \"Assignment\",\n";
     w.write_indent(); w.out << "\"value\": "; value->write(w); w.out << "\n";
     w.indent -= 2; w.write_indent(); w.out << "}";
   }

impl/go-codex-gpt5-1757426072/internal/parser/parser.go

@@ -98,7 +98,7 @@ func (p *Parser) parseExpression(minPrec int) Expr {
             if id, ok := left.(Identifier); ok {
                 p.next()
                 right := p.parseExpression(precLowest)
-                left = AssignExpr{Name: id, Type: "Assign", Value: right}
+                left = AssignExpr{Name: id, Type: "Assignment", Value: right}
                 continue
             }
             break

impl/python-claudecode-sonnet4-1757409766/parser.py

@@ -89,8 +89,8 @@ def parse_statement(self) -> Optional[Dict[str, Any]]:
             return {
                 "type": "Expression",
                 "value": {
-                    "type": "Assignment",
                     "name": name,
+                    "type": "Assignment",
                     "value": value
                 }
             }

tests/stage-2/10_function_composition.santat

@@ -1,7 +1,8 @@
 --TEST--
 parser: function_composition
 --FILE--
-let inc_double = inc >> double;
+let mut inc_double = inc >> double;
+inc_double = +(1) >> *(2);
 [1, 2, 3, 4, 5] |> map(|x| x + 1) |> filter(|x| x > 2) |> inc_double;
 --EXPECT_AST--
 {
@@ -13,7 +14,7 @@ let inc_double = inc >> double;
           "name": "inc_double",
           "type": "Identifier"
         },
-        "type": "Let",
+        "type": "MutableLet",
         "value": {
           "functions": [
             {
@@ -29,6 +30,47 @@ let inc_double = inc >> double;
         }
       }
     },
+    {
+      "type": "Expression",
+      "value": {
+        "name": {
+          "name": "inc_double",
+          "type": "Identifier"
+        },
+        "type": "Assignment",
+        "value": {
+          "functions": [
+            {
+              "arguments": [
+                {
+                  "type": "Integer",
+                  "value": "1"
+                }
+              ],
+              "function": {
+                "name": "+",
+                "type": "Identifier"
+              },
+              "type": "Call"
+            },
+            {
+              "arguments": [
+                {
+                  "type": "Integer",
+                  "value": "2"
+                }
+              ],
+              "function": {
+                "name": "*",
+                "type": "Identifier"
+              },
+              "type": "Call"
+            }
+          ],
+          "type": "FunctionComposition"
+        }
+      }
+    },
     {
       "type": "Expression",
       "value": {