Merge pull request #149 from engboris/fix

Revert interact back to exec

Author: engboris

BASICS.md

@@ -208,7 +208,7 @@ You can focus all stars of a constellation with `@`:
 (:= x [(+f X) X])
 (:= y (-f a))
 
-(:= res1 (interact @#x #y)) ' normal execution
+(:= res1 (exec @#x #y)) ' normal execution
 (show #res1)
 
 (:= res2 (fire @#x #y))     ' actions are used exactly once
@@ -226,7 +226,7 @@ Add constraints with `[ some star || (!= X1 Y1) ... (!= Xn Yn)]`:
   [(+f a)]
   [(+f b)]
   @[(-f X) (-f Y) (r X Y) || (!= X Y)]})
-(show (interact #ineq))
+(show (exec #ineq))
 ```
 
 where several equality constraints can be chained after `||`.
@@ -275,7 +275,7 @@ Constellations can act like logic programs (à la Prolog).
 (:= rules { (-childOf X Y) (-childOf Y Z) (+grandParentOf Z X) })
 
 (:= query [(-childOf X b) (res X)])
-(show (interact { #facts #rules @#query }))
+(show (exec { #facts #rules @#query }))
 ```
 
 This asks: *Who are the children of `b`?*
@@ -313,7 +313,7 @@ A constellation must pass **all tests** to be considered of type `nat`.
 We then define the behavior of type assertions with a macro:
 
 ```stellogen
-(macro (:: Tested Test) (== @(interact @#Tested #Test) ok))
+(macro (:: Tested Test) (== @(exec @#Tested #Test) ok))
 ```
 
 It says that a `Tested` is of type `Test` when their interaction with focus on

CLAUDE.md

@@ -167,7 +167,7 @@ dune exec sgen run -- <inputfile>
 (:= query [(-add <s s 0> <s s 0> R) R])
 
 ' Execute interaction
-(show (interact #add @#query))
+(show (exec #add @#query))
 ```
 
 ## Example: Type Definition
@@ -178,7 +178,7 @@ dune exec sgen run -- <inputfile>
 
 ' Macro for type assertion
 (macro (:: Tested Test)
-  (== @(interact @#Tested #Test) ok))
+  (== @(exec @#Tested #Test) ok))
 
 ' Define nat type as interactive tests
 (spec nat {

README.md

@@ -72,7 +72,7 @@ Stellogen's constellation-based model supports multiple programming paradigms:
 ' Make x and y interact along (+f a) and (-f X)
 ' The conflict is resolved and propagated to the other term X
 ' It results in [a]
-(:= result (interact #x @#y))
+(:= result (exec #x @#y))
 
 ' Display result [a] on screen
 (show #result)

docs/compilation_and_abstract_machines.md

@@ -645,7 +645,7 @@ HALT:
   [(-add X Y Z) (+add (s X) Y (s Z))]})
 
 (:= query [(-add <s s 0> <s s 0> R) R])
-(interact #add @#query)
+(exec #add @#query)
 ```
 
 **Step 1: Compile constellation definitions**
@@ -868,7 +868,7 @@ unify result X
 **Evaluate interactions at compile-time when possible:**
 
 ```stellogen
-(:= constant (interact #add @#two @#three))
+(:= constant (exec #add @#two @#three))
 ```
 
 If `add`, `two`, and `three` are all known at compile-time, evaluate now and store the result.
@@ -1895,7 +1895,7 @@ Term: (+add (s 0) (s 0) R)
 ```
 [Debugger] Starting type check for 'bad'
 [Step 1] Evaluating: (:: bad nat)
-[Step 2] Expanding macro: (== @(interact @#bad #nat) ok)
+[Step 2] Expanding macro: (== @(exec @#bad #nat) ok)
 [Step 3] Focusing @#bad → (+nat [])
 [Step 4] Loading #nat → { [(-nat 0) ok], [(-nat (s N)) (+nat N)] }
 [Step 5] Scheduling interaction: (+nat []) with #nat
@@ -1922,7 +1922,7 @@ Term: (+add (s 0) (s 0) R)
 (:= loop {
   [(-loop X) (+loop X)]})  ' Bug: infinite loop
 
-(interact #loop @#start)
+(exec #loop @#start)
 ```
 
 **Debug session:**
@@ -1968,7 +1968,7 @@ Term: (+add (s 0) (s 0) R)
   [(-add X Y Z) (+add (s X) Y (s Z))]})
 
 (:= query [(-add <s s 0> <s s 0> R) R])
-(show (interact #add @#query))
+(show (exec #add @#query))
 ```
 
 **Debug session with visualization:**
@@ -2089,7 +2089,7 @@ sgen debug --trace program.sg
 stellogen> :debug on
 [Debugger enabled]
 
-stellogen> (interact #add @#query)
+stellogen> (exec #add @#query)
 [Breakpoint] Entering constellation 'add'
 
 (debug) :step

docs/cut_and_control_flow.md

@@ -362,7 +362,7 @@ Prolog maintains a **choice point** at each clause. Backtracking explores altern
   [(-member X [_|T]) (+member X T)]})
 
 (:= query [(-member X [1 2 3]) X])
-(show (interact #member @#query))
+(show (exec #member @#query))
 ' Result: [1, 2, 3]  (all at once, or depends on implementation)
 ```
 
@@ -427,7 +427,7 @@ R = 5.         % Deterministic
   [(-max X Y Y)]})
 
 (:= query [(-max 5 3 R) R])
-(show (interact #max @#query))
+(show (exec #max @#query))
 ```
 
 **Problem:** Both stars might match (or neither, depending on constraint handling). There's no way to say "if the first matches, don't try the second."
@@ -479,7 +479,7 @@ While Stellogen can't reproduce Prolog's cut, it has **different mechanisms** fo
 
 (:= query [(-f X) (-f Y) (result X Y)])
 
-(interact #facts @#query)
+(exec #facts @#query)
 ' All combinations: (result 1 1), (result 1 2), (result 2 1), (result 2 2)
 ```
 
@@ -710,7 +710,7 @@ Or with syntactic sugar:
 
 ```stellogen
 (macro (not Test)
-  (interact @#Test #failure-check))
+  (exec @#Test #failure-check))
 
 (:= failure-check {
   [(+anything) fail]})
@@ -937,7 +937,7 @@ Or more directly, introduce `|` separator for alternatives:
 
 ''' Deterministic if-then-else '''
 (macro (if Cond Then Else)
-  (interact
+  (exec
     { [(+cond) @#Then]
       [(-cond) @#Else] }
     @#Cond))

docs/interaction_nets_and_combinators.md

@@ -421,10 +421,10 @@ This encodes the identity agent in multiplicative linear logic (MLL):
   [+cuts [
     [(-7 X) (-8 X)]]]})
 
-(:= vehicle (eval (interact #ps1 @[-vehicle])))
-(:= cuts    (eval (interact #ps1 @[-cuts])))
+(:= vehicle (eval (exec #ps1 @[-vehicle])))
+(:= cuts    (eval (exec #ps1 @[-cuts])))
 
-(show (interact #vehicle #cuts))
+(show (exec #vehicle #cuts))
 ```
 
 **Analysis:**
@@ -466,7 +466,7 @@ This is the classic **cut elimination** from linear logic proof theory:
   [(-id X) (-arg X)]
   @[(+arg [r|X]) (out X)]])
 
-(show (interact #id #id_arg #linker))
+(show (exec #id #id_arg #linker))
 ```
 
 **Analysis:**

docs/language_comparisons.md

@@ -104,7 +104,7 @@ Z = ann.
   [(-grandparent X Z) (-parent X Y) (+parent Y Z)]})
 
 (:= query [(-grandparent tom Z) Z])
-(show (interact #grandparent @(process #query #family)))
+(show (exec #grandparent @(process #query #family)))
 ' Result: [ann, jim]
 ```
 
@@ -128,7 +128,7 @@ R = s(s(s(s(0)))).
   [(-add X Y Z) (+add (s X) Y (s Z))]})
 
 (:= query1 [(-add <s s 0> <s s 0> R) R])
-(show (interact #add @#query1))
+(show (exec #add @#query1))
 ' Result: (s (s (s (s 0))))
 ```
 
@@ -198,7 +198,7 @@ X = 3.     % backtrack
 (:= x (+f a))
 #x          ' Just the identifier
 @#x         ' Focused/evaluated
-(interact @#x #y)  ' Explicit interaction
+(exec @#x #y)  ' Explicit interaction
 ```
 
 #### 5. Type Systems
@@ -257,7 +257,7 @@ Both use S-expressions as the primary syntactic form.
 **Stellogen:**
 ```stellogen
 (:= add { ... })
-(show (interact #add @#query))
+(show (exec #add @#query))
 ```
 
 Both are homoiconic—code is data represented as lists/trees.
@@ -281,7 +281,7 @@ Both support powerful macro systems for syntactic extension.
 ```stellogen
 (macro (spec X Y) (:= X Y))
 (macro (:: Tested Test)
-  (== @(interact @#Tested #Test) ok))
+  (== @(exec @#Tested #Test) ok))
 
 (spec nat { ... })
 (:: zero nat)
@@ -438,7 +438,7 @@ Both use unification to relate terms.
 ```stellogen
 (:= fact [(+hello q)])
 (:= query [(-hello X) X])
-(show (interact #fact @#query))
+(show (exec #fact @#query))
 ```
 
 #### 2. Relational Queries
@@ -474,11 +474,11 @@ Both can express relations that work in multiple directions.
 
 ' Forward
 (:= q1 [(-append [1 2] [3 4] R) R])
-(show (interact #appendo @#q1))
+(show (exec #appendo @#q1))
 
 ' Backward (if properly defined)
 (:= q2 [(-append X [3 4] [1 2 3 4]) X])
-(show (interact #appendo @#q2))
+(show (exec #appendo @#q2))
 ```
 
 #### 3. Logic Variables
@@ -997,7 +997,7 @@ map f xs
 **Stellogen:** Interaction-based.
 
 ```stellogen
-(interact #map @#f @#xs)
+(exec #map @#f @#xs)
 ```
 
 #### 3. Narrowing
@@ -1128,7 +1128,7 @@ Both track resources and control their use.
 
 ```stellogen
 (fire #a #b)      ' Linear
-(interact #a #b)  ' Non-linear
+(exec #a #b)  ' Non-linear
 ```
 
 ### Differences from Stellogen
@@ -1451,7 +1451,7 @@ Most languages evaluate automatically. Stellogen gives **fine-grained control**:
 ```stellogen
 #x            ' Reference (no evaluation)
 @#x           ' Focus (evaluate)
-(interact #x #y)   ' Non-linear interaction
+(exec #x #y)   ' Non-linear interaction
 (fire #x #y)       ' Linear interaction
 (process #a #b #c) ' Chained interaction
 (eval #x)          ' Meta-level evaluation
@@ -1468,7 +1468,7 @@ Most languages evaluate automatically. Stellogen gives **fine-grained control**:
 
 (:= zero (+nat 0))
 (:: zero nat)
-' Type check ≡ (== @(interact @#zero #nat) ok)
+' Type check ≡ (== @(exec @#zero #nat) ok)
 ```
 
 This is a radically different approach from all other languages.

docs/natural_scripting_syntax.md

@@ -500,7 +500,7 @@ For more flexibility, allow system scoping within a file:
 )
 
 ' Back to regular Stellogen
-(show (interact @#e #automaton))
+(show (exec @#e #automaton))
 
 ' Another system in the same file
 (within-system state-machine
@@ -1303,7 +1303,7 @@ type nat = zero | succ of nat
 
 ' File 5: Core Stellogen (no system)
 (:= x 42)
-(show (interact @#a @#b))
+(show (exec @#a @#b))
 ```
 
 **All files** compile to the same core Stellogen, interact seamlessly, but each has the **natural syntax** for its domain.