Merge pull request #284 from array2d/wip/struct-list-spec

struct/链表 tutorial + spec 运算符/内建 + parser/symbol

Author: miaobyte

layout/src/parser.rs

@@ -1239,6 +1239,12 @@ impl Parser {
             if symbol::lookup(&t.value).word == "add" {
                 return self.parse_pratt(UNARY_PREC);
             }
+            // 一元前缀 & = 取址：&x ≡ kv·abs(x)（中缀 & 仍为按位与，走 pratt 中缀路径）。
+            if symbol::lookup(&t.value).word == "bitand" {
+                let arg = self.parse_pratt(UNARY_PREC)?;
+                let op = format!("kv{}abs", keytree::MEMBER_SEP);
+                return Some(ast::call(&op, vec![arg]));
+            }
             let arg = self.parse_pratt(UNARY_PREC)?;
             return Some(ast::call(&t.value, vec![arg]));
         }

layout/src/symbol.rs

@@ -260,7 +260,7 @@ static ENTRIES: &[Entry] = &[
         precedence: 80,
         arith: true,
         cmp: false,
-        unary: false,
+        unary: true,
     },
     Entry {
         word: "bitor",

stdlib/kvlang/spec/01-词法/08-运算符基础.kv

@@ -44,7 +44,8 @@ x = 42       // 左写、右读
 - `/`（U+002F）**不是**除号。它只用于绝对路径字面量与注释（`//`、`/*`）；出现在其他位置的裸 `/` 不承
   载算术除法语义。
 
-一元 `+`、`-` 作前缀；`√`（U+221A，平方根）亦为一元前缀运算符。
+一元 `+`、`-` 作前缀；`√`（U+221A，平方根）亦为一元前缀运算符。`&` 亦兼一元前缀（取址，
+`&x ≡ kv·abs(x)`）；其中缀身份（按位与）与前缀身份靠位置区分，同 C，详见 [[逻辑位运算与优先级]]。
 
 ## 比较运算符
 

stdlib/kvlang/spec/01-词法/09-逻辑位运算与优先级.kv

@@ -18,9 +18,27 @@ lib kvlang/spec/词法/逻辑位运算与优先级 {
 
 分别为按位与、按位或、按位异或、左移、右移。
 
+`&` 一符二用，靠位置区分（同 C）：操作数之后为中缀**按位与**；表达式起始或运算符之后为一元前缀
+**取址**（见下 [[取址运算符 `&`]]）。
+
+## 取址运算符 `&`
+
+一元前缀 `&loc` 求值为 `loc` 所在节点的绝对 KV 路径字符串，等价 `kv·abs(loc)`。操作数须为位置
+（location）：帧内裸名、容器/成员链（`x`、`list·1`、`base·field`）。
+
+产物是普通路径串，与指针惯例同型（可 `-> p` 存指针、`+ "·n"` 拼子节点、赋给 `next` 字段）；与
+`*T` ref 标注互补——`&` 造路径，`*` 标注该路径所指目标的形态（见 [[ptr]]）。
+
+```
+list·1 -> x
+&x -> p          // p = x 的绝对路径串，等价 kv·abs(x)
+p + "·next" -> q
+```
+
 ## 优先级
 
-中缀运算符的优先级如下（数值越大结合越紧）；一元前缀运算符（`+ - ! √`）优先级高于全部中缀。
+中缀运算符的优先级如下（数值越大结合越紧）；一元前缀运算符（`+ - ! √ &`）优先级高于全部中缀。
+故 `&a·b ≡ &(a·b)`（成员链先结合，同 C 的 `&a.b`）。
 
 | 运算符 | 优先级 |
 |--------|--------|

stdlib/kvlang/spec/03-类型系统/16-ptr.kv

@@ -16,5 +16,8 @@ lib kvlang/spec/类型系统/ptr {
 "/n1" -> p             // 引号 = 路径串（指针）
 p·val -> v             // 按值解引用：读 /n1·val
 ```
+
+局部变量/容器成员取指针用一元前缀 `&`（`&x ≡ kv·abs(x)`，返回绝对路径串），与 `*` ref 标注互补——
+`&` 造路径、`*` 标注目标形态（见 [[逻辑位运算与优先级]] 取址运算符）。
 "#### -> /lib/kvlang/spec/类型系统/ptr
 }

stdlib/kvlang/spec/附录/05-表达式.kv

@@ -18,7 +18,7 @@ primary     = literal | ident | path
             | struct_literal
             | map_literal
 
-prefix_unary = "-" | "!" | "√"                        (* √ = sqrt（U+221A），一元 *)
+prefix_unary = "-" | "!" | "√" | "&"                  (* √ = sqrt（U+221A）；&x ≡ kv·abs(x) 取址 *)
 
 infix_primary = binary_op expr
 

stdlib/kvlang/spec/附录/07-内建函数.kv

@@ -32,6 +32,7 @@ builtin_call = ( "abs" | "neg" | "sign" | "pow" | "sqrt" | "exp" | "log"
 (* ÷ : 两侧 int → 整除(C 风格)；任一侧 float → 浮除 *)
 (* s[i] 读返单字符字符串，越界返 ""；s[i]="X" 单字符替换写回新串 *)
 (* + 作用在 string∧string → 拼接 *)
+(* &x 是 kv·abs(x) 的语法糖（一元前缀取址，返回 x 的绝对路径串）；与中缀按位与 a & b 靠位置区分 *)
 ```
 "## -> /lib/kvlang/spec/附录/内建函数
 }

tutorial/08-leetcode/002_add_two_numbers.kv

@@ -47,23 +47,15 @@ rwfunc add(a:[]char/utf32, b:[]char/utf32) -> () {
 }
 
 rwfunc test() -> () {
-	l1:[int64]·Node = {}
-	kv·abs(l1) -> b1
-	b1 + "·2" -> a2
-	b1 + "·3" -> a3
-	l1·1:Node = {val=2 next=a2}
-	l1·2:Node = {val=4 next=a3}
-	l1·3:Node = {val=3 next=""}
-	b1 + "·1" -> h1
+	a3:Node = {val=3}
+	a2:Node = {val=4 next=&a3}
+	a1:Node = {val=2 next=&a2}
+	&a1 -> h1
 
-	l2:[int64]·Node = {}
-	kv·abs(l2) -> b2
-	b2 + "·2" -> c2
-	b2 + "·3" -> c3
-	l2·1:Node = {val=5 next=c2}
-	l2·2:Node = {val=6 next=c3}
-	l2·3:Node = {val=4 next=""}
-	b2 + "·1" -> h2
+	b3:Node = {val=4}
+	b2:Node = {val=6 next=&b3}
+	b1:Node = {val=5 next=&b2}
+	&b1 -> h2
 
 	lc·add(h1, h2)
 }

tutorial/08-leetcode/021_merge_two_lists.kv

@@ -44,23 +44,15 @@ rwfunc merge(a:[]char/utf32, b:[]char/utf32) -> () {
 }
 
 rwfunc test() -> () {
-	a:[int64]·Node = {}
-	kv·abs(a) -> ab
-	ab + "·2" -> a2
-	ab + "·3" -> a3
-	a·1:Node = {val=1 next=a2}
-	a·2:Node = {val=2 next=a3}
-	a·3:Node = {val=4 next=""}
-	ab + "·1" -> ha
+	a3:Node = {val=4}
+	a2:Node = {val=2 next=&a3}
+	a1:Node = {val=1 next=&a2}
+	&a1 -> ha
 
-	b:[int64]·Node = {}
-	kv·abs(b) -> bb
-	bb + "·2" -> b2
-	bb + "·3" -> b3
-	b·1:Node = {val=1 next=b2}
-	b·2:Node = {val=3 next=b3}
-	b·3:Node = {val=4 next=""}
-	bb + "·1" -> hb
+	b3:Node = {val=4}
+	b2:Node = {val=3 next=&b3}
+	b1:Node = {val=1 next=&b2}
+	&b1 -> hb
 
 	merge(ha, hb)
 }

tutorial/08-leetcode/083_remove_dup_list.kv

@@ -43,29 +43,19 @@ rwfunc show(head:[]char/utf32) -> () {
 }
 
 rwfunc test() -> () {
-	e:[int64]·Node = {}
-	kv·abs(e) -> eb
-	eb + "·2" -> e2
-	eb + "·3" -> e3
-	e·1:Node = {val=1 next=e2}
-	e·2:Node = {val=1 next=e3}
-	e·3:Node = {val=2 next=""}
-	eb + "·1" -> e1
-	dedup(e1)
-	show(e1)
+	e3:Node = {val=2}
+	e2:Node = {val=1 next=&e3}
+	e1:Node = {val=1 next=&e2}
+	&e1 -> eh
+	dedup(eh)
+	show(eh)
 
-	f:[int64]·Node = {}
-	kv·abs(f) -> fb
-	fb + "·2" -> f2
-	fb + "·3" -> f3
-	fb + "·4" -> f4
-	fb + "·5" -> f5
-	f·1:Node = {val=1 next=f2}
-	f·2:Node = {val=1 next=f3}
-	f·3:Node = {val=2 next=f4}
-	f·4:Node = {val=3 next=f5}
-	f·5:Node = {val=3 next=""}
-	fb + "·1" -> f1
-	dedup(f1)
-	show(f1)
+	f5:Node = {val=3}
+	f4:Node = {val=3 next=&f5}
+	f3:Node = {val=2 next=&f4}
+	f2:Node = {val=1 next=&f3}
+	f1:Node = {val=1 next=&f2}
+	&f1 -> fh
+	dedup(fh)
+	show(fh)
 }