gram-hs-migrate: updated use of gram-hs; reflected api changes in plisp, which now uses pattern and pure

Author: akollegger

docs/pattern-state-lisp-design.md

@@ -38,7 +38,7 @@ Where:
 ```scheme
 ;; Pure function, runtime handles state threading
 (lambda (state)
-  (pattern-with 
+  (pattern 
     (pattern-value state)
     (cons new-item (pattern-elements state))))
 ```
@@ -54,7 +54,7 @@ Tools in Pattern Agents are naturally `Pattern v -> Pattern v` transformations:
 (lambda (state)
   (let* ((user (pattern-find state is-user?))
          (name (pattern-query user "$.name")))
-    (pattern-with 
+    (pattern 
       {:greeting (string-append "Hello, " name)}
       (pattern-elements state))))
 ```
@@ -72,7 +72,7 @@ Tools compose as functions:
 (define format-greeting
   (lambda (state)
     (let ((user (get-user state)))
-      (pattern {:greeting (string-append "Hello, " (pattern-value user))}))))
+      (pure {:greeting (string-append "Hello, " (pattern-value user))}))))
 
 ;; Compose: format-greeting ∘ get-user
 (define greet-user 
@@ -177,8 +177,8 @@ Pattern is a **native Lisp value type**, not accessed through host-calls.
 
 ```scheme
 ;; Pattern construction
-(pattern value)                    ; Atomic pattern
-(pattern-with value elements)      ; Pattern with elements
+(pure value)                       ; Atomic pattern
+(pattern value elements)          ; Pattern with elements
 (from-list value [v1 v2 v3])      ; Convenience constructor
 
 ;; Pattern transformation (returns new pattern)
@@ -220,7 +220,7 @@ Since programs are pure, **host-calls** are the only mechanism for side effects:
                         "SELECT * FROM users WHERE id = ?" 
                         user-id)))
       ;; Incorporate result into new state pattern
-      (pattern-with 
+      (pattern 
         {:query-result db-result}
         (pattern-elements state)))))
 ```
@@ -316,12 +316,12 @@ executeTool toolName runtime = do
              (db-result (host-call 'db-query 
                           "SELECT * FROM orders WHERE id = ?" 
                           order-id))
-             (order-pattern (pattern-with 
+             (order-pattern (pattern 
                              {:type "Order"
                               :id order-id
                               :data db-result}
                              [])))
-        (pattern-with
+        (pattern
           (pattern-value state)
           (cons order-pattern (pattern-elements state)))))
   ]
@@ -337,14 +337,14 @@ executeTool toolName runtime = do
          (db-result (host-call 'db-query 
                       "SELECT * FROM orders WHERE id = ?" 
                       order-id))
-         (order-pattern (pattern-with 
-                         {:type "Order"
-                          :id order-id
-                          :data db-result}
-                         [])))
-    (pattern-with
-      (pattern-value state)
-      (cons order-pattern (pattern-elements state)))))
+             (order-pattern (pattern 
+                             {:type "Order"
+                              :id order-id
+                              :data db-result}
+                             [])))
+        (pattern
+          (pattern-value state)
+          (cons order-pattern (pattern-elements state)))))
 ```
 
 ## Benefits for Pattern Agents

docs/plisp-serialization-design.md

@@ -606,7 +606,7 @@ Every Pattern Lisp runtime provides a standard environment (`initialEnv`) contai
 - Arithmetic primitives: `+`, `-`, `*`, `/`
 - Comparison primitives: `>`, `<`, `=`, `/=`
 - String primitives: `string-append`, `string-length`, `substring`
-- Pattern primitives: `pattern`, `pattern-with`, `pattern-value`, etc.
+- Pattern primitives: `pure`, `pattern`, `pattern-value`, etc.
 
 ### Environment Filtering
 
@@ -1245,10 +1245,10 @@ Pattern Subject → Check Label:
 **S-expression**:
 ```scheme
 (lambda (state)
-  (pattern-with
+  (pattern
     (pattern-value state)
     (cons
-      (pattern "new-item")
+      (pure "new-item")
       (pattern-elements state))))
 ```
 
@@ -1262,7 +1262,7 @@ Pattern Subject → Check Label:
     [:Parameters | state],
     [:Body |
       [:List |
-        [:Symbol {name: "pattern-with"}],
+        [:Symbol {name: "pattern"}],
         [:List | [:Symbol {name: "pattern-value"}], state],
         [:List |
           [:Symbol {name: "cons"}],

examples/pattern-basics.plisp

@@ -2,10 +2,10 @@
 ;; Demonstrates creating and querying Pattern values
 
 ;; Create an atomic pattern
-(define hello (pattern "hello"))
+(define hello (pure "hello"))
 
 ;; Create a pattern with elements (empty for now)
-(define root (pattern-with "root" '()))
+(define root (pattern "root" '()))
 
 ;; Query pattern decoration
 (pattern-value hello)

examples/pattern-predicates.plisp

@@ -9,9 +9,9 @@
 ;; ============================================================================
 
 ;; Create some atomic patterns for testing
-(define p1 (pattern 10))
-(define p2 (pattern 20))
-(define p3 (pattern 30))
+(define p1 (pure 10))
+(define p2 (pure 20))
+(define p3 (pure 30))
 
 ;; pattern-find: Find the first matching subpattern
 ;; Returns the matching pattern, or empty list if no match

specs/003-pattern-state-functions/quickstart.md

@@ -35,11 +35,11 @@ cabal build all
 
 ```scheme
 ;; Create an atomic pattern
-(define atomic (pattern "hello"))
+(define atomic (pure "hello"))
 
 ;; Create a pattern with elements
-(define with-elements (pattern-with "root" 
-  (list (pattern "child1") (pattern "child2"))))
+(define with-elements (pattern "root" 
+  (list (pure "child1") (pure "child2"))))
 ```
 
 ### 2. Querying Pattern Values
@@ -64,10 +64,10 @@ All tools must follow the canonical form `(lambda (state) ...)`:
 ```scheme
 ;; Simple tool that adds a greeting
 (lambda (state)
-  (pattern-with 
+  (pattern 
     (pattern-value state)  ; Preserve decoration
     (cons 
-      (pattern "Hello from Pattern Lisp!")
+      (pure "Hello from Pattern Lisp!")
       (pattern-elements state))))
 ```
 
@@ -173,13 +173,13 @@ Deserializes runtime from a Gram file and resumes execution.
 (lambda (state)
   (let ((count (pattern-size state))
         (depth (pattern-depth state)))
-    (pattern-with
+    (pattern
       (pattern-value state)
-      (cons 
-        (pattern-with "summary" 
-          (list 
-            (pattern count)
-            (pattern depth)))
+      (cons
+        (pattern "summary" 
+          (list
+            (pure count)
+            (pure depth)))
         (pattern-elements state)))))
 
 ;; 2. Save to file: state-reader.plisp
@@ -269,13 +269,13 @@ it "round-trips closures" $ do
 ;; Define multiple tools
 (define add-timestamp
   (lambda (state)
-    (pattern-with (pattern-value state)
-      (cons (pattern "timestamp") (pattern-elements state)))))
+    (pattern (pattern-value state)
+      (cons (pure "timestamp") (pattern-elements state)))))
 
 (define add-metadata
   (lambda (state)
-    (pattern-with (pattern-value state)
-      (cons (pattern "metadata") (pattern-elements state)))))
+    (pattern (pattern-value state)
+      (cons (pure "metadata") (pattern-elements state)))))
 
 ;; Compose tools
 (lambda (state)
@@ -289,9 +289,9 @@ it "round-trips closures" $ do
 (lambda (state)
   (let ((incrementer (lambda (x) (+ x 1)))
         (doubler (lambda (x) (* x 2))))
-    (pattern-with "functions"
-      (list (pattern incrementer)
-            (pattern doubler)))))
+    (pattern "functions"
+      (list (pure incrementer)
+            (pure doubler)))))
 ```
 
 ### State Filtering
@@ -302,7 +302,7 @@ it "round-trips closures" $ do
   (let ((filtered (pattern-find state 
                     (lambda (p) 
                       (> (pattern-size p) 1)))))
-    (pattern-with "filtered" (list filtered))))
+    (pattern "filtered" (list filtered))))
 ```
 
 ## Troubleshooting

specs/006-gram-hs-migration/tasks.md

@@ -24,9 +24,9 @@
 
 **Purpose**: Verify prerequisites and understand migration requirements
 
-- [ ] T001 Verify updated gram-hs library is available and compatible with current GHC version
-- [ ] T002 Read migration guide at `../gram-hs/docs/users/migration/rename-constructors.md` and understand breaking changes
-- [ ] T003 Verify existing test suite passes before migration: `cabal test`
+- [x] T001 Verify updated gram-hs library is available and compatible with current GHC version
+- [x] T002 Read migration guide at `../gram-hs/docs/users/migration/rename-constructors.md` and understand breaking changes
+- [x] T003 Verify existing test suite passes before migration: `cabal test`
 
 **Checkpoint**: Prerequisites verified - ready to begin migration
 
@@ -40,15 +40,15 @@
 
 ### Implementation for User Story 1
 
-- [ ] T004 [P] [US1] Update import in `src/PatternLisp/Codec.hs`: Change `import Pattern.Core (pattern, patternWith)` to `import Pattern.Core (point, pattern)`
-- [ ] T005 [P] [US1] Update import in `src/PatternLisp/PatternPrimitives.hs`: Change `import Pattern.Core (pattern, patternWith)` to `import Pattern.Core (point, pattern)`
-- [ ] T006 [P] [US1] Update import in `src/PatternLisp/Gram.hs`: Change `import Pattern.Core (pattern)` to `import Pattern.Core (point, pattern)`
-- [ ] T007 [P] [US1] Update import in `test/PatternLisp/CodecSpec.hs`: Change `import Pattern.Core (pattern, patternWith)` to `import Pattern.Core (point, pattern)`
-- [ ] T008 [P] [US1] Update import in `test/PatternLisp/GramSpec.hs`: Change `import Pattern.Core (pattern, patternWith)` to `import Pattern.Core (point, pattern)`
-- [ ] T009 [P] [US1] Update import in `test/PatternLisp/GramSerializationSpec.hs`: Change `import Pattern.Core (pattern, patternWith)` to `import Pattern.Core (point, pattern)`
-- [ ] T010 [P] [US1] Update import in `test/PatternLisp/RuntimeSpec.hs`: Change `import Pattern.Core (pattern)` to `import Pattern.Core (point, pattern)`
-- [ ] T011 [US1] Verify all imports updated: Run `grep -r "patternWith" src/ test/ | grep -i import` to confirm no old imports remain
-- [ ] T012 [US1] Verify compilation: Run `cabal build` to ensure no import-related errors
+- [x] T004 [P] [US1] Update import in `src/PatternLisp/Codec.hs`: Change `import Pattern.Core (pattern, patternWith)` to `import Pattern.Core (point, pattern)`
+- [x] T005 [P] [US1] Update import in `src/PatternLisp/PatternPrimitives.hs`: Change `import Pattern.Core (pattern, patternWith)` to `import Pattern.Core (point, pattern)`
+- [x] T006 [P] [US1] Update import in `src/PatternLisp/Gram.hs`: Change `import Pattern.Core (pattern)` to `import Pattern.Core (point, pattern)`
+- [x] T007 [P] [US1] Update import in `test/PatternLisp/CodecSpec.hs`: Change `import Pattern.Core (pattern, patternWith)` to `import Pattern.Core (point, pattern)`
+- [x] T008 [P] [US1] Update import in `test/PatternLisp/GramSpec.hs`: Change `import Pattern.Core (pattern, patternWith)` to `import Pattern.Core (point, pattern)`
+- [x] T009 [P] [US1] Update import in `test/PatternLisp/GramSerializationSpec.hs`: Change `import Pattern.Core (pattern, patternWith)` to `import Pattern.Core (point, pattern)`
+- [x] T010 [P] [US1] Update import in `test/PatternLisp/RuntimeSpec.hs`: Change `import Pattern.Core (pattern)` to `import Pattern.Core (point, pattern)`
+- [x] T011 [US1] Verify all imports updated: Run `grep -r "patternWith" src/ test/ | grep -i import` to confirm no old imports remain
+- [x] T012 [US1] Verify compilation: Run `cabal build` to ensure no import-related errors
 
 **Checkpoint**: All imports updated - code should compile (may have errors from old constructor usage, which is expected)
 
@@ -62,12 +62,12 @@
 
 ### Implementation for User Story 2
 
-- [ ] T013 [P] [US2] Replace atomic `pattern` calls in `src/PatternLisp/Codec.hs`: Find all `pattern $` and `pattern subject` (single argument) and replace with `point $` and `point subject`
-- [ ] T014 [P] [US2] Replace atomic `pattern` calls in `src/PatternLisp/PatternPrimitives.hs`: Find all `pattern subject` (single argument) and replace with `point subject`
-- [ ] T015 [P] [US2] Replace atomic `pattern` calls in `src/PatternLisp/Gram.hs`: Replace `pattern subject` with `point subject` in `exprToGram` function
-- [ ] T016 [P] [US2] Replace atomic `pattern` calls in `test/PatternLisp/RuntimeSpec.hs`: Replace any atomic `pattern` calls with `point`
-- [ ] T017 [US2] Verify atomic patterns migrated: Run `grep -r "pattern \$" src/ test/` and `grep -r "pattern [^W]" src/ test/` to check for remaining atomic patterns (excluding `patternWith`)
-- [ ] T018 [US2] Verify compilation: Run `cabal build` to ensure atomic pattern replacements are correct
+- [x] T013 [P] [US2] Replace atomic `pattern` calls in `src/PatternLisp/Codec.hs`: Find all `pattern $` and `pattern subject` (single argument) and replace with `point $` and `point subject`
+- [x] T014 [P] [US2] Replace atomic `pattern` calls in `src/PatternLisp/PatternPrimitives.hs`: Find all `pattern subject` (single argument) and replace with `point subject`
+- [x] T015 [P] [US2] Replace atomic `pattern` calls in `src/PatternLisp/Gram.hs`: Replace `pattern subject` with `point subject` in `exprToGram` function
+- [x] T016 [P] [US2] Replace atomic `pattern` calls in `test/PatternLisp/RuntimeSpec.hs`: Replace any atomic `pattern` calls with `point`
+- [x] T017 [US2] Verify atomic patterns migrated: Run `grep -r "pattern \$" src/ test/` and `grep -r "pattern [^W]" src/ test/` to check for remaining atomic patterns (excluding `patternWith`)
+- [x] T018 [US2] Verify compilation: Run `cabal build` to ensure atomic pattern replacements are correct
 
 **Checkpoint**: All atomic patterns use `point` - compilation should succeed for atomic patterns
 
@@ -81,13 +81,13 @@
 
 ### Implementation for User Story 3
 
-- [ ] T019 [P] [US3] Replace `patternWith` calls in `src/PatternLisp/Codec.hs`: Replace all ~30+ occurrences of `patternWith` with `pattern`
-- [ ] T020 [P] [US3] Replace `patternWith` calls in `src/PatternLisp/PatternPrimitives.hs`: Replace all 4 occurrences of `patternWith` with `pattern`
-- [ ] T021 [P] [US3] Replace `patternWith` calls in `test/PatternLisp/GramSpec.hs`: Replace `patternWith` with `pattern`
-- [ ] T022 [P] [US3] Replace `patternWith` calls in `test/PatternLisp/GramSerializationSpec.hs`: Replace `patternWith` with `pattern`
-- [ ] T023 [US3] Verify all `patternWith` replaced: Run `grep -r "patternWith" src/ test/` to confirm no function calls remain (comments may still reference)
-- [ ] T024 [US3] Verify compilation: Run `cabal build` to ensure all `patternWith` replacements are correct
-- [ ] T025 [US3] Verify nested patterns: Check that nested patterns correctly use `point` for atomic children and `pattern` for non-atomic children
+- [x] T019 [P] [US3] Replace `patternWith` calls in `src/PatternLisp/Codec.hs`: Replace all ~30+ occurrences of `patternWith` with `pattern`
+- [x] T020 [P] [US3] Replace `patternWith` calls in `src/PatternLisp/PatternPrimitives.hs`: Replace all 4 occurrences of `patternWith` with `pattern`
+- [x] T021 [P] [US3] Replace `patternWith` calls in `test/PatternLisp/GramSpec.hs`: Replace `patternWith` with `pattern`
+- [x] T022 [P] [US3] Replace `patternWith` calls in `test/PatternLisp/GramSerializationSpec.hs`: Replace `patternWith` with `pattern`
+- [x] T023 [US3] Verify all `patternWith` replaced: Run `grep -r "patternWith" src/ test/` to confirm no function calls remain (comments may still reference)
+- [x] T024 [US3] Verify compilation: Run `cabal build` to ensure all `patternWith` replacements are correct
+- [x] T025 [US3] Verify nested patterns: Check that nested patterns correctly use `point` for atomic children and `pattern` for non-atomic children
 
 **Checkpoint**: All `patternWith` calls replaced with `pattern` - full migration of constructor calls complete
 
@@ -101,12 +101,12 @@
 
 ### Implementation for User Story 4
 
-- [ ] T026 [US4] Search for remaining `patternWith` function calls: Run `grep -r "patternWith" src/ test/` and verify only comments/documentation references remain
-- [ ] T027 [US4] Search for incorrect atomic `pattern` usage: Run `grep -r "pattern \$" src/ test/` and verify all are intentional (not atomic patterns that should be `point`)
-- [ ] T028 [US4] Verify compilation: Run `cabal build` and ensure zero errors related to Pattern constructors
-- [ ] T029 [US4] Run full test suite: Execute `cabal test` and verify 100% test pass rate
-- [ ] T030 [US4] Test example programs: Run example programs through interpreter and verify they produce same results as before migration
-- [ ] T031 [US4] Verify serialization round-trips: Test pattern serialization/deserialization for all pattern types (atomic, lists, maps, sets, closures, nested)
+- [x] T026 [US4] Search for remaining `patternWith` function calls: Run `grep -r "patternWith" src/ test/` and verify only comments/documentation references remain
+- [x] T027 [US4] Search for incorrect atomic `pattern` usage: Run `grep -r "pattern \$" src/ test/` and verify all are intentional (not atomic patterns that should be `point`)
+- [x] T028 [US4] Verify compilation: Run `cabal build` and ensure zero errors related to Pattern constructors
+- [x] T029 [US4] Run full test suite: Execute `cabal test` and verify 100% test pass rate
+- [x] T030 [US4] Test example programs: Run example programs through interpreter and verify they produce same results as before migration
+- [x] T031 [US4] Verify serialization round-trips: Test pattern serialization/deserialization for all pattern types (atomic, lists, maps, sets, closures, nested)
 
 **Checkpoint**: Migration verified complete - all tests pass, no old API usage remains
 
@@ -116,13 +116,13 @@
 
 **Purpose**: Update code comments and documentation examples to reflect new API
 
-- [ ] T032 [P] Update Haddock examples in `src/PatternLisp/PatternPrimitives.hs`: Replace `evalPatternWith` example comments to use new API if they reference constructors
-- [ ] T033 [P] Update inline comments in `src/PatternLisp/Codec.hs`: Review and update any comments that reference old constructor names
-- [ ] T034 [P] Update module documentation examples: Review module headers for example code snippets referencing old API
-- [ ] T035 [P] Update comments in `test/PatternLisp/` files: Review test file comments for old API references
-- [ ] T036 Verify comment updates: Run final `grep -r "patternWith" src/ test/` to confirm only historical references remain (if any)
-- [ ] T037 Final compilation check: Run `cabal build` one final time
-- [ ] T038 Final test check: Run `cabal test` one final time to ensure everything still works
+- [x] T032 [P] Update Haddock examples in `src/PatternLisp/PatternPrimitives.hs`: Replace `evalPatternWith` example comments to use new API if they reference constructors
+- [x] T033 [P] Update inline comments in `src/PatternLisp/Codec.hs`: Review and update any comments that reference old constructor names
+- [x] T034 [P] Update module documentation examples: Review module headers for example code snippets referencing old API
+- [x] T035 [P] Update comments in `test/PatternLisp/` files: Review test file comments for old API references
+- [x] T036 Verify comment updates: Run final `grep -r "patternWith" src/ test/` to confirm only historical references remain (if any)
+- [x] T037 Final compilation check: Run `cabal build` one final time
+- [x] T038 Final test check: Run `cabal test` one final time to ensure everything still works
 
 **Checkpoint**: Migration complete - code, tests, and documentation all updated