go: parse.sx — unary prefix operators + 11 tests [nothing]

Adds Go unary prefix operators per Go spec § Operators:
  +x  -x  !x  ^x  *p  &v  <-ch

gp-parse-unary is recursive (so !!x and -^x chain correctly) and
sits between gp-parse-expr and gp-parse-primary — unary therefore
always binds tighter than any binary op without needing a unary
entry in the precedence table.

Symbols +, -, *, &, ^ are shared between unary and binary forms;
the positional split (expression-start sees unary, mid-expression
sees binary) disambiguates them cleanly with no lookback.

Unary nodes are single-arg ast-app:
  (ast-app (ast-var OP) (list OPERAND))

parse 37/37, total 166/166.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

lib/go/parse.sx

@@ -64,11 +64,32 @@
               (= ty "ident")
               (do (gp-advance!) (ast-var v))
               :else nil))))
+      (define
+        gp-unary-ops
+        ;; Go spec § Operators: prefix unary, all higher precedence than
+        ;; any binary operator. <- is the channel receive form (send is a
+        ;; statement, not an expression, so never appears here as binary).
+        (list "+" "-" "!" "^" "*" "&" "<-"))
+      (define
+        gp-parse-unary
+        (fn
+          ()
+          (let ((tok (gp-cur)))
+            (cond
+              (and (= (get tok :type) "op")
+                   (some (fn (u) (= u (get tok :value))) gp-unary-ops))
+              (do
+                (gp-advance!)
+                (let ((operand (gp-parse-unary)))
+                  (cond
+                    (= operand nil) nil
+                    :else (ast-app (ast-var (get tok :value)) (list operand)))))
+              :else (gp-parse-primary)))))
       (define
         gp-parse-expr
         (fn
           (min-prec)
-          (let ((left (gp-parse-primary))) (gp-pratt-loop left min-prec))))
+          (let ((left (gp-parse-unary))) (gp-pratt-loop left min-prec))))
       (define
         gp-pratt-loop
         (fn

lib/go/scoreboard.json

@@ -1,10 +1,10 @@
 {
   "language": "go",
-  "total_pass": 155,
-  "total": 155,
+  "total_pass": 166,
+  "total": 166,
   "suites": [
     {"name":"lex","pass":129,"total":129,"status":"ok"},
-    {"name":"parse","pass":26,"total":26,"status":"ok"},
+    {"name":"parse","pass":37,"total":37,"status":"ok"},
     {"name":"types","pass":0,"total":0,"status":"pending"},
     {"name":"eval","pass":0,"total":0,"status":"pending"},
     {"name":"runtime","pass":0,"total":0,"status":"pending"},

lib/go/scoreboard.md

@@ -1,11 +1,11 @@
 # Go-on-SX Scoreboard
 
-**Total: 155 / 155 tests passing**
+**Total: 166 / 166 tests passing**
 
 |  | Suite | Pass | Total |
 |---|---|---|---|
 | ✅ | lex | 129 | 129 |
-| ✅ | parse | 26 | 26 |
+| ✅ | parse | 37 | 37 |
 | ⬜ | types | 0 | 0 |
 | ⬜ | eval | 0 | 0 |
 | ⬜ | runtime | 0 | 0 |

lib/go/tests/parse.sx

@@ -111,6 +111,67 @@
       (ast-app (ast-var "|") (list (ast-var "a") (ast-var "b")))
       (ast-var "c"))))
 
+(go-parse-test
+  "unary: -a"
+  (go-parse "-a")
+  (ast-app (ast-var "-") (list (ast-var "a"))))
+
+(go-parse-test
+  "unary: +a"
+  (go-parse "+a")
+  (ast-app (ast-var "+") (list (ast-var "a"))))
+
+(go-parse-test
+  "unary: !x"
+  (go-parse "!x")
+  (ast-app (ast-var "!") (list (ast-var "x"))))
+
+(go-parse-test
+  "unary: ^x (bitwise NOT)"
+  (go-parse "^x")
+  (ast-app (ast-var "^") (list (ast-var "x"))))
+
+(go-parse-test
+  "unary: *p (pointer deref)"
+  (go-parse "*p")
+  (ast-app (ast-var "*") (list (ast-var "p"))))
+
+(go-parse-test
+  "unary: &v (address-of)"
+  (go-parse "&v")
+  (ast-app (ast-var "&") (list (ast-var "v"))))
+
+(go-parse-test
+  "unary: <-ch (channel recv)"
+  (go-parse "<-ch")
+  (ast-app (ast-var "<-") (list (ast-var "ch"))))
+
+(go-parse-test
+  "unary: -1 (on literal)"
+  (go-parse "-1")
+  (ast-app (ast-var "-") (list (ast-literal "1"))))
+
+(go-parse-test
+  "unary: !!x (chained, right-recursive)"
+  (go-parse "!!x")
+  (ast-app
+    (ast-var "!")
+    (list (ast-app (ast-var "!") (list (ast-var "x"))))))
+
+(go-parse-test
+  "unary: -a + b → ((-a) + b) — unary tighter than binary"
+  (go-parse "-a + b")
+  (ast-app
+    (ast-var "+")
+    (list (ast-app (ast-var "-") (list (ast-var "a"))) (ast-var "b"))))
+
+(go-parse-test
+  "unary: a + -b → unary applies to RHS"
+  (go-parse "a + -b")
+  (ast-app
+    (ast-var "+")
+    (list (ast-var "a") (ast-app (ast-var "-") (list (ast-var "b"))))))
+
 (go-parse-test "non-primary: '+'" (go-parse "+") nil)
 
 (go-parse-test "non-primary: empty" (go-parse "") nil)