Fix conflict

Author: engboris

CLAUDE.md

@@ -56,7 +56,7 @@ Unlike traditional typed languages where types constrain and shape program desig
 
 ### Declarations
 - **Definition**: `(:= name value)`
-- **Macro**: `(new-declaration (pattern) (expansion))`
+- **Macro**: `(macro (pattern) (expansion))`
 - **Show**: `(show expr)` - display result
 - **Expect**: Assertion/testing mechanism
 
@@ -171,10 +171,10 @@ dune exec sgen run -- <inputfile>
 
 ```stellogen
 ' Macro for type specification
-(new-declaration (spec X Y) (:= X Y))
+(macro (spec X Y) (:= X Y))
 
 ' Macro for type assertion
-(new-declaration (:: Tested Test)
+(macro (:: Tested Test)
   (== @(interact @#Tested #Test) ok))
 
 ' Define nat type as interactive tests

docs/basics.md

@@ -109,7 +109,7 @@ Some special operators are written as prefix of the expression:
 It is possible to declare aliases for expressions:
 
 ```stellogen
-(new-declaration (spec X Y) (:= X Y))
+(macro (spec X Y) (:= X Y))
 ```
 
 after this declaration, `(spec X Y)` stands for `(:= X Y)`.
@@ -370,7 +370,7 @@ In Stellogen, **types are sets of tests** that a constellation must pass to be o
 For example, we define a type for natural numbers:
 
 ```stellogen
-(new-declaration (spec X Y) (:= X Y))
+(macro (spec X Y) (:= X Y))
 (spec nat {
   [(-nat 0) ok]              ' test 1
   [(-nat (s N)) (+nat N)]})  ' test 2
@@ -381,7 +381,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
-(new-declaration (:: Tested Test)
+(macro (:: Tested Test)
   (== @(interact @#Tested #Test) ok))
 ```
 

docs/cut_and_control_flow.md

@@ -709,7 +709,7 @@ Or with syntactic sugar:
 **Syntax:**
 
 ```stellogen
-(new-declaration (not Test)
+(macro (not Test)
   (interact @#Test #failure-check))
 
 (:= failure-check {
@@ -802,7 +802,7 @@ Or with syntactic sugar:
 **Example - First-match macro:**
 
 ```stellogen
-(new-declaration (first-match Name Cases)
+(macro (first-match Name Cases)
   (:= Name {
     (expand-cases-with-flags Cases)}))
 
@@ -936,14 +936,14 @@ Or more directly, introduce `|` separator for alternatives:
 ' lib/control.sg
 
 ''' Deterministic if-then-else '''
-(new-declaration (if Cond Then Else)
+(macro (if Cond Then Else)
   (interact
     { [(+cond) @#Then]
       [(-cond) @#Else] }
     @#Cond))
 
 ''' First match from multiple options '''
-(new-declaration (first-of Options)
+(macro (first-of Options)
   (:= temp {
     [(+available)]
     @(expand-with-guards #Options)

docs/import_mechanisms.md

@@ -66,7 +66,7 @@ let preprocess e = e |> List.map ~f:expand_macro |> unfold_decl_def []
 The preprocessing phase consists of two steps:
 
 1. **Syntactic expansion** (`expand_macro`): Desugars syntax like `[1|Tail]`, `<f a b>`, `"string"` into core forms
-2. **Macro expansion** (`unfold_decl_def`): Processes `new-declaration` forms and expands macro calls
+2. **Macro expansion** (`unfold_decl_def`): Processes `macro` forms and expands macro calls
 
 ### How Macros Work
 
@@ -78,7 +78,7 @@ The `unfold_decl_def` function:
 let unfold_decl_def (macro_env : (string * (string list * expr list)) list) exprs =
   let rec process_expr (env, acc) = function
     (* Macro definition *)
-    | List (Symbol "new-declaration" :: List (Symbol macro_name :: args) :: body) ->
+    | List (Symbol "macro" :: List (Symbol macro_name :: args) :: body) ->
       let var_args = List.map args ~f:(function | Var x -> x | _ -> failwith ...) in
       ((macro_name, (var_args, body)) :: env, acc)
 
@@ -791,8 +791,8 @@ let resolve_module module_name current_file =
 The same macro definitions appear at the beginning of **12+ example files**:
 
 ```stellogen
-(new-declaration (spec X Y) (:= X Y))
-(new-declaration (:: Tested Test)
+(macro (spec X Y) (:= X Y))
+(macro (:: Tested Test)
   (== @(interact @#Tested #Test) ok))
 ```
 
@@ -847,8 +847,8 @@ Suppose we want to create `lib/prelude.sg`:
 
 ```stellogen
 ' lib/prelude.sg - Common macros
-(new-declaration (spec X Y) (:= X Y))
-(new-declaration (:: Tested Test)
+(macro (spec X Y) (:= X Y))
+(macro (:: Tested Test)
   (== @(interact @#Tested #Test) ok))
 ```
 
@@ -1054,8 +1054,8 @@ The current architecture has a clean separation between:
 
 ```stellogen
 ' lib/prelude.sg
-(new-declaration (spec X Y) (:= X Y))
-(new-declaration (:: Tested Test)
+(macro (spec X Y) (:= X Y))
+(macro (:: Tested Test)
   (== @(interact @#Tested #Test) ok))
 
 ' my_program.sg
@@ -1111,8 +1111,8 @@ The current architecture has a clean separation between:
 
 ```stellogen
 ' lib/prelude.sg
-(new-declaration (spec X Y) (:= X Y))
-(new-declaration (:: Tested Test)
+(macro (spec X Y) (:= X Y))
+(macro (:: Tested Test)
   (== @(interact @#Tested #Test) ok))
 
 ' my_program.sg
@@ -1169,8 +1169,8 @@ sgen config set prelude lib/prelude.sg
 
 ```bash
 # Create prelude
-echo '(new-declaration (spec X Y) (:= X Y))' > prelude.sg
-echo '(new-declaration (:: Tested Test) (== @(interact @#Tested #Test) ok))' >> prelude.sg
+echo '(macro (spec X Y) (:= X Y))' > prelude.sg
+echo '(macro (:: Tested Test) (== @(interact @#Tested #Test) ok))' >> prelude.sg
 
 # Use it
 sgen run --prelude prelude.sg my_program.sg
@@ -1351,10 +1351,10 @@ sgen config set prelude lib/milkyway.sg
 ' lib/milkyway.sg - Stellogen Standard Library
 
 ''' Type system macros '''
-(new-declaration (spec X Y) (:= X Y))
-(new-declaration (:: Tested Test)
+(macro (spec X Y) (:= X Y))
+(macro (:: Tested Test)
   (== @(interact @#Tested #Test) ok))
-(new-declaration (::lin Tested Test)
+(macro (::lin Tested Test)
   (== @(fire @#Tested #Test) ok))
 
 ''' Common type definitions '''
@@ -1363,15 +1363,15 @@ sgen config set prelude lib/milkyway.sg
 (spec list {...})
 
 ''' Utility macros '''
-(new-declaration (alias X Y) (:= X Y))
-(new-declaration (type X Y) (spec X Y))
+(macro (alias X Y) (:= X Y))
+(macro (type X Y) (spec X Y))
 
 ''' Testing macros '''
-(new-declaration (test Name Body)
+(macro (test Name Body)
   (== Body ok Name))
 
 ''' Documentation helpers '''
-(new-declaration (doc _ Body) Body)
+(macro (doc _ Body) Body)
 ```
 
 **Organization:**

docs/language_comparisons.md

@@ -279,8 +279,8 @@ Both support powerful macro systems for syntactic extension.
 
 **Stellogen:**
 ```stellogen
-(new-declaration (spec X Y) (:= X Y))
-(new-declaration (:: Tested Test)
+(macro (spec X Y) (:= X Y))
+(macro (:: Tested Test)
   (== @(interact @#Tested #Test) ok))
 
 (spec nat { ... })
@@ -400,7 +400,7 @@ No automatic evaluation—you control when terms are evaluated.
 | Foundation | Lambda calculus | Term unification + polarity |
 | Syntax | S-expressions | S-expressions |
 | Evaluation | Eager (strict) | Explicit (via `@`) |
-| Metaprogramming | Macros (syntax-rules, defmacro) | Macros (new-declaration) |
+| Metaprogramming | Macros (syntax-rules, defmacro) | Macros (macro) |
 | Unification | No | Yes (central) |
 | Types | Dynamic | User-defined interactive tests |
 | Paradigm | Functional (primarily) | Multi-paradigm (logic-agnostic) |
@@ -1097,7 +1097,7 @@ Stellogen supports **linear evaluation** via `fire`.
 
 **Stellogen (`examples/mll.sg`, `examples/smll.sg`):**
 ```stellogen
-(new-declaration (::lin Tested Test)
+(macro (::lin Tested Test)
   (== @(fire #Tested #Test) ok))
 
 ' fire uses resources exactly once (linear)
@@ -1507,8 +1507,8 @@ Stellogen supports **all paradigms** without committing to any:
 Macros are not an add-on—they're **fundamental** to how Stellogen is extended.
 
 ```stellogen
-(new-declaration (spec X Y) (:= X Y))
-(new-declaration (:: Tested Test) ...)
+(macro (spec X Y) (:= X Y))
+(macro (:: Tested Test) ...)
 ```
 
 Users define new declaration forms, not just syntactic sugar.