From 697dfc97643ecc217bedcae9fb76b09ea9318424 Mon Sep 17 00:00:00 2001 From: "peng.li24" <734991033@qq.com> Date: Sat, 12 Sep 2026 11:43:58 +0800 Subject: [PATCH] =?UTF-8?q?chore:=20kv=C2=B7*=20=E5=86=85=E5=BB=BA?= =?UTF-8?q?=E9=87=8D=E5=91=BD=E5=90=8D=E4=B8=BA=20kvspace=C2=B7*?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - rwir 名 kv·get/set/del/deltree/cp/cpdir/has/list... → kvspace·* - C 层 kvlangBuiltinKv* → kvlangC*，错误文案同步（kv.get→kvspace·get 等） - layout(lower/parser/scanner)、runtime-rs(engine/kvlanglayout/mod)、 runtime-c(builtin*) 注册表全量同步 - stdlib、spec、tutorial、benchmark、error_cases 引用同步 Co-Authored-By: Claude Opus 4.8 --- .../cases/binary_search/binary_search.kv | 2 +- benchmark/cases/binary_trees/binary_trees.kv | 10 +-- benchmark/cases/hash_table/hash_table.kv | 4 +- benchmark/cases/k_nucleotide/k_nucleotide.kv | 10 +-- error_cases/index_error/at_oob.kv | 2 +- .../index_error/typed_array_string_key.kv | 2 +- error_cases/key_error/kv_at_missing.kv | 2 +- layout/src/lower.rs | 22 +++---- layout/src/parser.rs | 48 +++++++------- layout/src/scanner.rs | 2 +- runtime-rs/build.rs | 2 +- runtime-rs/src/engine.rs | 2 +- runtime-rs/src/rwir/kvlanglayout.rs | 10 +-- runtime-rs/src/rwir/mod.rs | 26 ++++---- .../go/json/tutorial/json_local.kv | 12 ++-- runtime/src/builtin.c | 12 ++-- runtime/src/builtin_collection.c | 4 +- runtime/src/builtin_internal.h | 28 ++++---- runtime/src/builtin_kv.c | 66 +++++++++---------- stdlib/kv.kv | 18 ++--- stdlib/kvlang/kvlangbrief.kv | 28 ++++---- ...4-\346\240\207\350\257\206\347\254\246.kv" | 2 +- ...04\345\255\227\351\235\242\351\207\217.kv" | 6 +- ...27\347\254\246\345\237\272\347\241\200.kv" | 2 +- ...16\344\274\230\345\205\210\347\272\247.kv" | 4 +- ...00\344\270\216\345\221\275\345\220\215.kv" | 2 +- ...51\347\220\206\345\275\242\346\200\201.kv" | 2 +- ...03\345\261\200\346\240\274\345\274\217.kv" | 2 +- ...16\345\220\210\346\263\225\346\200\247.kv" | 2 +- ...1-stringkeymap\345\275\242\346\200\201.kv" | 2 +- ...\345\257\206vs\347\250\200\347\226\217.kv" | 4 +- .../14-map\345\256\271\345\231\250.kv" | 6 +- ...20\345\221\230\350\256\277\351\227\256.kv" | 4 +- .../16-ptr.kv" | 6 +- ...46\344\270\262\347\274\226\347\240\201.kv" | 2 +- .../03-\345\207\275\346\225\260.kv" | 6 +- ...66\346\265\201\350\204\261\347\263\226.kv" | 2 +- ...ut\346\265\201\346\260\264\347\272\277.kv" | 2 +- ...20\345\221\230\350\256\277\351\227\256.kv" | 10 +-- .../05-runtimec\345\206\205\345\273\272.kv" | 5 +- ...00\345\217\221\350\247\204\350\214\203.kv" | 2 +- .../07-notinmyrwircaps.kv" | 2 +- ...07\347\232\206\346\230\216\346\226\207.kv" | 2 +- ...5-\350\241\250\350\276\276\345\274\217.kv" | 2 +- ...05\345\273\272\345\207\275\346\225\260.kv" | 5 +- stdlib/math.kv | 2 +- tutorial/01-basics/kv_mkindex_cap.kv | 12 ++-- tutorial/01-basics/kv_tree.kv | 18 ++--- tutorial/04-ndarray/map_coord.kv | 2 +- tutorial/04-ndarray/separated.kv | 8 +-- tutorial/04-ndarray/sparse_literal.kv | 8 +-- tutorial/05-dict/kv_has_string_key.kv | 2 +- tutorial/05-dict/literal.kv | 4 +- tutorial/05-dict/literal_as_arg.kv | 4 +- tutorial/06-algo/map_reduce.kv | 8 +-- tutorial/06-algo/word_count.kv | 8 +-- tutorial/07-lib/walk_lib.kv | 10 +-- tutorial/08-leetcode/001_two-sum-hash.kv | 10 +-- tutorial/08-leetcode/002_add_two_numbers.kv | 4 +- tutorial/08-leetcode/003_longest_substring.kv | 6 +- tutorial/08-leetcode/020_valid_parentheses.kv | 6 +- tutorial/08-leetcode/038_count_and_say.kv | 18 ++--- tutorial/08-leetcode/056_merge_intervals.kv | 30 ++++----- tutorial/08-leetcode/062_unique_paths.kv | 10 +-- tutorial/08-leetcode/094_inorder_traversal.kv | 4 +- tutorial/08-leetcode/118_pascal_triangle.kv | 16 ++--- tutorial/08-leetcode/217_contains_dup_hash.kv | 8 +-- tutorial/08-leetcode/219_contains_dup_ii.kv | 4 +- tutorial/08-leetcode/234_palindrome_list.kv | 6 +- tutorial/08-leetcode/242_valid_anagram.kv | 4 +- tutorial/10-types/01-typed-map.kv | 8 +-- tutorial/10-types/02-string-map.kv | 4 +- tutorial/10-types/03-map-return.kv | 6 +- tutorial/10-types/06-any-read-param.kv | 2 +- tutorial/12-struct/03-linked-list.kv | 2 +- tutorial/12-struct/07-list-local.kv | 2 +- tutorial/13-stdlib/kv/get_or.kv | 8 +-- tutorial/13-stdlib/kv/has.kv | 8 +-- tutorial/13-stdlib/kv/set_default.kv | 10 +-- tutorial/13-stdlib/math/constants.kv | 4 +- tutorial/14-networld/08-fs-dir.kv | 8 +-- tutorial/15-vthread/02-crashrecover.kv | 4 +- 82 files changed, 338 insertions(+), 336 deletions(-) diff --git a/benchmark/cases/binary_search/binary_search.kv b/benchmark/cases/binary_search/binary_search.kv index 9fc5ba9b..5c555f6f 100644 --- a/benchmark/cases/binary_search/binary_search.kv +++ b/benchmark/cases/binary_search/binary_search.kv @@ -9,7 +9,7 @@ rwfunc bsearch(arr:*[int64]·int64, n:int64, target:int64) -> (idx:int64) { while (lo <= hi) { lo + hi -> s s ÷ 2 -> mid - kv·get(arr, mid) -> mv + kvspace·get(arr, mid) -> mv if (mv == target) { mid -> idx hi + 1 -> lo diff --git a/benchmark/cases/binary_trees/binary_trees.kv b/benchmark/cases/binary_trees/binary_trees.kv index e3b48757..6f2f270a 100644 --- a/benchmark/cases/binary_trees/binary_trees.kv +++ b/benchmark/cases/binary_trees/binary_trees.kv @@ -21,8 +21,8 @@ rwfunc test() -> () { top + 1 -> top while (top > 0) { top - 1 -> top - kv·get(bid, top) -> cur - kv·get(bdep, top) -> d + kvspace·get(bid, top) -> cur + kvspace·get(bdep, top) -> d if (d > 0) { nid + 1 -> nid nid -> lc @@ -50,10 +50,10 @@ rwfunc test() -> () { tp + 1 -> tp while (tp > 0) { tp - 1 -> tp - kv·get(tid, tp) -> cur + kvspace·get(tid, tp) -> cur count + 1 -> count - kv·get(L, cur) -> lc - kv·get(R, cur) -> rc + kvspace·get(L, cur) -> lc + kvspace·get(R, cur) -> rc if (lc != 0) { lc -> tid·*tp tp + 1 -> tp diff --git a/benchmark/cases/hash_table/hash_table.kv b/benchmark/cases/hash_table/hash_table.kv index 0a54351c..3ddcf82d 100644 --- a/benchmark/cases/hash_table/hash_table.kv +++ b/benchmark/cases/hash_table/hash_table.kv @@ -19,10 +19,10 @@ rwfunc test() -> () { while (i < n) { i × 2654435761 -> k0 k0 % 100003 -> key - kv·get(h, key) != None -> ex + kvspace·get(h, key) != None -> ex if (ex) { hits + 1 -> hits - kv·get(h, key) -> v + kvspace·get(h, key) -> v sum + v -> sum } i + 1 -> i diff --git a/benchmark/cases/k_nucleotide/k_nucleotide.kv b/benchmark/cases/k_nucleotide/k_nucleotide.kv index f46c20d8..0676d091 100644 --- a/benchmark/cases/k_nucleotide/k_nucleotide.kv +++ b/benchmark/cases/k_nucleotide/k_nucleotide.kv @@ -18,7 +18,7 @@ rwfunc test() -> () { while (i < n) { string·char(s, i) -> ch string·ord(ch) -> c - kv·get(h, c) -> cur + kvspace·get(h, c) -> cur if (cur == None) { 0 -> cur } @@ -27,10 +27,10 @@ rwfunc test() -> () { i + 1 -> i } t1 = time·now() - kv·get(h, 65) -> a - kv·get(h, 67) -> cc - kv·get(h, 71) -> g - kv·get(h, 84) -> t + kvspace·get(h, 65) -> a + kvspace·get(h, 67) -> cc + kvspace·get(h, 71) -> g + kvspace·get(h, 84) -> t println("knuc: A =", a, "C =", cc, "G =", g, "T =", t) delta = time·sub(t1, t0) ns = time/duration·as_nanos(delta) diff --git a/error_cases/index_error/at_oob.kv b/error_cases/index_error/at_oob.kv index f9d6a66f..152c9ab6 100644 --- a/error_cases/index_error/at_oob.kv +++ b/error_cases/index_error/at_oob.kv @@ -2,5 +2,5 @@ // error: KeyError: kv·at: key not found rwfunc test() -> () { - kv·get([1, 2], 5) -> _ + kvspace·get([1, 2], 5) -> _ } diff --git a/error_cases/index_error/typed_array_string_key.kv b/error_cases/index_error/typed_array_string_key.kv index 18ac76b9..7b5626f7 100644 --- a/error_cases/index_error/typed_array_string_key.kv +++ b/error_cases/index_error/typed_array_string_key.kv @@ -3,5 +3,5 @@ rwfunc test() -> () { arr:[]int32 = [1, 2, 3] - kv·get(arr, "key") -> _ + kvspace·get(arr, "key") -> _ } diff --git a/error_cases/key_error/kv_at_missing.kv b/error_cases/key_error/kv_at_missing.kv index 579e5dfc..cb1117e1 100644 --- a/error_cases/key_error/kv_at_missing.kv +++ b/error_cases/key_error/kv_at_missing.kv @@ -2,5 +2,5 @@ // error: KeyError: kv·at: key not found rwfunc test() -> () { - kv·get("/x", "y") -> _ + kvspace·get("/x", "y") -> _ } diff --git a/layout/src/lower.rs b/layout/src/lower.rs index f52e2b94..92d8c0bd 100644 --- a/layout/src/lower.rs +++ b/layout/src/lower.rs @@ -12,7 +12,7 @@ fn is_container_type(t: &str) -> bool { t == "stringkeymap" || t.contains(keytree::MEMBER_SEP) } -/// `[]` 下标校验：xv·at/xv·set 基座若为容器类型 → 报错，逼用 kv·get/kv·set/`base·key`。 +/// `[]` 下标校验：xv·at/xv·set 基座若为容器类型 → 报错，逼用 kvspace·get/kvspace·set/`base·key`。 fn is_container_ty(ty: &str) -> bool { // 剥掉间接性前缀 `*`/`@` 再判：签名里 `p:*Point`、`m:*[int64]·int64` 的 `*` 是传递方式， // 类型本体仍是值容器——不剥会把这类参数误判为"未定义容器"，成员写全部被拒。 @@ -185,9 +185,9 @@ fn check_map_inst(s: &Instruction, defined: &HashSet, diags: &mut Vec= 3 && !e.args[0].val.contains('/') { + if e.op == "kvspace·set" && e.args.len() >= 3 && !e.args[0].val.contains('/') { check_map_base(&e.args[0].val, defined, Pos { line: 0, col: 0 }, diags); } } @@ -243,7 +243,7 @@ fn check_subscript_expr(e: &Expr, tm: &HashMap, diags: &mut Vec< diags.push(Diagnostic { pos: Pos { line: 0, col: 0 }, message: format!( - "`[]` 下标不能用于容器 `{}`（类型 {}）；容器成员访问用 kv·get/kv·set 或 `{}·key`，`[]` 仅限 compact array", + "`[]` 下标不能用于容器 `{}`（类型 {}）；容器成员访问用 kvspace·get/kvspace·set 或 `{}·key`，`[]` 仅限 compact array", base.val, t, base.val ), warn: false, @@ -558,7 +558,7 @@ fn lower_for_with_cont( let cond_slot = lg.tmp(); let len_slot = lg.tmp(); let key_slot = lg.tmp(); - // 容器源（stringkeymap/struct）用 kv·listlen/kv·listn/kv·get 遍历，compact 数组源用 + // 容器源（stringkeymap/struct）用 kvspace·listlen/kvspace·listn/kvspace·get 遍历，compact 数组源用 // ndarray·numel/xv·at（见 spec 控制流脱糖）。判据看**声明的类型**：map 的 kindexpr 恒含 // `key·value` 的那个 `·`（`[int64]·int64`、`[]char/utf8·int64`），compact 数组不含。 let is_obj = s.iter.op == "obj" @@ -592,7 +592,7 @@ fn lower_for_with_cont( if is_obj { init_body.push(Stmt::Instruction(Instruction { comments: Vec::new(), - expr: Some(ast::call("kv·listlen", vec![ast::leaf(&iter_slot)])), + expr: Some(ast::call("kvspace·listlen", vec![ast::leaf(&iter_slot)])), writes: vec![len_slot.clone()], write_types: Vec::new(), arrow_left: false, @@ -641,7 +641,7 @@ fn lower_for_with_cont( body_insts.push(Stmt::Instruction(Instruction { comments: Vec::new(), expr: Some(ast::call( - "kv·listn", + "kvspace·listn", vec![ast::leaf(&iter_slot), ast::leaf(&idx_slot)], )), writes: vec![key_slot.clone()], @@ -651,7 +651,7 @@ fn lower_for_with_cont( body_insts.push(Stmt::Instruction(Instruction { comments: Vec::new(), expr: Some(ast::call( - "kv·get", + "kvspace·get", vec![ast::leaf(&iter_slot), ast::leaf(&key_slot)], )), writes: vec![s.var.clone()], @@ -1043,19 +1043,19 @@ fn infer_op_type(opcode: &str, reads: &[String], tm: &mut HashMap { return "int64".to_string(); } "xv·langtype" => return "[]char/utf8".to_string(), "ndarray·shape" => return "[]int64".to_string(), - "kv·list" => return "[]char/utf8".to_string(), + "kvspace·list" => return "[]char/utf8".to_string(), "string·char" | "string·set" | "string·slice" | "string·concat" | "string·formatint" | "string·formatuint" => return "char/utf32".to_string(), "random.int63" => return "int64".to_string(), diff --git a/layout/src/parser.rs b/layout/src/parser.rs index 0653677d..0cb5ee05 100644 --- a/layout/src/parser.rs +++ b/layout/src/parser.rs @@ -804,11 +804,11 @@ impl Parser { bad(p, w, fname); } } - // kv.set 成员形（3 读：base, key, val）改写 base 的成员目录，命中读参**或别名**即拒绝。 + // kvspace·set 成员形（3 读：base, key, val）改写 base 的成员目录，命中读参**或别名**即拒绝。 // 被写的参数**必须**声明在写参侧（签名诚实原则）——要就地改调用方的对象， // 就把该参数写到 `-> (p:Point)` 里，而不是留在读参侧靠别名绕。 if let Some(e) = &inst.expr { - if e.op == "kv·set" && e.args.len() >= 3 { + if e.op == "kvspace·set" && e.args.len() >= 3 { let base = &e.args[0].val; if !base.contains('/') && (ro.contains(base) || tainted.contains_key(base)) { if ro.contains(base) { @@ -1274,8 +1274,8 @@ impl Parser { fn parse_pratt(&mut self, min_prec: i32) -> Option { let mut left = self.parse_primary_expr()?; - // 成员链：base + 各段收集成单个变参 kv·get(base, seg1, seg2, ...)，runtime 直接拼路径。 - // 不在 layout 摊成嵌套 kv·get（内层返回的是值，丢路径，#110）。每段为静态字面量或 + // 成员链：base + 各段收集成单个变参 kvspace·get(base, seg1, seg2, ...)，runtime 直接拼路径。 + // 不在 layout 摊成嵌套 kvspace·get（内层返回的是值，丢路径，#110）。每段为静态字面量或 // 动态键（*k 的变量）。 let mut chain_base: Option = None; let mut chain_segs: Vec = Vec::new(); @@ -1327,11 +1327,11 @@ impl Parser { continue; } } - // 成员链被打断（下标/中缀/循环尾）：flush 成单个变参 kv·get。 + // 成员链被打断（下标/中缀/循环尾）：flush 成单个变参 kvspace·get。 if let Some(base) = chain_base.take() { let mut args = vec![base]; args.append(&mut chain_segs); - left = ast::call("kv·get", args); + left = ast::call("kvspace·get", args); } // 后缀索引 if self.peek().kind == Kind::LBrack { @@ -1349,8 +1349,8 @@ impl Parser { let is_path = left.is_leaf() && left.val.starts_with('/'); let mut args = vec![left]; args.extend(indices); - // 路径字面量 + [idx] → kv.get（KV 路径成员访问）；否则 xv.at（compact 数组元素）。 - left = ast::call(if is_path { "kv·get" } else { "xv·at" }, args); + // 路径字面量 + [idx] → kvspace·get（KV 路径成员访问）；否则 xv.at（compact 数组元素）。 + left = ast::call(if is_path { "kvspace·get" } else { "xv·at" }, args); continue; } let t = self.peek(); @@ -1368,7 +1368,7 @@ impl Parser { if let Some(base) = chain_base.take() { let mut args = vec![base]; args.append(&mut chain_segs); - left = ast::call("kv·get", args); + left = ast::call("kvspace·get", args); } Some(left) } @@ -1407,12 +1407,12 @@ impl Parser { if symbol::lookup(&t.value).word == "add" { return self.parse_pratt(UNARY_PREC); } - // 一元前缀 & = 取址：&x ≡ kv·abs(x)（中缀 & 仍为按位与，走 pratt 中缀路径）。 - // & 对成员链 kv·get(base, segs...) → kv·abs(base, segs...)：取成员路径地址，非读值取址。 + // 一元前缀 & = 取址：&x ≡ kvlang·abs(x)（中缀 & 仍为按位与，走 pratt 中缀路径）。 + // & 对成员链 kvspace·get(base, segs...) → kvlang·abs(base, segs...)：取成员路径地址，非读值取址。 if symbol::lookup(&t.value).word == "bitand" { let arg = self.parse_pratt(UNARY_PREC)?; - let op = format!("kv{}abs", keytree::MEMBER_SEP); - let get = format!("kv{}get", keytree::MEMBER_SEP); + let op = format!("kvlang{}abs", keytree::MEMBER_SEP); + let get = format!("kvspace{}get", keytree::MEMBER_SEP); if arg.op == get && arg.args.len() >= 2 { return Some(ast::call(&op, arg.args)); } @@ -1897,7 +1897,7 @@ impl Parser { if (t.kind == Kind::Ident || is_path_literal) && self.peek_at(1).kind == Kind::Dot { let mut w = self.advance().value; // 成员链写槽：整段 p·obj·deep 收成单个 write 槽，交给 desugar_member_write - // 拆成 kv·set(base, "obj·deep", v)。勿在每段 · 处截断（否则 deep 被当独立写槽）。 + // 拆成 kvspace·set(base, "obj·deep", v)。勿在每段 · 处截断（否则 deep 被当独立写槽）。 while self.peek().kind == Kind::Dot { self.advance(); // . w.push_str(keytree::MEMBER_SEP); @@ -2054,7 +2054,7 @@ impl Parser { } // 下标写脱糖：arr[i,j] 写槽 + 值 e → xv·set(arr, i, j, e) -> arr（compact 数组， - // 读侧 arr[i,j]→xv·at 的对称）。arr· 前缀坐标或 / 路径 → kv·set。左右箭头共用： + // 读侧 arr[i,j]→xv·at 的对称）。arr· 前缀坐标或 / 路径 → kvspace·set。左右箭头共用： // = 时 e 是 pratt 右值，-> 时 e 是箭头左值，语义一致。layout 不判维数，交给 runtime。 fn desugar_subscript_write(&mut self, inst: &mut Instruction) { if inst.writes.len() != 1 || !inst.writes[0].contains('[') { @@ -2068,7 +2068,7 @@ impl Parser { let dot_coord = arr.ends_with(keytree::MEMBER_SEP); let arr = arr.trim_end_matches(keytree::MEMBER_SEP).to_string(); let op = if dot_coord || arr.starts_with('/') { - "kv·set" + "kvspace·set" } else { "xv·set" }; @@ -2101,13 +2101,13 @@ impl Parser { } let s = inst.writes[0].clone(); // 路径字面量（/ 开头）是完整 key，不是成员写，勿脱糖——**但含动态键段 `·*k` 的除外**： - // 那时 `·` 之后是运行期求值的段，必须脱糖成 kv·set(base, k, v) 才能取到 k 的值 + // 那时 `·` 之后是运行期求值的段，必须脱糖成 kvspace·set(base, k, v) 才能取到 k 的值 // （否则会被当成字面 key `/tmp/ts·*k` 整段写下去）。 if s.starts_with('/') && !s.contains(&format!("{}*", keytree::MEMBER_SEP)) { return; } - // struct 赋值（RHS = struct·new）：浅拷 base+一层成员，lower 为 kv·cplist(struct·new→temp, dst)。 - // 不走 kv·set —— 后者只搬基值，struct 的成员会丢在临时槽。dst 传完整成员槽串， + // struct 赋值（RHS = struct·new）：浅拷 base+一层成员，lower 为 kvspace·cplist(struct·new→temp, dst)。 + // 不走 kvspace·set —— 后者只搬基值，struct 的成员会丢在临时槽。dst 传完整成员槽串， // runtime ResolveWriteSlot 拼 +"base·key…" 即成员绝对路径。 let is_struct_new = inst .expr @@ -2116,13 +2116,13 @@ impl Parser { .unwrap_or(false); if is_struct_new && !s.contains('*') { let e = inst.expr.take().unwrap(); - inst.expr = Some(ast::call("kv·cplist", vec![e, ast::leaf(&s)])); + inst.expr = Some(ast::call("kvspace·cplist", vec![e, ast::leaf(&s)])); inst.writes = Vec::new(); inst.write_types = Vec::new(); return; } - // 成员链写槽 p·a·b = v → 变参 kv·set(p, "a", "b", v)，与读侧 #110 一致逐段拼路径。 - // 不再按首个 · 压扁成 kv·set(p, "a·b", v)：扁平段把「成员链」与「含 · 的成员名」混为一谈。 + // 成员链写槽 p·a·b = v → 变参 kvspace·set(p, "a", "b", v)，与读侧 #110 一致逐段拼路径。 + // 不再按首个 · 压扁成 kvspace·set(p, "a·b", v)：扁平段把「成员链」与「含 · 的成员名」混为一谈。 let mut parts = s.split(keytree::MEMBER_SEP); let base = parts.next().unwrap_or("").to_string(); let mut args = vec![ast::leaf(&base)]; @@ -2148,8 +2148,8 @@ impl Parser { } let e = inst.expr.take(); args.push(e.unwrap_or(ast::leaf(""))); - // base.a.b = v 脱糖为 kv·set(base, "a", "b", v)：kv·set 是 void（副作用写成员），无写槽 - inst.expr = Some(ast::call("kv·set", args)); + // base.a.b = v 脱糖为 kvspace·set(base, "a", "b", v)：kvspace·set 是 void（副作用写成员），无写槽 + inst.expr = Some(ast::call("kvspace·set", args)); inst.writes = Vec::new(); inst.write_types = Vec::new(); } diff --git a/layout/src/scanner.rs b/layout/src/scanner.rs index 1439978b..7665f648 100644 --- a/layout/src/scanner.rs +++ b/layout/src/scanner.rs @@ -464,7 +464,7 @@ pub fn scan(src: &str) -> Vec { // ·（U+00B7）与 .（释放给小数 key）是路径字符；· 后的坐标段 [0,1] 是成员链。 if src[i] == 0xC2 && i + 1 < src.len() && src[i + 1] == 0xB7 { // `·*`（动态成员名）不并入路径：让 `·`/`*`/`k` 单独成 token，交成员链解析 - // 成 `kv·get/kv·set(base, k)`。`·` 后接名字的情况（`/lib/json·to` 的 + // 成 `kvspace·get/kvspace·set(base, k)`。`·` 后接名字的情况（`/lib/json·to` 的 // 包·函数分隔符、`/tmp/ts·5` 的静态成员）仍按原样整段吃进路径 token。 if i + 2 < src.len() && src[i + 2] == b'*' { break; diff --git a/runtime-rs/build.rs b/runtime-rs/build.rs index bdee0cc2..d852c32c 100644 --- a/runtime-rs/build.rs +++ b/runtime-rs/build.rs @@ -1,7 +1,7 @@ // 链接 stock 三方 .so（camelCase，符合 deepx-design/doc/abi-naming-standard.md）： // kvlang_runtime —— 模式2 主导执行 + rwirext 宿主 ABI（kvlang/bin 新构建优先，回落 /usr/lib） // kvspace —— dispatch 前端，按 DSN 运行时选后端（/usr/lib） -// kvlanglayout —— .kv 编译入库（kvlanglayout·* rwir + 启动 layout stdlib 用，/usr/lib） +// kvlanglayout —— .kv 编译入库（kvlang·* rwir + 启动 layout stdlib 用，/usr/lib） // 并把 stdlib/**/*.kv（顶层语言级标准库）全部 include_str! 进二进制（EMBEDDED_KV），启动时 layout 进 kvspace。 use std::path::{Path, PathBuf}; diff --git a/runtime-rs/src/engine.rs b/runtime-rs/src/engine.rs index 611c274e..1b2cfcf2 100644 --- a/runtime-rs/src/engine.rs +++ b/runtime-rs/src/engine.rs @@ -245,7 +245,7 @@ impl Engine { } } - /// 写一个字符串列表容器（供 fs·list 等返回可 for-in 的字符串列表，对齐 C kv·list 表示）： + /// 写一个字符串列表容器（供 fs·list 等返回可 for-in 的字符串列表，对齐 C kvspace·list 表示）： /// dst = 容器值：langtype=`[int64]·[]char/utf32`（见 [[map容器]]），body 空，dims=[n] /// dst· = memindex：kind=index，body=[4B count LE]["[0]\n[1]\n..."]（成员坐标名唯一权威） /// dst·[i] = 各成员字符串（char/utf32） diff --git a/runtime-rs/src/rwir/kvlanglayout.rs b/runtime-rs/src/rwir/kvlanglayout.rs index 0e9879d6..bf8bfd24 100644 --- a/runtime-rs/src/rwir/kvlanglayout.rs +++ b/runtime-rs/src/rwir/kvlanglayout.rs @@ -1,8 +1,8 @@ -//! rwir `kvlanglayout·*`：自造 kv 代码入库/导出（直连 layout 的 C ABI）。 -//! kvlanglayout·vet(src) -> "ok" | 错误信息 只校验（parse+lower），不写 kvspace -//! kvlanglayout·format(src) -> 规范化源码 | "error: …" 格式化（parse→规范化），不写 kvspace -//! kvlanglayout·layout(src) -> entry | "error: …" 把内存源码 layout 进 kvspace -//! kvlanglayout·dump(lib) -> dump 文本 | "error: …" 把 /lib 子树重构为可运行 kvlang 源码 +//! rwir `kvlang·*`：自造 kv 代码入库/导出（直连 layout 的 C ABI）。 +//! kvlang·vet(src) -> "ok" | 错误信息 只校验（parse+lower），不写 kvspace +//! kvlang·format(src) -> 规范化源码 | "error: …" 格式化（parse→规范化），不写 kvspace +//! kvlang·layout(src) -> entry | "error: …" 把内存源码 layout 进 kvspace +//! kvlang·dump(lib) -> dump 文本 | "error: …" 把 /lib 子树重构为可运行 kvlang 源码 //! 四者都在 C 边界 catch_unwind：坏代码返回 -1，绝不打崩宿主进程。 use std::ffi::c_char; diff --git a/runtime-rs/src/rwir/mod.rs b/runtime-rs/src/rwir/mod.rs index 05574e04..0c24de01 100644 --- a/runtime-rs/src/rwir/mod.rs +++ b/runtime-rs/src/rwir/mod.rs @@ -3,7 +3,7 @@ //! term : print / println / cerr / printf / input 行输出 + C 风格格式化 + 读 stdin（裸 rwir） //! json : json·to / json·from KV 子树 ↔ JSON 文本 //! http : http·call 网络抓取（ureq 原生） -//! kvlanglayout : kvlanglayout·vet/format/layout/dump 自造 kv 代码入库（layout C ABI） +//! kvlanglayout : kvlang·vet/format/layout/dump 自造 kv 代码入库（layout C ABI） //! networld : networld/proc·exec、networld/fs·size/read/write/append/list/del/mkdir/exists 外部进程 + 宿主文件系统 //! 不纯 rwir（llm/shell/python/byteseek·run 等）留在 byteseek，依赖本库后自行叠加。 @@ -90,28 +90,28 @@ pub const MYRWIRCAPS: &[(&str, Rwir)] = &[ }, ), ( - "kvlanglayout·vet", + "kvlang·vet", Rwir { rp: &["[]char/utf32"], wp: &["[]char/utf32"], }, ), ( - "kvlanglayout·format", + "kvlang·format", Rwir { rp: &["[]char/utf32"], wp: &["[]char/utf32"], }, ), ( - "kvlanglayout·layout", + "kvlang·layout", Rwir { rp: &["[]char/utf32"], wp: &["[]char/utf32"], }, ), ( - "kvlanglayout·dump", + "kvlang·dump", Rwir { rp: &["[]char/utf32"], wp: &["[]char/utf32"], @@ -219,10 +219,10 @@ pub fn is_inproc(op: &str) -> bool { | "json·to" | "json·from" | "http·call" - | "kvlanglayout·vet" - | "kvlanglayout·format" - | "kvlanglayout·layout" - | "kvlanglayout·dump" + | "kvlang·vet" + | "kvlang·format" + | "kvlang·layout" + | "kvlang·dump" | "networld/proc·exec" | "networld/fs·size" | "networld/fs·read" @@ -258,19 +258,19 @@ pub fn dispatch(eng: &Engine, op: &str, pc: &str) { "networld/fs·del" => networld::fs::del(eng, pc), "networld/fs·mkdir" => networld::fs::mkdir(eng, pc), "networld/fs·exists" => networld::fs::exists(eng, pc), - "kvlanglayout·vet" => { + "kvlang·vet" => { let out = kvlanglayout::vet(eng, &eng.read0(pc)); eng.set_kv(&eng.write0(pc), &out); } - "kvlanglayout·format" => { + "kvlang·format" => { let out = kvlanglayout::format(eng, &eng.read0(pc)); eng.set_kv(&eng.write0(pc), &out); } - "kvlanglayout·layout" => { + "kvlang·layout" => { let out = kvlanglayout::layout(eng, &eng.read0(pc)); eng.set_kv(&eng.write0(pc), &out); } - "kvlanglayout·dump" => { + "kvlang·dump" => { let out = kvlanglayout::dump(eng, &eng.read0(pc)); eng.set_kv(&eng.write0(pc), &out); } diff --git a/runtime-rwirext_example/go/json/tutorial/json_local.kv b/runtime-rwirext_example/go/json/tutorial/json_local.kv index b1091a31..b437afef 100644 --- a/runtime-rwirext_example/go/json/tutorial/json_local.kv +++ b/runtime-rwirext_example/go/json/tutorial/json_local.kv @@ -4,7 +4,7 @@ // 2) go build -o /tmp/json-rwirext ./rwirext/json/cmd/ && /tmp/json-rwirext & // 3) ./kvlang tutorial/10-rwirext/json_local.kv // 语义: json·to 接受局部 object/stringkeymap 变量（resolve 到帧槽路径后序列化）。 -// object 局部变量（{} + kv·set）→ JSON 对象；stringkeymap 局部变量（{..} 散 key +// object 局部变量（{} + kvspace·set）→ JSON 对象；stringkeymap 局部变量（{..} 散 key // 数组）→ JSON 数组。散 key 数组成员名是坐标段 "[i]"。 // 期望输出: // profile = {"active":true,"age":42,"name":"alice","nums":[1,2,3],"score":3.14} @@ -12,12 +12,12 @@ // tags = ["a","b","c"] rwfunc main() -> () { profile = {} - kv·set(profile, "name", "alice") - kv·set(profile, "age", 42) - kv·set(profile, "active", true) - kv·set(profile, "score", 3.14) + kvspace·set(profile, "name", "alice") + kvspace·set(profile, "age", 42) + kvspace·set(profile, "active", true) + kvspace·set(profile, "score", 3.14) nums = [1, 2, 3] - kv·set(profile, "nums", nums) + kvspace·set(profile, "nums", nums) json·to(profile) -> j1 println("profile =", j1) diff --git a/runtime/src/builtin.c b/runtime/src/builtin.c index 0a126450..929eea45 100644 --- a/runtime/src/builtin.c +++ b/runtime/src/builtin.c @@ -95,7 +95,7 @@ void kvlangBuiltinResolveReadValue(kvlangKv_t *kv, const char *frame_root, const kvlangXvalue_t pv; kvlangXvalueZero(&pv); kvlangKvGetMember(kv, stk, name, &pv); if (kvlangXvalueIsPtr(&pv)) { - /* 数据 Ptr（&x）：地址值本体，读值不解引用。成员访问另走 kv·get 的 member_path。 */ + /* 数据 Ptr（&x）：地址值本体，读值不解引用。成员访问另走 kvspace·get 的 member_path。 */ *out = pv; pv.data = NULL; pv.len = 0; } else if (!kvlangXvalueNone(&pv)) { *out = pv; pv.data = NULL; pv.len = 0; @@ -609,9 +609,9 @@ static const struct { const char *op; kvlangBuiltinFn fn; } myrwircaps[] = { {"time/duration·before", kvlangBuiltinDurCmp}, {"time/duration·after", kvlangBuiltinDurCmp}, {"time·before", kvlangBuiltinTimeCmp}, {"time·after", kvlangBuiltinTimeCmp}, {"random·uint64", kvlangBuiltinRandUint64}, {"random·int63", kvlangBuiltinRandInt63}, {"random·intn", kvlangBuiltinRandIntn}, - {"kv·get", kvlangBuiltinKvGet}, {"kv·set", kvlangBuiltinKvSet}, {"kv·del", kvlangBuiltinKvDel}, - {"kv·deltree", kvlangBuiltinKvDelTree}, {"kv·cp", kvlangBuiltinKvCp}, {"kv·cpdir", kvlangBuiltinKvCpTree}, {"kv·cplist", kvlangBuiltinKvCpList}, {"kv·list", kvlangBuiltinKvList}, {"kv·listlen", kvlangBuiltinKvListLen}, {"kv·listn", kvlangBuiltinKvListN}, {"kv·mkindex", kvlangBuiltinKvMkindex}, - {"kv·extindex", kvlangBuiltinKvExtIndex}, {"kv·rmindexext", kvlangBuiltinKvRmIndexExt}, {"kv·watch", kvlangBuiltinKvWatch}, {"kv·abs", kvlangBuiltinKvAbs}, + {"kvspace·get", kvlangCGet}, {"kvspace·set", kvlangCSet}, {"kvspace·del", kvlangCDel}, + {"kvspace·deltree", kvlangCDelTree}, {"kvspace·cp", kvlangCCp}, {"kvspace·cpdir", kvlangCCpTree}, {"kvspace·cplist", kvlangCCpList}, {"kvspace·list", kvlangCList}, {"kvspace·listlen", kvlangCListLen}, {"kvspace·listn", kvlangCListN}, {"kvspace·mkindex", kvlangCMkindex}, + {"kvspace·extindex", kvlangCExtIndex}, {"kvspace·rmindexext", kvlangCRmIndexExt}, {"kvspace·watch", kvlangCWatch}, {"kvlang·abs", kvlangCAbs}, {"vthread·create", kvlangBuiltinVthreadCreate}, {"vthread·run", kvlangBuiltinVthreadRun}, {"vthread·call", kvlangBuiltinVthreadCall}, @@ -687,7 +687,7 @@ int kvlangBuiltinExecuteCopy(kvlangKv_t *kv, const char *vtid, const char *pc, k const char *slot = inst->writes[i].name; const char *dot = strstr(slot, MEMBER_SEP); if (dot && dot != slot) { - /* 成员写前置条件：memhead 必须已存在（同 kv·set，见 builtin_kv.c）。 */ + /* 成员写前置条件：memhead 必须已存在（同 kvspace·set，见 builtin_kv.c）。 */ char *b = strndup(slot, (size_t)(dot - slot)); int ok = kvlangBuiltinCheckMemhead(kv, fr, b); char msg[320]; @@ -784,7 +784,7 @@ int kvlangBuiltinExecuteCopy(kvlangKv_t *kv, const char *vtid, const char *pc, k -/* ── kv.* ─────────────────────────────────────────────────────────── */ +/* ── kvspace·* ─────────────────────────────────────────────── */ diff --git a/runtime/src/builtin_collection.c b/runtime/src/builtin_collection.c index c44a743b..cadce3d1 100644 --- a/runtime/src/builtin_collection.c +++ b/runtime/src/builtin_collection.c @@ -223,7 +223,7 @@ static int xv_head1(kvlangFrame_t *f, kvspaceHead_t *h); /* GetHead-only 单读参 head，定义见下 */ /* ndarray 形状算子只认带形状段的 langtype。map 容器（langtype=`{keylt}·{valt}`）无形状段—— - * 成员数在 memindex（`p·`）而非容器值，用 ndarray·numel 取是范畴错误，直接报错逼用 kv·listlen。 */ + * 成员数在 memindex（`p·`）而非容器值，用 ndarray·numel 取是范畴错误，直接报错逼用 kvspace·listlen。 */ static int ndarray_shape_guard(kvlangFrame_t *f, const char *op, const kvspaceHead_t *h) { kvlangLangtype kx; @@ -233,7 +233,7 @@ static int ndarray_shape_guard(kvlangFrame_t *f, const char *op, if (kvlangKindIsMap(kx.kind)) return kvlangBuiltinSetErr(f, "TypeError: %s: container %s has no shape; " - "use kv·listlen for member count", + "use kvspace·listlen for member count", op, kx.kind); return 0; } diff --git a/runtime/src/builtin_internal.h b/runtime/src/builtin_internal.h index 8e676d05..994676d8 100644 --- a/runtime/src/builtin_internal.h +++ b/runtime/src/builtin_internal.h @@ -58,20 +58,20 @@ int kvlangBuiltinArray(kvlangFrame_t *f), kvlangBuiltinRandUint64(kvlangFrame_t *f), kvlangBuiltinRandInt63(kvlangFrame_t *f), kvlangBuiltinRandIntn(kvlangFrame_t *f), - kvlangBuiltinKvGet(kvlangFrame_t *f), kvlangBuiltinKvSet(kvlangFrame_t *f), - kvlangBuiltinKvDel(kvlangFrame_t *f), - kvlangBuiltinKvDelTree(kvlangFrame_t *f), - kvlangBuiltinKvCp(kvlangFrame_t *f), - kvlangBuiltinKvCpTree(kvlangFrame_t *f), - kvlangBuiltinKvCpList(kvlangFrame_t *f), - kvlangBuiltinKvList(kvlangFrame_t *f), - kvlangBuiltinKvListLen(kvlangFrame_t *f), - kvlangBuiltinKvListN(kvlangFrame_t *f), - kvlangBuiltinKvMkindex(kvlangFrame_t *f), - kvlangBuiltinKvExtIndex(kvlangFrame_t *f), - kvlangBuiltinKvRmIndexExt(kvlangFrame_t *f), - kvlangBuiltinKvWatch(kvlangFrame_t *f), - kvlangBuiltinKvAbs(kvlangFrame_t *f), + kvlangCGet(kvlangFrame_t *f), kvlangCSet(kvlangFrame_t *f), + kvlangCDel(kvlangFrame_t *f), + kvlangCDelTree(kvlangFrame_t *f), + kvlangCCp(kvlangFrame_t *f), + kvlangCCpTree(kvlangFrame_t *f), + kvlangCCpList(kvlangFrame_t *f), + kvlangCList(kvlangFrame_t *f), + kvlangCListLen(kvlangFrame_t *f), + kvlangCListN(kvlangFrame_t *f), + kvlangCMkindex(kvlangFrame_t *f), + kvlangCExtIndex(kvlangFrame_t *f), + kvlangCRmIndexExt(kvlangFrame_t *f), + kvlangCWatch(kvlangFrame_t *f), + kvlangCAbs(kvlangFrame_t *f), kvlangBuiltinDebugger(kvlangFrame_t *f), kvlangBuiltinVthreadCreate(kvlangFrame_t *f), kvlangBuiltinVthreadRun(kvlangFrame_t *f), diff --git a/runtime/src/builtin_kv.c b/runtime/src/builtin_kv.c index a198b169..2dbcc8b2 100644 --- a/runtime/src/builtin_kv.c +++ b/runtime/src/builtin_kv.c @@ -1,4 +1,4 @@ -// builtin_kv —— kv·* KV 树 rwir +// builtin_kv —— kvspace·* KV 树 rwir #include "builtin_internal.h" @@ -66,14 +66,14 @@ static char *member_path(kvlangFrame_t *f, const kvlangXvalue_t *in, int n) { return bp; } -int kvlangBuiltinKvGet(kvlangFrame_t *f) { +int kvlangCGet(kvlangFrame_t *f) { kvlangXvalue_t in[MAX_PARAMS]; int n = kvlangBuiltinReadInputs(f, in, MAX_PARAMS); char *key = f->inst->nr >= 2 ? member_path(f, in, n) : (n >= 1 ? path_arg(f, 0, in) : NULL); if (!key) { kvlangBuiltinFreeInputs(in, n); - return kvlangBuiltinSetErr(f, "TypeError: kv.get requires a path"); + return kvlangBuiltinSetErr(f, "TypeError: kvspace·get requires a path"); } kvlangXvalue_t v; kvlangXvalueZero(&v); @@ -104,7 +104,7 @@ int kvlangBuiltinCheckMemhead(kvlangKv_t *kv, const char *frame_root, return ok ? 0 : -1; } -int kvlangBuiltinKvSet(kvlangFrame_t *f) { +int kvlangCSet(kvlangFrame_t *f) { kvlangXvalue_t in[MAX_PARAMS]; int n = kvlangBuiltinReadInputs(f, in, MAX_PARAMS); char *key; @@ -132,7 +132,7 @@ int kvlangBuiltinKvSet(kvlangFrame_t *f) { free(key); kvlangBuiltinFreeInputs(in, n); return kvlangBuiltinSetErr(f, - "TypeError: kv.set requires path and value"); + "TypeError: kvspace·set requires path and value"); } kvlangKvPair_t p = {key, *val}; char err[256]; @@ -166,15 +166,15 @@ static int kv_path_void(kvlangFrame_t *f, const char *name, return 0; } -int kvlangBuiltinKvDel(kvlangFrame_t *f) { - return kv_path_void(f, "kv.del", kvlangKvDel); +int kvlangCDel(kvlangFrame_t *f) { + return kv_path_void(f, "kvspace·del", kvlangKvDel); } -int kvlangBuiltinKvDelTree(kvlangFrame_t *f) { - return kv_path_void(f, "kv.deltree", kvlangKvDelTree); +int kvlangCDelTree(kvlangFrame_t *f) { + return kv_path_void(f, "kvspace·deltree", kvlangKvDelTree); } -/* 绝对路径 / 路径字符串直取，否则裸标识符解析为本帧槽位 key（对齐 kv.list 的裸变量处理）。 */ +/* 绝对路径 / 路径字符串直取，否则裸标识符解析为本帧槽位 key（对齐 kvspace·list 的裸变量处理）。 */ static char *resolve_path_arg(kvlangFrame_t *f, int idx, const kvlangXvalue_t *in) { char *p = path_arg(f, idx, in); @@ -212,19 +212,19 @@ static int kv_two_path_void(kvlangFrame_t *f, const char *name, return 0; } -int kvlangBuiltinKvCp(kvlangFrame_t *f) { - return kv_two_path_void(f, "kv.cp", kvlangKvCp); +int kvlangCCp(kvlangFrame_t *f) { + return kv_two_path_void(f, "kvspace·cp", kvlangKvCp); } -int kvlangBuiltinKvCpTree(kvlangFrame_t *f) { - return kv_two_path_void(f, "kv.cpdir", kvlangKvCpTree); +int kvlangCCpTree(kvlangFrame_t *f) { + return kv_two_path_void(f, "kvspace·cpdir", kvlangKvCpTree); } -int kvlangBuiltinKvCpList(kvlangFrame_t *f) { - return kv_two_path_void(f, "kv.cplist", kvlangKvCpList); +int kvlangCCpList(kvlangFrame_t *f) { + return kv_two_path_void(f, "kvspace·cplist", kvlangKvCpList); } -int kvlangBuiltinKvAbs(kvlangFrame_t *f) { +int kvlangCAbs(kvlangFrame_t *f) { kvlangXvalue_t in[MAX_PARAMS]; int n = kvlangBuiltinReadInputs(f, in, MAX_PARAMS); char *p = NULL; @@ -234,10 +234,10 @@ int kvlangBuiltinKvAbs(kvlangFrame_t *f) { p = resolve_path_arg(f, 0, in); if (!p) { kvlangBuiltinFreeInputs(in, n); - return kvlangBuiltinSetErr(f, "TypeError: kv.abs requires a key"); + return kvlangBuiltinSetErr(f, "TypeError: kvlang·abs requires a key"); } /* 产出 Ptr（ref=1）：langtype = 目标 kindexpr、body = 目标绝对路径。 - * &x ≡ kv.abs(x)：取址返回指向 x 所在节点的软链接（单跳同型），不再产 char 路径串。 */ + * &x ≡ kvlang·abs(x)：取址返回指向 x 所在节点的软链接（单跳同型），不再产 char 路径串。 */ kvlangXvalue_t tg; kvlangXvalueZero(&tg); kvlangKvGetOne(f->kv, p, &tg); @@ -261,10 +261,10 @@ int kvlangBuiltinKvAbs(kvlangFrame_t *f) { return rc; } -int kvlangBuiltinKvList(kvlangFrame_t *f) { +int kvlangCList(kvlangFrame_t *f) { if (f->inst->nw == 0) return kvlangBuiltinSetErr(f, - "TypeError: kv.list requires a write param"); + "TypeError: kvspace·list requires a write param"); kvlangXvalue_t in[1]; int n = kvlangBuiltinReadInputs(f, in, 1); char *key = n >= 1 ? path_arg(f, 0, in) : NULL; @@ -281,7 +281,7 @@ int kvlangBuiltinKvList(kvlangFrame_t *f) { } if (!key) { kvlangBuiltinFreeInputs(in, n); - return kvlangBuiltinSetErr(f, "TypeError: kv.list requires 1 path arg"); + return kvlangBuiltinSetErr(f, "TypeError: kvspace·list requires 1 path arg"); } char **names = NULL; int count = 0; @@ -350,7 +350,7 @@ int kvlangBuiltinKvList(kvlangFrame_t *f) { return 0; } -/* 解析 obj/map 成员目录 key（/.），供 kv.list/listlen/listn 共用。 */ +/* 解析 obj/map 成员目录 key（/.），供 kvspace·list/listlen/listn 共用。 */ static char *kv_list_dir(kvlangFrame_t *f, kvlangXvalue_t *in, int n) { char *key = n >= 1 ? path_arg(f, 0, in) : NULL; if (!key && f->inst->nr >= 1) { @@ -366,7 +366,7 @@ static char *kv_list_dir(kvlangFrame_t *f, kvlangXvalue_t *in, int n) { return key; } -int kvlangBuiltinKvListLen(kvlangFrame_t *f) { +int kvlangCListLen(kvlangFrame_t *f) { kvlangXvalue_t in[1]; int n = kvlangBuiltinReadInputs(f, in, 1); char *key = kv_list_dir(f, in, n); @@ -389,7 +389,7 @@ int kvlangBuiltinKvListLen(kvlangFrame_t *f) { return rc; } -int kvlangBuiltinKvListN(kvlangFrame_t *f) { +int kvlangCListN(kvlangFrame_t *f) { kvlangXvalue_t in[2]; int n = kvlangBuiltinReadInputs(f, in, 2); char *key = kv_list_dir(f, in, n); @@ -414,13 +414,13 @@ int kvlangBuiltinKvListN(kvlangFrame_t *f) { return rc; } -int kvlangBuiltinKvMkindex(kvlangFrame_t *f) { +int kvlangCMkindex(kvlangFrame_t *f) { kvlangXvalue_t in[2]; int n = kvlangBuiltinReadInputs(f, in, 2); char *key = n >= 1 ? path_arg(f, 0, in) : NULL; if (!key) { kvlangBuiltinFreeInputs(in, n); - return kvlangBuiltinSetErr(f, "TypeError: kv.mkindex requires a path"); + return kvlangBuiltinSetErr(f, "TypeError: kvspace·mkindex requires a path"); } uint32_t capacity = n >= 2 ? (uint32_t)kvlangScalarI64(kvlangXvalueScalar(&in[1])) : 0; @@ -434,7 +434,7 @@ int kvlangBuiltinKvMkindex(kvlangFrame_t *f) { return 0; } -int kvlangBuiltinKvExtIndex(kvlangFrame_t *f) { +int kvlangCExtIndex(kvlangFrame_t *f) { kvlangXvalue_t in[2]; int n = kvlangBuiltinReadInputs(f, in, 2); char *key = n >= 1 ? path_arg(f, 0, in) : NULL; @@ -444,7 +444,7 @@ int kvlangBuiltinKvExtIndex(kvlangFrame_t *f) { free(ext); kvlangBuiltinFreeInputs(in, n); return kvlangBuiltinSetErr( - f, "TypeError: kv.extindex requires path and ext path"); + f, "TypeError: kvspace·extindex requires path and ext path"); } char err[256]; int rc = kvlangKvExtIndex(f->kv, key, ext, err, sizeof err); @@ -457,11 +457,11 @@ int kvlangBuiltinKvExtIndex(kvlangFrame_t *f) { return 0; } -int kvlangBuiltinKvRmIndexExt(kvlangFrame_t *f) { - return kv_path_void(f, "kv.rmindexext", kvlangKvDelExtIndex); +int kvlangCRmIndexExt(kvlangFrame_t *f) { + return kv_path_void(f, "kvspace·rmindexext", kvlangKvDelExtIndex); } -int kvlangBuiltinKvWatch(kvlangFrame_t *f) { +int kvlangCWatch(kvlangFrame_t *f) { kvlangXvalue_t in[2]; int n = kvlangBuiltinReadInputs(f, in, 2); char *key = n >= 1 ? path_arg(f, 0, in) : NULL; @@ -469,7 +469,7 @@ int kvlangBuiltinKvWatch(kvlangFrame_t *f) { free(key); kvlangBuiltinFreeInputs(in, n); return kvlangBuiltinSetErr( - f, "TypeError: kv.watch requires key and target"); + f, "TypeError: kvspace·watch requires key and target"); } kvlangXvalue_t v; kvlangXvalueZero(&v); diff --git a/stdlib/kv.kv b/stdlib/kv.kv index 8e0ea549..b80f2033 100644 --- a/stdlib/kv.kv +++ b/stdlib/kv.kv @@ -1,17 +1,17 @@ // 欢迎加入kvspace世界 -// lib kv —— KV 空间便利库。native rwir：kv·get/set/del/deltree/list/listlen； +// lib kvspace —— KV 空间便利库。native rwir：kvspace·get/set/del/deltree/list/listlen； // rwfunc 补充：has（存在检测）、get_or（缺省回退）、set_default（幂等写）。 // /___kv_stdlib_null___ 为内部 sentinel 路径，用户不得写入。 -lib kv { +lib kvspace { rwfunc has(path:[]char/utf32) -> (result:bool) { - v = kv·get(path) - sentinel = kv·get("/___kv_stdlib_null___") + v = kvspace·get(path) + sentinel = kvspace·get("/___kv_stdlib_null___") result = !(v == sentinel) } rwfunc get_or(path:[]char/utf32, default_val:[]char/utf32) -> (result:[]char/utf32) { - v = kv·get(path) - sentinel = kv·get("/___kv_stdlib_null___") + v = kvspace·get(path) + sentinel = kvspace·get("/___kv_stdlib_null___") if (v == sentinel) { result = default_val } else { @@ -19,10 +19,10 @@ lib kv { } } rwfunc set_default(path:[]char/utf32, val:[]char/utf32) -> () { - existing = kv·get(path) - sentinel = kv·get("/___kv_stdlib_null___") + existing = kvspace·get(path) + sentinel = kvspace·get("/___kv_stdlib_null___") if (existing == sentinel) { - kv·set(path, val) + kvspace·set(path, val) } } } diff --git a/stdlib/kvlang/kvlangbrief.kv b/stdlib/kvlang/kvlangbrief.kv index 152c88c7..a2893f39 100644 --- a/stdlib/kvlang/kvlangbrief.kv +++ b/stdlib/kvlang/kvlangbrief.kv @@ -53,7 +53,7 @@ rwfunc main() -> () { d:[]char/utf32·int64 = {} d·a = 10 d·b = 20 - kv·get(d, "a") -> x + kvspace·get(d, "a") -> x println(x) // 10 } ``` @@ -123,16 +123,16 @@ xv·bodylen(a) -> bl // 32（body 字节数） d:[]char/utf32·int64 = {} // 空 stringkeymap 必须标类型 d·a = 10 // 静态成员写 d·b = 20 -kv·get(d, "a") -> x // 读（缺失返回 None） +kvspace·get(d, "a") -> x // 读（缺失返回 None） k = "a" d·*k -> v // 动态键读 -kv·set(d, "c", 30) -> _ // 动态键写 +kvspace·set(d, "c", 30) -> _ // 动态键写 m = map() // stringkeymap m·k = 5 m2:[int64]·int64 = {} // 整型键 map（键落字符串） -kv·set(m2, 0, 7) -> _ +kvspace·set(m2, 0, 7) -> _ r = {name="kv", ver=1} // struct 字面量（异构记录；没有 object） r·name -> n @@ -161,7 +161,7 @@ break / continue return // 无返回值 ``` -map 遍历用 `while + kv·listlen + kv·listn`（for-in 对 map 不可靠）。 +map 遍历用 `while + kvspace·listlen + kvspace·listn`（for-in 对 map 不可靠）。 ## 8. 函数（lib 内定义；跨库调用走全路径） @@ -191,11 +191,11 @@ rwfunc main() -> () { ### 网络 - `http·call(method, header, url, body) -> resp`；`http·get(url)`/`post(url,body)`/`put(url,body)`/`del(url)`。 -### 自举（kvlanglayout） -- `kvlanglayout·vet(src) -> "ok"/err`：只校验，不写库。 -- `kvlanglayout·format(src) -> 规范化源码`。 -- `kvlanglayout·layout(src) -> entry`：源码 layout 入库，返回入口。 -- `kvlanglayout·dump("/lib") -> 源码`：/lib 子树导出为可运行源码。 +### 自举（kvlang·*） +- `kvlang·vet(src) -> "ok"/err`：只校验，不写库。 +- `kvlang·format(src) -> 规范化源码`。 +- `kvlang·layout(src) -> entry`：源码 layout 入库，返回入口。 +- `kvlang·dump("/lib") -> 源码`：/lib 子树导出为可运行源码。 ### 外部进程/文件系统（networld） - `networld/proc·exec(args, envs) -> code[, out, err]`：args/envs 是 `{...}` 数组字面量，args 首元素=可执行文件；out/err 是 `@[]uint8` 捕获句柄（绑定即捕获）。 @@ -210,10 +210,10 @@ println(code, out, err) networld/fs·write("/tmp/x.txt", xv·reinterpret("hi", "[]uint8")) -> n ``` -### KV 树（kv·*） -- `kv·get(path)`、`kv·set(path,val)`、`kv·del(path)`、`kv·deltree(path)`。 -- `kv·list("/dir/")`、`kv·listlen("/dir/")`、`kv·listn("/dir/",i)`（列目录 path 要带尾 `/`）。 -- `kv·abs(x)`（= `&x`，取址）、`kv·cp(src,dst)`、`kv·cpdir(src,dst)`、`kv·cplist(src,dst)`、`kv·has(path)`。 +### KV 树（kvspace·*） +- `kvspace·get(path)`、`kvspace·set(path,val)`、`kvspace·del(path)`、`kvspace·deltree(path)`。 +- `kvspace·list("/dir/")`、`kvspace·listlen("/dir/")`、`kvspace·listn("/dir/",i)`（列目录 path 要带尾 `/`）。 +- `kvlang·abs(x)`（= `&x`，取址）、`kvspace·cp(src,dst)`、`kvspace·cpdir(src,dst)`、`kvspace·cplist(src,dst)`、`kvspace·has(path)`。 ### 字符串（string·*） - `len / char / ord / cmp / find / slice / concat / formatint / formatuint / parseint / parseuint`。 diff --git "a/stdlib/kvlang/spec/01-\350\257\215\346\263\225/04-\346\240\207\350\257\206\347\254\246.kv" "b/stdlib/kvlang/spec/01-\350\257\215\346\263\225/04-\346\240\207\350\257\206\347\254\246.kv" index 44cab4f4..adf0a914 100644 --- "a/stdlib/kvlang/spec/01-\350\257\215\346\263\225/04-\346\240\207\350\257\206\347\254\246.kv" +++ "b/stdlib/kvlang/spec/01-\350\257\215\346\263\225/04-\346\240\207\350\257\206\347\254\246.kv" @@ -6,7 +6,7 @@ lib kvlang/spec/词法/标识符 { - `tutorial/01-basics/vars.kv`——标识符 `x`、`y`。 - `tutorial/01-basics/kv_tree.kv`——绝对路径 `/tmp/kvt`、子键路径 `/tmp/kvt·data`、层级路径 - `/tmp/kvt/a`，以及成员/方法 `kv·set`、`kv·get`。 + `/tmp/kvt/a`，以及成员/方法 `kvspace·set`、`kvspace·get`。 ## 标识符 diff --git "a/stdlib/kvlang/spec/01-\350\257\215\346\263\225/05-\347\273\235\345\257\271\350\267\257\345\276\204\345\255\227\351\235\242\351\207\217.kv" "b/stdlib/kvlang/spec/01-\350\257\215\346\263\225/05-\347\273\235\345\257\271\350\267\257\345\276\204\345\255\227\351\235\242\351\207\217.kv" index 0ee42823..041225c9 100644 --- "a/stdlib/kvlang/spec/01-\350\257\215\346\263\225/05-\347\273\235\345\257\271\350\267\257\345\276\204\345\255\227\351\235\242\351\207\217.kv" +++ "b/stdlib/kvlang/spec/01-\350\257\215\346\263\225/05-\347\273\235\345\257\271\350\267\257\345\276\204\345\255\227\351\235\242\351\207\217.kv" @@ -11,9 +11,9 @@ lib kvlang/spec/词法/绝对路径字面量 { - 其余非分隔符字符构成段名（同样允许非 ASCII）。 ``` -kv·set("/tmp/kvt·data", 42) -kv·get("/tmp/kvt", "data") -> x -kv·set("/tmp/kvt/a", 1) +kvspace·set("/tmp/kvt·data", 42) +kvspace·get("/tmp/kvt", "data") -> x +kvspace·set("/tmp/kvt/a", 1) ``` 路径的完整寻址语义见 [[寻址与命名]]；本节只界定其词法形态。裸 `/`（其后不接字母/数字/下划线，且非 diff --git "a/stdlib/kvlang/spec/01-\350\257\215\346\263\225/08-\350\277\220\347\256\227\347\254\246\345\237\272\347\241\200.kv" "b/stdlib/kvlang/spec/01-\350\257\215\346\263\225/08-\350\277\220\347\256\227\347\254\246\345\237\272\347\241\200.kv" index 0c8ee32d..0aef4486 100644 --- "a/stdlib/kvlang/spec/01-\350\257\215\346\263\225/08-\350\277\220\347\256\227\347\254\246\345\237\272\347\241\200.kv" +++ "b/stdlib/kvlang/spec/01-\350\257\215\346\263\225/08-\350\277\220\347\256\227\347\254\246\345\237\272\347\241\200.kv" @@ -45,7 +45,7 @@ x = 42 // 左写、右读 载算术除法语义。 一元 `+`、`-` 作前缀；`√`（U+221A，平方根）亦为一元前缀运算符。`&` 亦兼一元前缀（**绝对地址**， -`&x ≡ kv·abs(x)`）；其中缀身份（按位与）与前缀身份靠位置区分，同 C，详见 [[逻辑位运算与优先级]]。 +`&x ≡ kvlang·abs(x)`）；其中缀身份（按位与）与前缀身份靠位置区分，同 C，详见 [[逻辑位运算与优先级]]。 ## 比较运算符 diff --git "a/stdlib/kvlang/spec/01-\350\257\215\346\263\225/09-\351\200\273\350\276\221\344\275\215\350\277\220\347\256\227\344\270\216\344\274\230\345\205\210\347\272\247.kv" "b/stdlib/kvlang/spec/01-\350\257\215\346\263\225/09-\351\200\273\350\276\221\344\275\215\350\277\220\347\256\227\344\270\216\344\274\230\345\205\210\347\272\247.kv" index da37f4df..0f82c24b 100644 --- "a/stdlib/kvlang/spec/01-\350\257\215\346\263\225/09-\351\200\273\350\276\221\344\275\215\350\277\220\347\256\227\344\270\216\344\274\230\345\205\210\347\272\247.kv" +++ "b/stdlib/kvlang/spec/01-\350\257\215\346\263\225/09-\351\200\273\350\276\221\344\275\215\350\277\220\347\256\227\344\270\216\344\274\230\345\205\210\347\272\247.kv" @@ -24,7 +24,7 @@ lib kvlang/spec/词法/逻辑位运算与优先级 { ## 绝对地址运算符 `&` 一元前缀 `&loc` 求值为指向 `loc` 所在节点的**指针**（ref=1 Ptr：head 的 langtype = 目标 kindexpr、 -body = 目标绝对路径），等价 `kv·abs(loc)`——故它是**绝对地址运算符**，不是 C 式取址（kvspace 无进程私有 +body = 目标绝对路径），等价 `kvlang·abs(loc)`——故它是**绝对地址运算符**，不是 C 式取址（kvspace 无进程私有 内存地址）。操作数须为位置（location）：帧内裸名、容器/成员链（`x`、`list·1`、`base·field`）。 产物是**指针值**（不是 `char` 路径串）：可 `-> p` 存进 `*T` 变量、可 `p·field` 经指针访问成员；需要目 @@ -33,7 +33,7 @@ body = 目标绝对路径），等价 `kv·abs(loc)`——故它是**绝对地 ``` list·1 -> x -&x -> p // p = 指向 x 的 Ptr（ref=1），等价 kv·abs(x) +&x -> p // p = 指向 x 的 Ptr（ref=1），等价 kvlang·abs(x) *p -> q // 解引用：取 x 的整值 p·field -> v // 经指针访问成员（自动解引用，见 [[ptr]]） ``` diff --git "a/stdlib/kvlang/spec/02-kvspace\346\250\241\345\236\213/03-\345\257\273\345\235\200\344\270\216\345\221\275\345\220\215.kv" "b/stdlib/kvlang/spec/02-kvspace\346\250\241\345\236\213/03-\345\257\273\345\235\200\344\270\216\345\221\275\345\220\215.kv" index ffc11c65..9a02411b 100644 --- "a/stdlib/kvlang/spec/02-kvspace\346\250\241\345\236\213/03-\345\257\273\345\235\200\344\270\216\345\221\275\345\220\215.kv" +++ "b/stdlib/kvlang/spec/02-kvspace\346\250\241\345\236\213/03-\345\257\273\345\235\200\344\270\216\345\221\275\345\220\215.kv" @@ -24,7 +24,7 @@ PC 落在 kvspace、帧根落在 kvspace，故执行现场可观测、可崩溃 ## 变量名即指针 **代码中变量的名字，本身就是该变量的指针**（一条 kvspace 路径）kvspace/kvlang是路径寻址，而不是64位寻址。指令槽里存的从来不是值，而是指针文 -本；求值恒经一次指针间接。`&x`（`≡ kv·abs(x)`）是**绝对地址运算符**，产指向该节点的 Ptr（ref=1， +本；求值恒经一次指针间接。`&x`（`≡ kvlang·abs(x)`）是**绝对地址运算符**，产指向该节点的 Ptr（ref=1， body=绝对路径），**不是** C 式取址的私有内存地址（见 [[运算符基础]]）。指针有两种形态： | 形态 | 写法 | 语义 | 解析 | diff --git "a/stdlib/kvlang/spec/02-kvspace\346\250\241\345\236\213/07-\346\225\260\347\273\204\344\270\244\347\247\215\347\211\251\347\220\206\345\275\242\346\200\201.kv" "b/stdlib/kvlang/spec/02-kvspace\346\250\241\345\236\213/07-\346\225\260\347\273\204\344\270\244\347\247\215\347\211\251\347\220\206\345\275\242\346\200\201.kv" index 4298ab24..5410d421 100644 --- "a/stdlib/kvlang/spec/02-kvspace\346\250\241\345\236\213/07-\346\225\260\347\273\204\344\270\244\347\247\215\347\211\251\347\220\206\345\275\242\346\200\201.kv" +++ "b/stdlib/kvlang/spec/02-kvspace\346\250\241\345\236\213/07-\346\225\260\347\273\204\344\270\244\347\247\215\347\211\251\347\220\206\345\275\242\346\200\201.kv" @@ -29,7 +29,7 @@ stringkeymap 元素的成员名是坐标段，物理 key 形如 `m·[i]`（一 标）。 - 排序 `cmp_coord`（row-major）：坐标段恒排在非坐标段之前；两个可按整数解析的坐标段按数值升序，否则 字典序。 -- 访问：源码 `m·[i]` 对散 key 元素走 `kv·get`（member 名 `[i]`）；compact 的 `arr[i]` 走 `xv·at`。二 +- 访问：源码 `m·[i]` 对散 key 元素走 `kvspace·get`（member 名 `[i]`）；compact 的 `arr[i]` 走 `xv·at`。二 者由括号与形态区分。 ## 字面量括号即形态 diff --git "a/stdlib/kvlang/spec/02-kvspace\346\250\241\345\236\213/08-\346\214\207\344\273\244\345\270\203\345\261\200\346\240\274\345\274\217.kv" "b/stdlib/kvlang/spec/02-kvspace\346\250\241\345\236\213/08-\346\214\207\344\273\244\345\270\203\345\261\200\346\240\274\345\274\217.kv" index dba05960..c78b95d7 100644 --- "a/stdlib/kvlang/spec/02-kvspace\346\250\241\345\236\213/08-\346\214\207\344\273\244\345\270\203\345\261\200\346\240\274\345\274\217.kv" +++ "b/stdlib/kvlang/spec/02-kvspace\346\250\241\345\236\213/08-\346\214\207\344\273\244\345\270\203\345\261\200\346\240\274\345\274\217.kv" @@ -8,7 +8,7 @@ lib kvlang/spec/kvspace模型/指令布局格式 { ## 空间布局，非线性字节码 传统 VM 编译产线性字节码，调用即压返回地址后跳入口。kvlang 的 layout 不产线性序列，而是**空间布局 -**：每条指令展开为一组 `[s0,s1]` 坐标键，可逐槽 `kv·get`/`kv·list` 寻址，无需反汇编器。函数体永不被 +**：每条指令展开为一组 `[s0,s1]` 坐标键，可逐槽 `kvspace·get`/`kvspace·list` 寻址，无需反汇编器。函数体永不被 复制——调用时经 extindex 令帧根指向 `/lib` 下同一份指令树（见下 [[调用extindex]] 调用机制）。 ## 坐标键 `[s0,s1]` diff --git "a/stdlib/kvlang/spec/03-\347\261\273\345\236\213\347\263\273\347\273\237/07-\346\226\207\346\263\225\344\270\216\345\220\210\346\263\225\346\200\247.kv" "b/stdlib/kvlang/spec/03-\347\261\273\345\236\213\347\263\273\347\273\237/07-\346\226\207\346\263\225\344\270\216\345\220\210\346\263\225\346\200\247.kv" index c62792a4..dde9531c 100644 --- "a/stdlib/kvlang/spec/03-\347\261\273\345\236\213\347\263\273\347\273\237/07-\346\226\207\346\263\225\344\270\216\345\220\210\346\263\225\346\200\247.kv" +++ "b/stdlib/kvlang/spec/03-\347\261\273\345\236\213\347\263\273\347\273\237/07-\346\226\207\346\263\225\344\270\216\345\220\210\346\263\225\346\200\247.kv" @@ -41,7 +41,7 @@ lib kvlang/spec/类型系统/文法与合法性 { |------------|---------|----------------------| | `int64` | `b·200` | `b·[200]`（裸标量禁包成 1 元元组） | | `[float64,float64]` | `a·[342.124,23.2345]` | 塌缩为 `[2]float64` 后再改键 | -| `[]char/utf8` | `m·a` / `kv·set(m,"a",v)` | 加维度或改编码 | +| `[]char/utf8` | `m·a` / `kvspace·set(m,"a",v)` | 加维度或改编码 | 即 `a:[float64,float64]·int32={}` 的真实存储/访问路径必须是 `a·[342.124,23.2345]`； `b:int64·int64={}` 必须是 `b·200`（**不是** `b·[200]`）。裸标量键与 1 元元组键 `[int64]`（访问键 diff --git "a/stdlib/kvlang/spec/03-\347\261\273\345\236\213\347\263\273\347\273\237/11-stringkeymap\345\275\242\346\200\201.kv" "b/stdlib/kvlang/spec/03-\347\261\273\345\236\213\347\263\273\347\273\237/11-stringkeymap\345\275\242\346\200\201.kv" index 5d702b21..23ad4486 100644 --- "a/stdlib/kvlang/spec/03-\347\261\273\345\236\213\347\263\273\347\273\237/11-stringkeymap\345\275\242\346\200\201.kv" +++ "b/stdlib/kvlang/spec/03-\347\261\273\345\236\213\347\263\273\347\273\237/11-stringkeymap\345\275\242\346\200\201.kv" @@ -15,7 +15,7 @@ names:[int64]·[]char/utf32 = {"apple", "banana", "cherry"} // 变长字符串 容器字面量的写目标**必须带 map langtype**（见 [[map容器]]）——容器值的 langtype 就是它，缺标注 layout 报错；`{}` 尤其无法推断（空字面量不含任何成员）。 -散 key 元素以坐标段 `base·[i]` 访问（经 `kv·get`），或以 `for-in` / `kv·listlen` / `kv·listn` 遍历。 +散 key 元素以坐标段 `base·[i]` 访问（经 `kvspace·get`），或以 `for-in` / `kvspace·listlen` / `kvspace·listn` 遍历。 坐标段支持多值键（含小数）：`geo·[39.9,116.4] = "Beijing"`，物理以字符串格式落 key（见 `tutorial/04-ndarray/geo_coord.kv`）。 diff --git "a/stdlib/kvlang/spec/03-\347\261\273\345\236\213\347\263\273\347\273\237/12-\347\250\240\345\257\206vs\347\250\200\347\226\217.kv" "b/stdlib/kvlang/spec/03-\347\261\273\345\236\213\347\263\273\347\273\237/12-\347\250\240\345\257\206vs\347\250\200\347\226\217.kv" index 64a0a217..15a44c0d 100644 --- "a/stdlib/kvlang/spec/03-\347\261\273\345\236\213\347\263\273\347\273\237/12-\347\250\240\345\257\206vs\347\250\200\347\226\217.kv" +++ "b/stdlib/kvlang/spec/03-\347\261\273\345\236\213\347\263\273\347\273\237/12-\347\250\240\345\257\206vs\347\250\200\347\226\217.kv" @@ -9,8 +9,8 @@ lib kvlang/spec/类型系统/稠密vs稀疏 { | langtype | `[1024,1024]int32` | 坐标元组键 map，如 `[int32,int32]·int32` | | storetype | ARRAYND | index | | 落库 | 全量 1024×1024 元素连续打包进**单个** XValue 的 body（恒 1024×1024×4 = 4 MiB，未写元素亦占位） | 每个写过的坐标落一个独立子 key `base·[i,j]`；**未 set 的坐标子 key 根本不存在**，不占空间 | -| 缺失元素 | 无「缺失」——全部就位（默认 0） | 读未写坐标返回 None（`kv·get` 缺失语义） | -| 随机访问 | `a[i,j]` 按 row-major O(1) 偏移 | `base·[i,j]` / `kv·get` 按 key 查找 | +| 缺失元素 | 无「缺失」——全部就位（默认 0） | 读未写坐标返回 None（`kvspace·get` 缺失语义） | +| 随机访问 | `a[i,j]` 按 row-major O(1) 偏移 | `base·[i,j]` / `kvspace·get` 按 key 查找 | | 适用 | 稠密张量、绝大多数元素有值、需连续内存与 O(1) 下标 | 稀疏矩阵、坐标空间极大而实际有值项稀少 | ```kv diff --git "a/stdlib/kvlang/spec/03-\347\261\273\345\236\213\347\263\273\347\273\237/14-map\345\256\271\345\231\250.kv" "b/stdlib/kvlang/spec/03-\347\261\273\345\236\213\347\263\273\347\273\237/14-map\345\256\271\345\231\250.kv" index e40004ae..8fe81f0d 100644 --- "a/stdlib/kvlang/spec/03-\347\261\273\345\236\213\347\263\273\347\273\237/14-map\345\256\271\345\231\250.kv" +++ "b/stdlib/kvlang/spec/03-\347\261\273\345\236\213\347\263\273\347\273\237/14-map\345\256\271\345\231\250.kv" @@ -34,7 +34,7 @@ key 格式化成什么字面量文本」： |-----------------|---------------------------|-----| | 裸标量（`bool` + 十个定宽数字种类） | 该标量的字面量文本 | `b·200` | | 标量元组 `[scalar,…]` | `[v0,v1,…]`（逗号分隔、无空格） | `a·[3.252,235124.23]` | -| `[]char/<编码>` | 字符串本身（裸名） | `m·a` / `kv·set(m,"a",v)` | +| `[]char/<编码>` | 字符串本身（裸名） | `m·a` / `kvspace·set(m,"a",v)` | **不得**用数组形状 `[N]T` / `[d0,d1]T` 作键：形状描述「一段连续打包进 body 的等宽元素」，属 **value 的 langtype**；key 无 body、纯路径文本，形状对它没有意义。故 `b:[2]int32·[]char/utf8 = {}` 报错，而表达同 @@ -48,8 +48,8 @@ langtype**；key 无 body、纯路径文本，形状对它没有意义。故 `b: ```kv m:[]char/utf8·int64 = {} // 字符串键 map；空字面量须带类型标注 m·a = 10 // 命名成员写 -kv·set(m, "b", 20) // 动态键写 -kv·get(m, "a") -> x // 动态键读；缺失返回 None +kvspace·set(m, "b", 20) // 动态键写 +kvspace·get(m, "a") -> x // 动态键读；缺失返回 None b:int64·int64 = {} // 裸标量键 map b·200 = 7 // 访问键就是 200，禁止写成 b·[200] diff --git "a/stdlib/kvlang/spec/03-\347\261\273\345\236\213\347\263\273\347\273\237/15-\346\210\220\345\221\230\350\256\277\351\227\256.kv" "b/stdlib/kvlang/spec/03-\347\261\273\345\236\213\347\263\273\347\273\237/15-\346\210\220\345\221\230\350\256\277\351\227\256.kv" index cd944b4a..69276855 100644 --- "a/stdlib/kvlang/spec/03-\347\261\273\345\236\213\347\263\273\347\273\237/15-\346\210\220\345\221\230\350\256\277\351\227\256.kv" +++ "b/stdlib/kvlang/spec/03-\347\261\273\345\236\213\347\263\273\347\273\237/15-\346\210\220\345\221\230\350\256\277\351\227\256.kv" @@ -8,7 +8,7 @@ lib kvlang/spec/类型系统/成员访问 { | `base·200` | 裸标量 memitemkey：访问键即标量字面量本身（禁 `base·[200]`） | | `base·[342.124,23.2345]` | 标量元组 memitemkey：访问键即元组字面量本身 | | `base·*k` | 动态键：`*` 令 runtime-c 解引用/求值 `k`，其值作 memitemkey | -| `kv·get(base, k)` / `kv·set(base, k, v)` | 动态键读/写 | +| `kvspace·get(base, k)` / `kvspace·set(base, k, v)` | 动态键读/写 | **指针作 key 必须 `*` 开头**：当作为 memitemkey 的操作数是指针（ref=1 Ptr）时，**必须**写 `base·*k`， 由 runtime-c 沿 Ptr 解引用取被指向值作键；省略 `*` 非法（不自动解引用）。这是**显式** deref、非自动改 @@ -19,7 +19,7 @@ lib kvlang/spec/类型系统/成员访问 { [[文法与合法性]] 的逐字铁律）。裸标量键 `base·200` 与 1 元元组键 `base·[200]` 是**不同** formatter， 不得互转。 -容器成员一律走 `·`（或 `kv·get`/`kv·set`）作**索引**，**不得**用 `[]` 索引运算符；`[]` 只索引 compact +容器成员一律走 `·`（或 `kvspace·get`/`kvspace·set`）作**索引**，**不得**用 `[]` 索引运算符；`[]` 只索引 compact 数组（见 [[数组形态]]）。注意：元组键 `base·[…]` 里的 `[…]` 是 **memitemkey 值字面量**、不是索引运算 符——它整体是 `·` 右侧的那一个键。 diff --git "a/stdlib/kvlang/spec/03-\347\261\273\345\236\213\347\263\273\347\273\237/16-ptr.kv" "b/stdlib/kvlang/spec/03-\347\261\273\345\236\213\347\263\273\347\273\237/16-ptr.kv" index 0e9a8ab1..3e9601ae 100644 --- "a/stdlib/kvlang/spec/03-\347\261\273\345\236\213\347\263\273\347\273\237/16-ptr.kv" +++ "b/stdlib/kvlang/spec/03-\347\261\273\345\236\213\347\263\273\347\273\237/16-ptr.kv" @@ -13,7 +13,7 @@ lib kvlang/spec/类型系统/ptr { | 形态 | 语义 | |------|------| -| `&x` | **绝对地址** → ref=1 Ptr（`≡ kv·abs(x)`，body = 目标绝对路径） | +| `&x` | **绝对地址** → ref=1 Ptr（`≡ kvlang·abs(x)`，body = 目标绝对路径） | | `p`（`*T` 变量读值） | 得地址值本身（不穿透） | | `*p` | 解引用 → 读 body 目标地址的值 | | `None` | **空指针**（唯一的空指针字面量；即键不存在=无值） | @@ -41,8 +41,8 @@ p·val -> v // 成员访问经指针自动解引用：读 /n1·val if (p != None) { … } // 空指针判定 ``` -`&` 对**裸名** `&x` 产帧槽的绝对地址（`≡ kv·abs(x)`）、对**成员链** `&t·2` 产成员路径的绝对地址（`≡ -kv·abs(t, "2")`），均产 ref=1 Ptr、body 为目标 key 路径。 +`&` 对**裸名** `&x` 产帧槽的绝对地址（`≡ kvlang·abs(x)`）、对**成员链** `&t·2` 产成员路径的绝对地址（`≡ +kvlang·abs(t, "2")`），均产 ref=1 Ptr、body 为目标 key 路径。 成员访问 `p·field` 经指针**自动解引用**（对齐 Go/Rust 的 `p.field`）；需要「指针指向的整值」（如指针 指向标量）时用显式 `*p`。二者不冲突：`*p` 取整值、`p·field` 取成员。 diff --git "a/stdlib/kvlang/spec/03-\347\261\273\345\236\213\347\263\273\347\273\237/26-\345\255\227\347\254\246\344\270\262\347\274\226\347\240\201.kv" "b/stdlib/kvlang/spec/03-\347\261\273\345\236\213\347\263\273\347\273\237/26-\345\255\227\347\254\246\344\270\262\347\274\226\347\240\201.kv" index 565fe5dd..6c90aa8c 100644 --- "a/stdlib/kvlang/spec/03-\347\261\273\345\236\213\347\263\273\347\273\237/26-\345\255\227\347\254\246\344\270\262\347\274\226\347\240\201.kv" +++ "b/stdlib/kvlang/spec/03-\347\261\273\345\236\213\347\263\273\347\273\237/26-\345\255\227\347\254\246\344\270\262\347\274\226\347\240\201.kv" @@ -21,7 +21,7 @@ utf32 是码点序列（4B×N），**定宽、可索引**，供用户 kv 代码 ``` // 存储读出的串默认 utf8；要逐码点处理，先显式转 utf32 -kv·get(d, "name") -> s8 // s8: []char/utf8 +kvspace·get(d, "name") -> s8 // s8: []char/utf8 char/utf32(s8) -> s32 // s32: []char/utf32，定宽可索引 s32[0] -> c // O(1) 码点取 ``` diff --git "a/stdlib/kvlang/spec/04-layout\350\257\255\344\271\211/03-\345\207\275\346\225\260.kv" "b/stdlib/kvlang/spec/04-layout\350\257\255\344\271\211/03-\345\207\275\346\225\260.kv" index b8dc9e12..b1778b4c 100644 --- "a/stdlib/kvlang/spec/04-layout\350\257\255\344\271\211/03-\345\207\275\346\225\260.kv" +++ "b/stdlib/kvlang/spec/04-layout\350\257\255\344\271\211/03-\345\207\275\346\225\260.kv" @@ -86,7 +86,7 @@ runtime 被拒，故累加器写法前须保证目标已有值（如 `0 -> acc` **永久规定**：参数定义键 `.[op,param]` 中 `param<0` 是**只读参数**（读参）、`param>0` 是**要写的参** （写参，见 [[storetype_def族与签名行]]）。函数体内读参的裸名**一律**不得作写槽（含 `for … in` 的迭代 -变量、成员/下标写、`kv·set(base, …)` 的 base），layout 报错拒绝装载： +变量、成员/下标写、`kvspace·set(base, …)` 的 base），layout 报错拒绝装载： ``` error: func f: read param "A" cannot be used as write slot (read params are read-only) @@ -96,7 +96,7 @@ error: func f: read param "A" cannot be used as write slot (read params are read 都只读——写值读参就是写一个只读的帧槽，写地址读参还会破坏数据流方向。要改值就先拷到新局部变量 （`x -> local`，此后写 `local`）；要就地改调用方对象就把该参数放到写参侧（`-> (p:*/lib/Point)`）。 -**只读覆盖到子成员，且别名不洗白**：`p·field = v`、`p[k] = v`、`kv·set(p, k, v)` 同样命中该检查——经 +**只读覆盖到子成员，且别名不洗白**：`p·field = v`、`p[k] = v`、`kvspace·set(p, k, v)` 同样命中该检查——经 desugar 后 base 就是读参裸名；对地址读参，只读性还沿别名传播：`q = p` / `p -> q` 使 `q` 指到**同一个对 象**，此后 `q·field = v` 写的仍是 `p` 的对象，layout 一并拒绝（否则一句话就能绕开本规则）： @@ -125,7 +125,7 @@ rwfunc inc(x:int64) -> (r:int64) { x -> local local = local + 1 local -> r } ``` （`q·next -> q` 这类**重绑别名本身**的写槽是裸名、不碰调用方对象，不受影响。）判定规则（实现）：写槽 -含 `/`、`[`、`·` 者视为路径/下标/成员写，不计入本检查；但 `kv·set(base, …)` 的 base 命中读参裸名同样 +含 `/`、`[`、`·` 者视为路径/下标/成员写，不计入本检查；但 `kvspace·set(base, …)` 的 base 命中读参裸名同样 拒绝（成员目录被改写）。 ## 参数同名规则 diff --git "a/stdlib/kvlang/spec/04-layout\350\257\255\344\271\211/06-\346\216\247\345\210\266\346\265\201\350\204\261\347\263\226.kv" "b/stdlib/kvlang/spec/04-layout\350\257\255\344\271\211/06-\346\216\247\345\210\266\346\265\201\350\204\261\347\263\226.kv" index 2250bfd4..a62bea8c 100644 --- "a/stdlib/kvlang/spec/04-layout\350\257\255\344\271\211/06-\346\216\247\345\210\266\346\265\201\350\204\261\347\263\226.kv" +++ "b/stdlib/kvlang/spec/04-layout\350\257\255\344\271\211/06-\346\216\247\345\210\266\346\265\201\350\204\261\347\263\226.kv" @@ -7,7 +7,7 @@ lib kvlang/spec/layout语义/控制流脱糖 { `for (x in iter)` 由 lower 脱糖为索引循环：初始化临时索引与长度槽，条件块自增并比较，体首取元素绑定 迭代变量： -- 容器源（struct / stringkeymap）——长度用 `kv·listlen`，取元素用 `kv·listn` + `kv·get`。 +- 容器源（struct / stringkeymap）——长度用 `kvspace·listlen`，取元素用 `kvspace·listn` + `kvspace·get`。 - compact 数组源——长度用 `ndarray·numel`，取元素用 `xv·at`。 迭代源为裸标识符时原地遍历；为表达式（如数组字面量）时先物化到临时槽。迭代变量 `x` 是被写槽——`x` 命 diff --git "a/stdlib/kvlang/spec/04-layout\350\257\255\344\271\211/07-layout\346\265\201\346\260\264\347\272\277.kv" "b/stdlib/kvlang/spec/04-layout\350\257\255\344\271\211/07-layout\346\265\201\346\260\264\347\272\277.kv" index 025e1250..fe4250d5 100644 --- "a/stdlib/kvlang/spec/04-layout\350\257\255\344\271\211/07-layout\346\265\201\346\260\264\347\272\277.kv" +++ "b/stdlib/kvlang/spec/04-layout\350\257\255\344\271\211/07-layout\346\265\201\346\260\264\347\272\277.kv" @@ -20,7 +20,7 @@ kvspace 的 `/lib/` 子树，供 runtime 解释执行。layout 是 **o0 编译 关键性质： - **PC 是 KV 路径字符串**，不是整数偏移。 -- **指令存储在 KV 树**中，经 `kv·get` 逐槽读取；无字节码数组。 +- **指令存储在 KV 树**中，经 `kvspace·get` 逐槽读取；无字节码数组。 - 换行是语句分隔符（`Newline` token），`{ }` 负责块结构；块结构由消费 `LBrace`/`RBrace` 追踪。 - 诊断**不首错即止**：解析器累积全部诊断，最后统一判定（见 [[诊断]]）。 diff --git "a/stdlib/kvlang/spec/05-runtime\350\257\255\344\271\211/03-\346\210\220\345\221\230\350\256\277\351\227\256.kv" "b/stdlib/kvlang/spec/05-runtime\350\257\255\344\271\211/03-\346\210\220\345\221\230\350\256\277\351\227\256.kv" index ad93fed7..e45624db 100644 --- "a/stdlib/kvlang/spec/05-runtime\350\257\255\344\271\211/03-\346\210\220\345\221\230\350\256\277\351\227\256.kv" +++ "b/stdlib/kvlang/spec/05-runtime\350\257\255\344\271\211/03-\346\210\220\345\221\230\350\256\277\351\227\256.kv" @@ -15,7 +15,7 @@ kvlang 用两个符号访问复合数据，语义严格分离，runtime **不得 | `a[i]` | **数组下标** | compact 数组的元素访问，`i` 为整数 | | `base·name` | **容器成员 / 限定名** | `·`（U+00B7，中点）是成员访问符 | -容器成员一律走 `·`（或 `kv·get`/`kv·set`）；`[]` 只索引 compact 数组。 +容器成员一律走 `·`（或 `kvspace·get`/`kvspace·set`）；`[]` 只索引 compact 数组。 ## 容器 = 值 + memindex @@ -25,7 +25,7 @@ kvlang 用两个符号访问复合数据，语义严格分离，runtime **不得 是成员集合的唯一权威，遍历成员**必须**据此枚举，**不得**假设成员键连续或有序之外的布局。 - **写成员**：`rec·name = 值` 的写槽是完整成员键 `rec·name`，`=` 为值拷贝。 -- **读成员**：`rec·name -> v` 直接取 key `rec·name`；缺失成员的动态读（`kv·get`）返回 `None`。 +- **读成员**：`rec·name -> v` 直接取 key `rec·name`；缺失成员的动态读（`kvspace·get`）返回 `None`。 ## `·` 的解引用：按指针优先，按名回退 @@ -42,7 +42,7 @@ kvlang 用两个符号访问复合数据，语义严格分离，runtime **不得 ## 动态成员名 `·*`：解引用操作数取 memitemkey `base·*k` 用 `k` 的**值**作为成员键：`·*` 令 runtime-c **解引用/求值**操作数 `k`，以其值定位 -`base·`（等价显式形式 `kv·get(base, k)` / `kv·set(base, k, v)`）。裸 `base·k`（无 `*`）用字面 +`base·`（等价显式形式 `kvspace·get(base, k)` / `kvspace·set(base, k, v)`）。裸 `base·k`（无 `*`）用字面 名 `k`；`base·*k` 才取 `k` 的值。 **指针作 memitemkey 必须 `*` 开头**：当作为 key 的操作数是**指针**（ref=1 Ptr）时，**必须**写 @@ -75,9 +75,9 @@ ref=2（@ext）表示真实值在扩展世界，head 的 langtype 仍为目标 数组有两种存储形态：**compact**（`[...]` 字面量，元素连续打包进单个 XValue，head kind = 元素类型）与 **stringkeymap**（`{...}` 字面量，散 key，每元素落 `base·[i]` 坐标段独立子 key）。下标 `a[i]` / `xv·at` / -`xv·set` 用于 **compact** 形态；stringkeymap 形态用 `for-in` / `kv·get` 遍历访问。 +`xv·set` 用于 **compact** 形态；stringkeymap 形态用 `for-in` / `kvspace·get` 遍历访问。 -- **下标读**：`a[i] -> e`（layout 脱糖为 `xv·at`/`kv·get`），按 `kvlangXvalueElemSize(kind)` 定的元 +- **下标读**：`a[i] -> e`（layout 脱糖为 `xv·at`/`kvspace·get`），按 `kvlangXvalueElemSize(kind)` 定的元 素字节宽零拷贝定位第 `i` 个元素。 - **下标写**：`a[i] = v` / `v -> a[i]`（两种书写等价，脱糖为 `xv·set`，见 [[指令架构]]），就地改第 `i` 个元素；索引个数须等于维数，越界报 IndexError。 diff --git "a/stdlib/kvlang/spec/05-runtime\350\257\255\344\271\211/05-runtimec\345\206\205\345\273\272.kv" "b/stdlib/kvlang/spec/05-runtime\350\257\255\344\271\211/05-runtimec\345\206\205\345\273\272.kv" index d687fce6..4176aee5 100644 --- "a/stdlib/kvlang/spec/05-runtime\350\257\255\344\271\211/05-runtimec\345\206\205\345\273\272.kv" +++ "b/stdlib/kvlang/spec/05-runtime\350\257\255\344\271\211/05-runtimec\345\206\205\345\273\272.kv" @@ -51,8 +51,9 @@ runtime-c 的 myrwircaps**（见 [[runtime开发规范]]）——核心能就地 - `time/duration·`：`nanos`、`millis`、`seconds`、`minutes`、`hours`、`as_nanos`、`as_millis`、 `as_seconds`、`as_minutes`、`as_hours`、`add`、`sub`、`before`、`after`。 - `random·`：`uint64`、`int63`、`intn`。 -- `kv·`：`get`、`set`、`del`、`deltree`、`cp`、`cpdir`、`cplist`、`list`、`listlen`、`listn`、 - `mkindex`、`extindex`、`rmindexext`、`watch`、`abs`。 +- `kvspace·`：`get`、`set`、`del`、`deltree`、`cp`、`cpdir`、`cplist`、`list`、`listlen`、`listn`、 + `mkindex`、`extindex`、`rmindexext`、`watch`。 +- `kvlang·`：`abs`（取址；`&x ≡ kvlang·abs(x)`）。 - `vthread·`：`create`、`run`、`call`、`sleep`、`setstatus`（语义见 [[执行模型]] §七）。 锚例：`tutorial/13-stdlib/`（`kv`、`string`、`xv`、`math`、`time`、`duration` 六族）、 diff --git "a/stdlib/kvlang/spec/05-runtime\350\257\255\344\271\211/06-runtime\345\274\200\345\217\221\350\247\204\350\214\203.kv" "b/stdlib/kvlang/spec/05-runtime\350\257\255\344\271\211/06-runtime\345\274\200\345\217\221\350\247\204\350\214\203.kv" index 75d522de..286f94de 100644 --- "a/stdlib/kvlang/spec/05-runtime\350\257\255\344\271\211/06-runtime\345\274\200\345\217\221\350\247\204\350\214\203.kv" +++ "b/stdlib/kvlang/spec/05-runtime\350\257\255\344\271\211/06-runtime\345\274\200\345\217\221\350\247\204\350\214\203.kv" @@ -22,7 +22,7 @@ opcode**，映射 `opcode → 就地处理器`。它是 kvlang runtime 分层与 表**（数组 + 线性查找，见 [[cruntime与后端abi]]），登记 native builtin（+ 控制流 `call`/`return`/ `br`/`goto` + `=` 拷贝，见 [[runtimec内建]]）。 - **每个扩展运行时各自定义一张 myrwircaps**，登记其自带的 rwir opcode。例：runtime-rs 为 `term`/ - `json`/`http`/`kvlanglayout`/`networld` 等（见 [[notinmyrwircaps]] 就地集合）；未来 + `json`/`http`/`kvlang`/`networld` 等（见 [[notinmyrwircaps]] 就地集合）；未来 deepx-gpu-compute 为 tensor 融合算子。 - **派发判据**：`opcode ∈ 本 runtime.myrwircaps` → 查表取处理器**就地执行**；否则该 rwir 须经 def rwir 路由，**移交**给以它为 myrwircaps 的另一扩展（跨进程 handoff/watch，或嵌入式交回宿主，见 diff --git "a/stdlib/kvlang/spec/05-runtime\350\257\255\344\271\211/07-notinmyrwircaps.kv" "b/stdlib/kvlang/spec/05-runtime\350\257\255\344\271\211/07-notinmyrwircaps.kv" index d8cfe40c..1a1c9354 100644 --- "a/stdlib/kvlang/spec/05-runtime\350\257\255\344\271\211/07-notinmyrwircaps.kv" +++ "b/stdlib/kvlang/spec/05-runtime\350\257\255\344\271\211/07-notinmyrwircaps.kv" @@ -29,7 +29,7 @@ lib kvlang/spec/runtime语义/notinmyrwircaps { term print / println / cerr / input json json·to / json·from http http·call -layout kvlanglayout·vet / ·format / ·layout / ·dump +kvlang kvlang·vet / ·format / ·layout / ·dump networld networld/proc·exec networld/fs·size / ·read / ·write / ·append / ·list / ·del / ·mkdir / ·exists ``` diff --git "a/stdlib/kvlang/spec/\350\256\276\350\256\241\347\220\206\347\224\261/02-\344\270\200\345\210\207\347\232\206\346\230\216\346\226\207.kv" "b/stdlib/kvlang/spec/\350\256\276\350\256\241\347\220\206\347\224\261/02-\344\270\200\345\210\207\347\232\206\346\230\216\346\226\207.kv" index f05f1cd9..68497669 100644 --- "a/stdlib/kvlang/spec/\350\256\276\350\256\241\347\220\206\347\224\261/02-\344\270\200\345\210\207\347\232\206\346\230\216\346\226\207.kv" +++ "b/stdlib/kvlang/spec/\350\256\276\350\256\241\347\220\206\347\224\261/02-\344\270\200\345\210\207\347\232\206\346\230\216\346\226\207.kv" @@ -38,7 +38,7 @@ def rwir 路由）、读写哪个 slot。调度层的绝对耗时在 tensor 计 传统语言的 `&` 取址产生的是私有内存地址，只在当前进程内有意义，且与内存布局深度绑定。kvlang 的"变量 名"本身就是该变量的 kvspace 路径——路径在任何连接到同一 kvspace 的节点上都有意义。故 kvlang 保留 `&x` -（`≡ kv·abs(x)`），但它的产物是**指向该节点的 Ptr**（ref=1，body=绝对路径）、不是私有地址：没有进程私 +（`≡ kvlang·abs(x)`），但它的产物是**指向该节点的 Ptr**（ref=1，body=绝对路径）、不是私有地址：没有进程私 有地址空间，也没有 C 式取址的内存布局含义，故规范称它为**绝对地址运算符**（见 [[寻址与命名]]、 [[运算符基础]]）。 "#### -> /lib/kvlang/spec/设计理由/一切皆明文 diff --git "a/stdlib/kvlang/spec/\351\231\204\345\275\225/05-\350\241\250\350\276\276\345\274\217.kv" "b/stdlib/kvlang/spec/\351\231\204\345\275\225/05-\350\241\250\350\276\276\345\274\217.kv" index 348115e3..098fa884 100644 --- "a/stdlib/kvlang/spec/\351\231\204\345\275\225/05-\350\241\250\350\276\276\345\274\217.kv" +++ "b/stdlib/kvlang/spec/\351\231\204\345\275\225/05-\350\241\250\350\276\276\345\274\217.kv" @@ -18,7 +18,7 @@ primary = literal | ident | path | struct_literal | map_literal -prefix_unary = "-" | "!" | "√" | "&" | "*" (* √ = sqrt（U+221A）；&x ≡ kv·abs(x) 绝对地址（产 ref=1 Ptr）；*p 解引用 *) +prefix_unary = "-" | "!" | "√" | "&" | "*" (* √ = sqrt（U+221A）；&x ≡ kvlang·abs(x) 绝对地址（产 ref=1 Ptr）；*p 解引用 *) infix_primary = binary_op expr diff --git "a/stdlib/kvlang/spec/\351\231\204\345\275\225/07-\345\206\205\345\273\272\345\207\275\346\225\260.kv" "b/stdlib/kvlang/spec/\351\231\204\345\275\225/07-\345\206\205\345\273\272\345\207\275\346\225\260.kv" index 11ae4db7..0bdc29a7 100644 --- "a/stdlib/kvlang/spec/\351\231\204\345\275\225/07-\345\206\205\345\273\272\345\207\275\346\225\260.kv" +++ "b/stdlib/kvlang/spec/\351\231\204\345\275\225/07-\345\206\205\345\273\272\345\207\275\346\225\260.kv" @@ -19,7 +19,8 @@ builtin_call = ( "abs" | "neg" | "sign" | "pow" | "sqrt" | "exp" | "log" 集）兑现（见 runtime 语义卷）。 `·` 限定内建族（`base·method(...)`，非裸名终结符）： -`string·*`、`xv·*`（at/set/reshape/reinterpret/langtype/bodylen…）、`kv·*`（get/set/del…）、 +`string·*`、`xv·*`（at/set/reshape/reinterpret/langtype/bodylen…）、`kvspace·*`（get/set/del…）、 +`kvlang·*`（abs 取址）、 `ndarray·*`（numel/dim/shape）、`array·*`（append/slice/scatter/compact）、`struct·new`、`vthread·*` （create/run/call/sleep/setstatus）、`time·*`、`time/duration·*`（包分隔用 `/` 分段、`·` 接方法）、 `random·*`（uint64/int63/intn）。 @@ -32,7 +33,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 的 Ptr（ref=1，body=绝对路径）；与中缀按位与 a & b 靠位置区分 *) +(* &x ≡ kvlang·abs(x)：一元前缀**绝对地址**运算符，产指向 x 的 Ptr（ref=1，body=绝对路径）；与中缀按位与 a & b 靠位置区分 *) ``` "## -> /lib/kvlang/spec/附录/内建函数 } diff --git a/stdlib/math.kv b/stdlib/math.kv index 766db90c..66eba1e1 100644 --- a/stdlib/math.kv +++ b/stdlib/math.kv @@ -1,6 +1,6 @@ // 欢迎加入kvspace世界 // lib math —— 数学常量（常量成员式）。绝对路径赋值，math·init 落值；读侧同样用绝对路径： -// /lib/math·Pi -> p 或 kv·get("/lib/math·Pi") -> p +// /lib/math·Pi -> p 或 kvspace·get("/lib/math·Pi") -> p lib math { /lib/math·Pi = 3.141592653589793 diff --git a/tutorial/01-basics/kv_mkindex_cap.kv b/tutorial/01-basics/kv_mkindex_cap.kv index 8cefad9c..d286d681 100644 --- a/tutorial/01-basics/kv_mkindex_cap.kv +++ b/tutorial/01-basics/kv_mkindex_cap.kv @@ -3,15 +3,15 @@ // 列出 prefix 下的子键并计数 rwfunc count_children(prefix:[]char/utf32) -> (n:int64) { - kv·list(prefix) -> names - kv·listlen(names) -> n + kvspace·list(prefix) -> names + kvspace·listlen(names) -> n } rwfunc test() -> () { - kv·mkindex("/tmp/kvtc/", 8) - kv·set("/tmp/kvtc/a", 1) - kv·set("/tmp/kvtc/bb", 2) - kv·set("/tmp/kvtc/ccc", 3) + kvspace·mkindex("/tmp/kvtc/", 8) + kvspace·set("/tmp/kvtc/a", 1) + kvspace·set("/tmp/kvtc/bb", 2) + kvspace·set("/tmp/kvtc/ccc", 3) count_children("/tmp/kvtc/") -> n println("n=", n) } diff --git a/tutorial/01-basics/kv_tree.kv b/tutorial/01-basics/kv_tree.kv index ef29b99d..090c61cd 100644 --- a/tutorial/01-basics/kv_tree.kv +++ b/tutorial/01-basics/kv_tree.kv @@ -8,27 +8,27 @@ // path 下是否存在字段 key rwfunc has_field(path:[]char/utf32, key:[]char/utf32) -> (ok:bool) { - kv·get(path, key) != None -> ok + kvspace·get(path, key) != None -> ok } // 列出 prefix 下的子键并计数（成员数查 memindex，非 ndarray 形状） rwfunc count_children(prefix:[]char/utf32) -> (n:int64) { - kv·list(prefix) -> names - kv·listlen(names) -> n + kvspace·list(prefix) -> names + kvspace·listlen(names) -> n } rwfunc test() -> () { /tmp/kvt:int64·int64 = {} - kv·set("/tmp/kvt·data", 42) - kv·get("/tmp/kvt·data") -> v + kvspace·set("/tmp/kvt·data", 42) + kvspace·get("/tmp/kvt·data") -> v println("v=", v) has_field("/tmp/kvt", "data") -> h println("has_data=", h) - kv·get("/tmp/kvt", "data") -> x + kvspace·get("/tmp/kvt", "data") -> x println("x=", x) - kv·mkindex("/tmp/kvt/") - kv·set("/tmp/kvt/a", 1) - kv·set("/tmp/kvt/b", 2) + kvspace·mkindex("/tmp/kvt/") + kvspace·set("/tmp/kvt/a", 1) + kvspace·set("/tmp/kvt/b", 2) count_children("/tmp/kvt/") -> n println("n=", n) ndarray·numel([10,20,30]) -> m diff --git a/tutorial/04-ndarray/map_coord.kv b/tutorial/04-ndarray/map_coord.kv index 246b871b..01454329 100644 --- a/tutorial/04-ndarray/map_coord.kv +++ b/tutorial/04-ndarray/map_coord.kv @@ -1,5 +1,5 @@ // strkeymap_coord: stringkeymap 坐标段访问 a·[i] -// 语义: {..} 创建 1 维散 key map，成员名是坐标段 "[i]"，a·[i] 走 kv·get +// 语义: {..} 创建 1 维散 key map，成员名是坐标段 "[i]"，a·[i] 走 kvspace·get // 期望输出: // a[0] = 10 // a[2] = 30 diff --git a/tutorial/04-ndarray/separated.kv b/tutorial/04-ndarray/separated.kv index 103682f4..515a3417 100644 --- a/tutorial/04-ndarray/separated.kv +++ b/tutorial/04-ndarray/separated.kv @@ -1,8 +1,8 @@ // separated: 散 key 数组（元素分散在 b·[0]..b·[N-1] 各自 key，按坐标段寻址） // 语义: 字面量初始化默认 compact；array·scatter 把 compact 转散 key，array·compact 反向 -// 散 key 元素访问用 b·[i]（走 kv·get），compact 用 b[i]（走 xv·at） +// 散 key 元素访问用 b·[i]（走 kvspace·get），compact 用 b[i]（走 xv·at） // 期望输出: -// kv·listlen(b) = 3 +// kvspace·listlen(b) = 3 // b[0] = 10 // b[2] = 30 // ndarray·numel(c) = 3 @@ -10,8 +10,8 @@ rwfunc test() -> () { a:[]int64 = [10, 20, 30] // 字面量初始化 → compact b = array·scatter(a) // 显式 scatter：compact a → 散 key b（b·[0]..b·[2]） - kv·listlen(b) -> n1 - println("kv·listlen(b) =", n1) + kvspace·listlen(b) -> n1 + println("kvspace·listlen(b) =", n1) println("b[0] =", b·[0]) // 散 key 元素访问 ·[i] println("b[2] =", b·[2]) c = array·compact(b) // 显式 compact：散 key b → compact c diff --git a/tutorial/04-ndarray/sparse_literal.kv b/tutorial/04-ndarray/sparse_literal.kv index fbe183d1..7b1ca1ad 100644 --- a/tutorial/04-ndarray/sparse_literal.kv +++ b/tutorial/04-ndarray/sparse_literal.kv @@ -8,14 +8,14 @@ // 40 // sum = 100 // 散 key 数组作实参时 for-in 在 layout 脱糖成 compact 取值（xv·at）， -// 函数内改用 kv·listlen/kv·listn/kv·get 显式遍历。 +// 函数内改用 kvspace·listlen/kvspace·listn/kvspace·get 显式遍历。 rwfunc print_sum(nums:*[int64]·int64) -> (total:int64) { total = 0 - kv·listlen(nums) -> n + kvspace·listlen(nums) -> n 0 -> i while (i < n) { - kv·listn(nums, i) -> k - kv·get(nums, k) -> x + kvspace·listn(nums, i) -> k + kvspace·get(nums, k) -> x println(x) total = total + x i = i + 1 diff --git a/tutorial/05-dict/kv_has_string_key.kv b/tutorial/05-dict/kv_has_string_key.kv index eb4e7253..48b3c7a6 100644 --- a/tutorial/05-dict/kv_has_string_key.kv +++ b/tutorial/05-dict/kv_has_string_key.kv @@ -3,6 +3,6 @@ rwfunc test() -> () { /tmp/kvhas_test:[]char/utf8·int64 = {} /tmp/kvhas_test·data = 42 - kv·get(/tmp/kvhas_test, "data") != None -> ok + kvspace·get(/tmp/kvhas_test, "data") != None -> ok println(ok) } diff --git a/tutorial/05-dict/literal.kv b/tutorial/05-dict/literal.kv index a2e69e92..4b47c445 100644 --- a/tutorial/05-dict/literal.kv +++ b/tutorial/05-dict/literal.kv @@ -1,6 +1,6 @@ // literal: 字典（stringkeymap）成员赋值与访问 // 语义: h:[]char/utf32·int64 = {} 建空字典；h·key = v 成员赋值；base·key 访问； -// kv·get 检查存在性（缺失键返回 None） +// kvspace·get 检查存在性（缺失键返回 None） // 期望输出: // h·x = 1 // h·z = 42 @@ -13,6 +13,6 @@ rwfunc test() -> () { println("h·x =", v) 42 -> h·z println("h·z =", h·z) - kv·get(h, "x") != None -> ok + kvspace·get(h, "x") != None -> ok println("has x:", ok) } diff --git a/tutorial/05-dict/literal_as_arg.kv b/tutorial/05-dict/literal_as_arg.kv index 46f4e7f9..8a278c94 100644 --- a/tutorial/05-dict/literal_as_arg.kv +++ b/tutorial/05-dict/literal_as_arg.kv @@ -5,10 +5,10 @@ // 3 // hi rwfunc count(a:*[int64]·[]char/utf32) -> (n:int64) { - kv·listlen(a) -> n + kvspace·listlen(a) -> n } rwfunc first(a:*[int64]·[]char/utf32) -> (v:[]char/utf32) { - kv·get(a, "[0]") -> v + kvspace·get(a, "[0]") -> v } rwfunc test() -> () { args:[int64]·[]char/utf32 = {"a", "b", "c"} diff --git a/tutorial/06-algo/map_reduce.kv b/tutorial/06-algo/map_reduce.kv index a6f16aad..89c3058d 100644 --- a/tutorial/06-algo/map_reduce.kv +++ b/tutorial/06-algo/map_reduce.kv @@ -4,15 +4,15 @@ // odd squares count: 5 // sum of squares: 165 // 散 key 数组作实参时 for-in 在 layout 脱糖成 compact 取值（xv·at）， -// 函数内改用 kv·listlen/kv·listn/kv·get 显式遍历。 +// 函数内改用 kvspace·listlen/kvspace·listn/kvspace·get 显式遍历。 rwfunc map_reduce(nums:*[int64]·int64) -> (count:int64, total:int64) { 0 -> count total = 0 - kv·listlen(nums) -> n + kvspace·listlen(nums) -> n 0 -> i while (i < n) { - kv·listn(nums, i) -> k - kv·get(nums, k) -> nv + kvspace·listn(nums, i) -> k + kvspace·get(nums, k) -> nv rem = nv % 2 rem == 1 -> is_odd diff --git a/tutorial/06-algo/word_count.kv b/tutorial/06-algo/word_count.kv index fbf1d83c..3cce87d9 100644 --- a/tutorial/06-algo/word_count.kv +++ b/tutorial/06-algo/word_count.kv @@ -3,15 +3,15 @@ // 期望输出: // word count = 3 // 散 key 数组作实参时 for-in 在 layout 脱糖成 compact 取值（xv·at）， -// 函数内改用 kv·listlen/kv·listn/kv·get 显式遍历。 +// 函数内改用 kvspace·listlen/kvspace·listn/kvspace·get 显式遍历。 rwfunc word_count(chars:*[int64]·[]char/utf32) -> (nw:int64) { nw = 0 0 -> state - kv·listlen(chars) -> n + kvspace·listlen(chars) -> n 0 -> i while (i < n) { - kv·listn(chars, i) -> k - kv·get(chars, k) -> c + kvspace·listn(chars, i) -> k + kvspace·get(chars, k) -> c blank = c == " " if (blank) { diff --git a/tutorial/07-lib/walk_lib.kv b/tutorial/07-lib/walk_lib.kv index d1fb5228..479a5326 100644 --- a/tutorial/07-lib/walk_lib.kv +++ b/tutorial/07-lib/walk_lib.kv @@ -1,17 +1,17 @@ -// 递归打印 /lib 代码树：kv·listlen/kv·listn 逐层列举 + 自递归 -// 目录名以 "/" 结尾则下钻；kv·listn 返回 utf8，显式 char/utf32 转码后才能喂给 string·find（utf32） +// 递归打印 /lib 代码树：kvspace·listlen/kvspace·listn 逐层列举 + 自递归 +// 目录名以 "/" 结尾则下钻；kvspace·listn 返回 utf8，显式 char/utf32 转码后才能喂给 string·find（utf32） // 期望输出: // /lib/ // print // println -// kv +// kvspace // string // math rwfunc walk(path:[]char/utf32, indent:[]char/utf32) -> () { - kv·listlen(path) -> n + kvspace·listlen(path) -> n 0 -> i while (i < n) { - kv·listn(path, i) -> nm8 + kvspace·listn(path, i) -> nm8 char/utf32(nm8) -> nm println(indent, nm) string·find(nm, "/") -> sl diff --git a/tutorial/08-leetcode/001_two-sum-hash.kv b/tutorial/08-leetcode/001_two-sum-hash.kv index eb2ec504..8e14af88 100644 --- a/tutorial/08-leetcode/001_two-sum-hash.kv +++ b/tutorial/08-leetcode/001_two-sum-hash.kv @@ -1,4 +1,4 @@ -// 001: Two Sum — O(n) hash map。two_sum 用 kv·get/kv·set； +// 001: Two Sum — O(n) hash map。two_sum 用 kvspace·get/kvspace·set； // two_sum2 用动态成员名 `·*k` 直接读写路径成员。 // 来源: LeetCode #1 // 期望输出: @@ -11,23 +11,23 @@ rwfunc two_sum(nums:[]int64, target:int64) -> () { while (i < n) { x = nums[i] need = target - x - kv·get(h, need) != None -> exists + kvspace·get(h, need) != None -> exists if (exists) { - kv·get(h, need) -> j + kvspace·get(h, need) -> j k = j - 1 println("[", k, ",", i, "]") n -> i } else { v = i + 1 - _ = kv·set(h, x, v) + _ = kvspace·set(h, x, v) i + 1 -> i } } } // 同 two_sum，但用**动态成员名** `·*k` 直接读写路径成员： -// `base·*k` 取 k 的值作 memitemkey（等价 kv·get(base,k)/kv·set(base,k,v)）； +// `base·*k` 取 k 的值作 memitemkey（等价 kvspace·get(base,k)/kvspace·set(base,k,v)）； // 裸 `base·k` 用的是**字面名** k，两者不可混（见 05-runtime语义/03-成员访问）。 rwfunc two_sum2(nums:[]int64, target:int64) -> () { n = ndarray·numel(nums) diff --git a/tutorial/08-leetcode/002_add_two_numbers.kv b/tutorial/08-leetcode/002_add_two_numbers.kv index 7f2e777a..8c28b4ba 100644 --- a/tutorial/08-leetcode/002_add_two_numbers.kv +++ b/tutorial/08-leetcode/002_add_two_numbers.kv @@ -32,14 +32,14 @@ rwfunc add(a:*Node, b:*Node) -> () { } digit = sum % 10 - kv·set(result, ri, digit) -> _ + kvspace·set(result, ri, digit) -> _ ri + 1 -> ri sum ÷ 10 -> carry sum ÷ 10 -> carry_m } i = ri - 1 while (i >= 0) { - v = kv·get(result, i) + v = kvspace·get(result, i) println(v) i - 1 -> i } diff --git a/tutorial/08-leetcode/003_longest_substring.kv b/tutorial/08-leetcode/003_longest_substring.kv index 7a40aeda..a0b2f77f 100644 --- a/tutorial/08-leetcode/003_longest_substring.kv +++ b/tutorial/08-leetcode/003_longest_substring.kv @@ -12,13 +12,13 @@ rwfunc length_of_longest(s:[]char/utf32) -> (max_len:int64) { right = 0 while (right < n) { s[right] -> c - exists = kv·get(last, c) != None + exists = kvspace·get(last, c) != None if (exists) { - prev = kv·get(last, c) + prev = kvspace·get(last, c) cand = prev + 1 if (cand > left) { left = cand } } - _ = kv·set(last, c, right) + _ = kvspace·set(last, c, right) cur = right - left + 1 if (cur > max_len) { cur -> max_len } right + 1 -> right diff --git a/tutorial/08-leetcode/020_valid_parentheses.kv b/tutorial/08-leetcode/020_valid_parentheses.kv index 90f6fb86..d0cf5eba 100644 --- a/tutorial/08-leetcode/020_valid_parentheses.kv +++ b/tutorial/08-leetcode/020_valid_parentheses.kv @@ -14,15 +14,15 @@ rwfunc is_valid(s:[]char/utf32) -> (ok:int64) { if (c == "(") { si + 1 -> si /tmp/vp:[int64]·int64 = {} - _ = kv·set("/tmp/vp", si, 1) + _ = kvspace·set("/tmp/vp", si, 1) } if (c == "[") { si = si + 1 - kv·set("/tmp/vp", si, 2) -> _ + kvspace·set("/tmp/vp", si, 2) -> _ } if (c == "{") { si + 1 -> si - _ = kv·set("/tmp/vp", si, 3) + _ = kvspace·set("/tmp/vp", si, 3) } if (c == ")") { if (si < 0) { 0 -> ok ; n -> i } diff --git a/tutorial/08-leetcode/038_count_and_say.kv b/tutorial/08-leetcode/038_count_and_say.kv index 593c4eb5..19edcd25 100644 --- a/tutorial/08-leetcode/038_count_and_say.kv +++ b/tutorial/08-leetcode/038_count_and_say.kv @@ -12,16 +12,16 @@ rwfunc next_seq(src_len:int64) -> (dst_len:int64) { i = 0 di = 0 while (i < src_len) { - kv·get("/tmp/s", i) -> cur + kvspace·get("/tmp/s", i) -> cur count = 1 j = i + 1 while (j < src_len) { - kv·get("/tmp/s", j) -> v + kvspace·get("/tmp/s", j) -> v if (v == cur) { count + 1 -> count ; j + 1 -> j } else { src_len -> j } } - _ = kv·set("/tmp/s2", di, count) - _ = kv·set("/tmp/s2", di+1, cur) + _ = kvspace·set("/tmp/s2", di, count) + _ = kvspace·set("/tmp/s2", di+1, cur) di + 2 -> di i + count -> i } @@ -31,8 +31,8 @@ rwfunc next_seq(src_len:int64) -> (dst_len:int64) { rwfunc print_seq_len(seq_len:int64) -> () { i = 0 while (i < seq_len) { - kv·get("/tmp/s", i) -> cnt - kv·get("/tmp/s", i+1) -> val + kvspace·get("/tmp/s", i) -> cnt + kvspace·get("/tmp/s", i+1) -> val k = 0 while (k < cnt) { print(val) @@ -47,15 +47,15 @@ rwfunc copy_from_s2_to_s(s2_len:int64) -> () { i = 0 while (i < s2_len) { /tmp/s2[i] -> v - _ = kv·set("/tmp/s", i, v) + _ = kvspace·set("/tmp/s", i, v) i + 1 -> i } } rwfunc count_and_say(N:int64) -> () { /tmp/s:[int64]·int64 = {} - _ = kv·set("/tmp/s", 0, 1) // count=1 of digit 1 - _ = kv·set("/tmp/s", 1, 1) + _ = kvspace·set("/tmp/s", 0, 1) // count=1 of digit 1 + _ = kvspace·set("/tmp/s", 1, 1) cur_len = 2 round = 1 while (round < N) { diff --git a/tutorial/08-leetcode/056_merge_intervals.kv b/tutorial/08-leetcode/056_merge_intervals.kv index e4cf01de..ffcbea90 100644 --- a/tutorial/08-leetcode/056_merge_intervals.kv +++ b/tutorial/08-leetcode/056_merge_intervals.kv @@ -10,15 +10,15 @@ rwfunc bubble_sort(n:int64) -> () { while (i < n - 1) { j = 0 while (j < n - 1 - i) { - kv·get("/tmp/mi", j) -> ta - kv·get("/tmp/mi", j+1) -> tb + kvspace·get("/tmp/mi", j) -> ta + kvspace·get("/tmp/mi", j+1) -> tb ta[0] -> a tb[0] -> b if (a > b) { ta[1] -> a1 tb[1] -> b1 - _ = kv·set("/tmp/mi", j, [b, b1]) - _ = kv·set("/tmp/mi", j+1, [a, a1]) + _ = kvspace·set("/tmp/mi", j, [b, b1]) + _ = kvspace·set("/tmp/mi", j+1, [a, a1]) } j + 1 -> j } @@ -29,42 +29,42 @@ rwfunc bubble_sort(n:int64) -> () { rwfunc merge(n:int64) -> (m:int64) { bubble_sort(n) ki = 0 - kv·get("/tmp/mi", 0) -> cur + kvspace·get("/tmp/mi", 0) -> cur idx = 1 while (idx < n) { - kv·get("/tmp/mi", idx) -> nxt + kvspace·get("/tmp/mi", idx) -> nxt cur[1] -> cur_end nxt[0] -> nxt_start nxt[1] -> nxt_end if (cur_end >= nxt_start) { if (nxt_end > cur_end) { /tmp/mr:[int64]·[2]int64 = {} - _ = kv·set("/tmp/mr", ki, [cur[0], nxt_end]) - kv·get("/tmp/mr", ki) -> cur + _ = kvspace·set("/tmp/mr", ki, [cur[0], nxt_end]) + kvspace·get("/tmp/mr", ki) -> cur } } else { - _ = kv·set("/tmp/mr", ki, cur) + _ = kvspace·set("/tmp/mr", ki, cur) ki = ki + 1 nxt -> cur } idx + 1 -> idx } - _ = kv·set("/tmp/mr", ki, cur) + _ = kvspace·set("/tmp/mr", ki, cur) ki + 1 -> m } rwfunc test() -> () { // init intervals in tmp storage /tmp/mi:[int64]·[2]int64 = {} - _ = kv·set("/tmp/mi", 0, [1, 3]) - _ = kv·set("/tmp/mi", 1, [2, 6]) - _ = kv·set("/tmp/mi", 2, [8, 10]) - _ = kv·set("/tmp/mi", 3, [15, 18]) + _ = kvspace·set("/tmp/mi", 0, [1, 3]) + _ = kvspace·set("/tmp/mi", 1, [2, 6]) + _ = kvspace·set("/tmp/mi", 2, [8, 10]) + _ = kvspace·set("/tmp/mi", 3, [15, 18]) /tmp/mr:[int64]·[2]int64 = {} cnt = merge(4) i = 0 while (i < cnt) { - kv·get("/tmp/mr", i) -> iv + kvspace·get("/tmp/mr", i) -> iv print("[", iv[0], ",", iv[1], "]"); println() i + 1 -> i } diff --git a/tutorial/08-leetcode/062_unique_paths.kv b/tutorial/08-leetcode/062_unique_paths.kv index 2aea2688..3bb409c5 100644 --- a/tutorial/08-leetcode/062_unique_paths.kv +++ b/tutorial/08-leetcode/062_unique_paths.kv @@ -7,21 +7,21 @@ rwfunc dp(m:int64, n:int64) -> (result:int64) { /tmp/up:[int64]·int64 = {} i = 0 while (i < n) { - _ = kv·set("/tmp/up", i, 1) + _ = kvspace·set("/tmp/up", i, 1) i + 1 -> i } j = 1 while (j < m) { k = 1 while (k < n) { - kv·get("/tmp/up", k) -> v - kv·get("/tmp/up", k-1) -> prev - _ = kv·set("/tmp/up", k, prev + v) + kvspace·get("/tmp/up", k) -> v + kvspace·get("/tmp/up", k-1) -> prev + _ = kvspace·set("/tmp/up", k, prev + v) k + 1 -> k } j + 1 -> j } - kv·get("/tmp/up", n-1) -> result + kvspace·get("/tmp/up", n-1) -> result } rwfunc test() -> () { diff --git a/tutorial/08-leetcode/094_inorder_traversal.kv b/tutorial/08-leetcode/094_inorder_traversal.kv index a558445b..6345b928 100644 --- a/tutorial/08-leetcode/094_inorder_traversal.kv +++ b/tutorial/08-leetcode/094_inorder_traversal.kv @@ -17,12 +17,12 @@ rwfunc inorder(root:*TNode) -> () { cur = root while (cur != None || si > 0) { while (cur != None) { - _ = kv·set(stack, si, cur) + _ = kvspace·set(stack, si, cur) si + 1 -> si cur·left -> cur } si - 1 -> si - kv·get(stack, si) -> node + kvspace·get(stack, si) -> node node·val -> v println(v) node·right -> cur diff --git a/tutorial/08-leetcode/118_pascal_triangle.kv b/tutorial/08-leetcode/118_pascal_triangle.kv index a71867d6..ae1a8c77 100644 --- a/tutorial/08-leetcode/118_pascal_triangle.kv +++ b/tutorial/08-leetcode/118_pascal_triangle.kv @@ -21,29 +21,29 @@ rwfunc generate(num_rows:int64) -> () { /tmp/cur:[int64]·int64 = {} // store prev row in dict /tmp/pt:[int64]·int64 = {} - _ = kv·set("/tmp/pt", 0, 1) + _ = kvspace·set("/tmp/pt", 0, 1) println(1) if (num_rows == 1) { } r = 1 while (r < num_rows) { println(1) - _ = kv·set("/tmp/cur", 0, 1) + _ = kvspace·set("/tmp/cur", 0, 1) i = 1 while (i < r) { - kv·get("/tmp/pt", i-1) -> a - kv·get("/tmp/pt", i) -> b + kvspace·get("/tmp/pt", i-1) -> a + kvspace·get("/tmp/pt", i) -> b v = a + b println(v) - _ = kv·set("/tmp/cur", i, v) + _ = kvspace·set("/tmp/cur", i, v) i + 1 -> i } println(1) - _ = kv·set("/tmp/cur", r, 1) + _ = kvspace·set("/tmp/cur", r, 1) // copy cur to pt k = 0 while (k <= r) { - kv·get("/tmp/cur", k) -> val - _ = kv·set("/tmp/pt", k, val) + kvspace·get("/tmp/cur", k) -> val + _ = kvspace·set("/tmp/pt", k, val) k + 1 -> k } r + 1 -> r diff --git a/tutorial/08-leetcode/217_contains_dup_hash.kv b/tutorial/08-leetcode/217_contains_dup_hash.kv index 4b2e7a8b..211c9ecd 100644 --- a/tutorial/08-leetcode/217_contains_dup_hash.kv +++ b/tutorial/08-leetcode/217_contains_dup_hash.kv @@ -10,13 +10,13 @@ rwfunc has_dup(a:[]int64) -> () { i = 0 while (i < n) { a[i] -> x - kv·get(seen, x) != None -> exists + kvspace·get(seen, x) != None -> exists if (exists) { true -> found i = n } else { - _ = kv·set(seen, x, 1) + _ = kvspace·set(seen, x, 1) i + 1 -> i } } @@ -37,13 +37,13 @@ rwfunc no_dup() -> () { i = 0 while (i < n) { a[i] -> x - kv·get(seen, x) != None -> exists + kvspace·get(seen, x) != None -> exists if (exists) { true -> found i = n } else { - _ = kv·set(seen, x, 1) + _ = kvspace·set(seen, x, 1) i + 1 -> i } } diff --git a/tutorial/08-leetcode/219_contains_dup_ii.kv b/tutorial/08-leetcode/219_contains_dup_ii.kv index 9d5ae25b..24390b3e 100644 --- a/tutorial/08-leetcode/219_contains_dup_ii.kv +++ b/tutorial/08-leetcode/219_contains_dup_ii.kv @@ -10,7 +10,7 @@ rwfunc near_dup(nums:[]int64, k:int64) -> () { 0 -> i while (i < n) { nums[i] -> x - kv·get(h, x) != None -> exists + kvspace·get(h, x) != None -> exists if (exists) { h·*x -> j @@ -24,7 +24,7 @@ rwfunc near_dup(nums:[]int64, k:int64) -> () { } } if (found == false) { - kv·set(h, x, i + 1) -> _ + kvspace·set(h, x, i + 1) -> _ } i = i + 1 } diff --git a/tutorial/08-leetcode/234_palindrome_list.kv b/tutorial/08-leetcode/234_palindrome_list.kv index baaa3b5c..a9c99147 100644 --- a/tutorial/08-leetcode/234_palindrome_list.kv +++ b/tutorial/08-leetcode/234_palindrome_list.kv @@ -14,7 +14,7 @@ rwfunc is_pal(head:*Node) -> () { head -> p while (p != None) { p·val -> v - kv·set(arr, n, v) -> _ + kvspace·set(arr, n, v) -> _ n = n + 1 p·next -> p } @@ -22,8 +22,8 @@ rwfunc is_pal(head:*Node) -> () { 0 -> l r = n - 1 while (l < r) { - kv·get(arr, l) -> x - kv·get(arr, r) -> y + kvspace·get(arr, l) -> x + kvspace·get(arr, r) -> y if (x != y) { false -> ok diff --git a/tutorial/08-leetcode/242_valid_anagram.kv b/tutorial/08-leetcode/242_valid_anagram.kv index 572b1745..9b0f68b6 100644 --- a/tutorial/08-leetcode/242_valid_anagram.kv +++ b/tutorial/08-leetcode/242_valid_anagram.kv @@ -15,7 +15,7 @@ rwfunc is_anagram(s:[]char/utf32, t:[]char/utf32) -> () { 0 -> i while (i < ns) { string·char(s, i) -> c - kv·get(h, c) != None -> exists + kvspace·get(h, c) != None -> exists if (exists) { h·*c + 1 -> h·*c } else { @@ -26,7 +26,7 @@ rwfunc is_anagram(s:[]char/utf32, t:[]char/utf32) -> () { 0 -> i while (i < nt) { string·char(t, i) -> c - kv·get(h, c) != None -> exists + kvspace·get(h, c) != None -> exists if (exists) { h·*c -> v v - 1 -> h·*c diff --git a/tutorial/10-types/01-typed-map.kv b/tutorial/10-types/01-typed-map.kv index eb44f4d3..55718e2f 100644 --- a/tutorial/10-types/01-typed-map.kv +++ b/tutorial/10-types/01-typed-map.kv @@ -5,13 +5,13 @@ // total = 30 // max = 20 rwfunc total(m:*[]char/utf8·int64) -> (s:int64) { - kv·get(m, "a") -> a - kv·get(m, "b") -> b + kvspace·get(m, "a") -> a + kvspace·get(m, "b") -> b (a + b) -> s } rwfunc max2(m:*[]char/utf8·int64) -> (mx:int64) { - kv·get(m, "a") -> a - kv·get(m, "b") -> b + kvspace·get(m, "a") -> a + kvspace·get(m, "b") -> b max(a, b) -> mx } rwfunc test() -> () { diff --git a/tutorial/10-types/02-string-map.kv b/tutorial/10-types/02-string-map.kv index 977f6222..b73948ba 100644 --- a/tutorial/10-types/02-string-map.kv +++ b/tutorial/10-types/02-string-map.kv @@ -5,7 +5,7 @@ // zh = 你好 // missing: true rwfunc lookup(dict:*[]char/utf8·[]char/utf32, k:[]char/utf32) -> (v:[]char/utf32) { - kv·get(dict, k) -> v + kvspace·get(dict, k) -> v } rwfunc test() -> () { d:[]char/utf8·[]char/utf32 = {} @@ -15,6 +15,6 @@ rwfunc test() -> () { println("en =", a) lookup(d, "zh") -> b println("zh =", b) - kv·get(d, "fr") == None -> gone + kvspace·get(d, "fr") == None -> gone println("missing:", gone) } diff --git a/tutorial/10-types/03-map-return.kv b/tutorial/10-types/03-map-return.kv index d36b1602..2b59a886 100644 --- a/tutorial/10-types/03-map-return.kv +++ b/tutorial/10-types/03-map-return.kv @@ -9,10 +9,10 @@ rwfunc build() -> (m:*[]char/utf8·int64) { } rwfunc test() -> () { build() -> r - kv·get(r, "n") -> n + kvspace·get(r, "n") -> n println("n =", n) - kv·get(r, "x") -> x + kvspace·get(r, "x") -> x println("x =", x) - kv·get(r, "none") == None -> miss + kvspace·get(r, "none") == None -> miss println("miss =", miss) } diff --git a/tutorial/10-types/06-any-read-param.kv b/tutorial/10-types/06-any-read-param.kv index 478166bc..c12c6f57 100644 --- a/tutorial/10-types/06-any-read-param.kv +++ b/tutorial/10-types/06-any-read-param.kv @@ -8,7 +8,7 @@ // 3 // 42 rwfunc size_of(a:any) -> (n:int64) { - kv·listlen(a) -> n + kvspace·listlen(a) -> n } rwfunc print_any(a:any) -> () { println(a) diff --git a/tutorial/12-struct/03-linked-list.kv b/tutorial/12-struct/03-linked-list.kv index d0e53aa2..5ac89462 100644 --- a/tutorial/12-struct/03-linked-list.kv +++ b/tutorial/12-struct/03-linked-list.kv @@ -1,5 +1,5 @@ // linked-list: 局部 struct 节点变量 + & 取址串成链表 -// 语义: 每个节点是帧内 struct 局部变量；next 存下一节点地址（&node ≡ kv·abs(node)）； +// 语义: 每个节点是帧内 struct 局部变量；next 存下一节点地址（&node ≡ kvlang·abs(node)）； // None=尾；show_list 接收 *Node 头指针，按 next 路径解引用逐节点打印。 // 尾节点先建，&node 恒指向已存在节点。 // 期望输出: diff --git a/tutorial/12-struct/07-list-local.kv b/tutorial/12-struct/07-list-local.kv index 0dff0a5c..04177690 100644 --- a/tutorial/12-struct/07-list-local.kv +++ b/tutorial/12-struct/07-list-local.kv @@ -1,5 +1,5 @@ // list-local: 局部 struct 节点变量 + & 建链，遍历求和 -// 语义: 节点是帧内 struct 局部变量，next 存下一节点地址（&node ≡ kv·abs(node)）； +// 语义: 节点是帧内 struct 局部变量，next 存下一节点地址（&node ≡ kvlang·abs(node)）； // None=尾；sum_list 接收 *Node 头指针，遍历累加各节点 val。 // 链表: 10→20→30 // 期望输出: diff --git a/tutorial/13-stdlib/kv/get_or.kv b/tutorial/13-stdlib/kv/get_or.kv index a838a6ff..80e776eb 100644 --- a/tutorial/13-stdlib/kv/get_or.kv +++ b/tutorial/13-stdlib/kv/get_or.kv @@ -1,12 +1,12 @@ -// kv·get_or：读取 KV 值，不存在时返回默认值 +// kvspace·get_or：读取 KV 值，不存在时返回默认值 // 期望输出: // get_or missing: default_val // get_or existing: world rwfunc test() -> () { - v1 = kv·get_or("/missing_key", "default_val") + v1 = kvspace·get_or("/missing_key", "default_val") println("get_or missing:", v1) - kv·set("/exists_key", "world") - v2 = kv·get_or("/exists_key", "default_val") + kvspace·set("/exists_key", "world") + v2 = kvspace·get_or("/exists_key", "default_val") println("get_or existing:", v2) } diff --git a/tutorial/13-stdlib/kv/has.kv b/tutorial/13-stdlib/kv/has.kv index bf7504d0..febe091c 100644 --- a/tutorial/13-stdlib/kv/has.kv +++ b/tutorial/13-stdlib/kv/has.kv @@ -1,12 +1,12 @@ -// kv·has：检测 KV 路径是否存在 +// kvspace·has：检测 KV 路径是否存在 // 期望输出: // has missing: false // has existing: true rwfunc test() -> () { - h1 = kv·has("/missing_key") + h1 = kvspace·has("/missing_key") println("has missing:", h1) - kv·set("/exists_key", "hello") - h2 = kv·has("/exists_key") + kvspace·set("/exists_key", "hello") + h2 = kvspace·has("/exists_key") println("has existing:", h2) } diff --git a/tutorial/13-stdlib/kv/set_default.kv b/tutorial/13-stdlib/kv/set_default.kv index 44078e36..008ab975 100644 --- a/tutorial/13-stdlib/kv/set_default.kv +++ b/tutorial/13-stdlib/kv/set_default.kv @@ -1,13 +1,13 @@ -// kv·set_default：路径不存在时写入，已存在则保留原值 +// kvspace·set_default：路径不存在时写入，已存在则保留原值 // 期望输出: // set_default new: first_val // set_default existing: first_val rwfunc test() -> () { - kv·set_default("/sd_key", "first_val") - sd1 = kv·get("/sd_key") + kvspace·set_default("/sd_key", "first_val") + sd1 = kvspace·get("/sd_key") println("set_default new:", sd1) - kv·set_default("/sd_key", "second_val") - sd2 = kv·get("/sd_key") + kvspace·set_default("/sd_key", "second_val") + sd2 = kvspace·get("/sd_key") println("set_default existing:", sd2) } diff --git a/tutorial/13-stdlib/math/constants.kv b/tutorial/13-stdlib/math/constants.kv index 25e79339..74e8d460 100644 --- a/tutorial/13-stdlib/math/constants.kv +++ b/tutorial/13-stdlib/math/constants.kv @@ -6,8 +6,8 @@ rwfunc test() -> () { /lib/math·Pi -> pi println("Pi=", pi) - kv·get("/lib/math·E") -> e + kvspace·get("/lib/math·E") -> e println("E=", e) - kv·get("/lib/math·Tau") -> tau + kvspace·get("/lib/math·Tau") -> tau println("Tau=", tau) } diff --git a/tutorial/14-networld/08-fs-dir.kv b/tutorial/14-networld/08-fs-dir.kv index be2044c4..f1528e2b 100644 --- a/tutorial/14-networld/08-fs-dir.kv +++ b/tutorial/14-networld/08-fs-dir.kv @@ -1,6 +1,6 @@ // networld/fs·mkdir + list + del：目录创建、列举成员、删除 // fs·mkdir(d) -> 0 创建目录（含缺失父级，幂等） -// fs·list(d) -> names 列目录成员（名字序，[int64]·[]char/utf32）；散 key 两步遍历 kv·listn+kv·get 取名 +// fs·list(d) -> names 列目录成员（名字序，[int64]·[]char/utf32）；散 key 两步遍历 kvspace·listn+kvspace·get 取名 // fs·del(p) -> 0 删文件或空目录；非空目录失败返回 -1 // 期望输出: // count= 2 @@ -11,12 +11,12 @@ // print_dir 列目录成员（map 两步遍历）并打印成员数与逐个名字 rwfunc print_dir(d:[]char/utf32) -> () { networld/fs·list(d) -> names - kv·listlen(names) -> nc + kvspace·listlen(names) -> nc println("count=", nc) i = 0 while (i < nc) { - kv·listn(names, i) -> key - kv·get(names, key) -> nm + kvspace·listn(names, i) -> key + kvspace·get(names, key) -> nm println("name=", nm) i = i + 1 } diff --git a/tutorial/15-vthread/02-crashrecover.kv b/tutorial/15-vthread/02-crashrecover.kv index b3687ae8..998a77b2 100644 --- a/tutorial/15-vthread/02-crashrecover.kv +++ b/tutorial/15-vthread/02-crashrecover.kv @@ -15,7 +15,7 @@ rwfunc run_steps(limit:int64) -> (final:int64) { 0 -> i while (i < limit) { i + 1 -> i - kv·set("/crashtest/step", i) + kvspace·set("/crashtest/step", i) println("step", i) noenv:[int64]·[]char/utf32 = {} a:[int64]·[]char/utf32 = {"sleep", "0.2"} @@ -26,6 +26,6 @@ rwfunc run_steps(limit:int64) -> (final:int64) { rwfunc test() -> () { run_steps(5) -> i - kv·set("/crashtest/done", 1) + kvspace·set("/crashtest/done", 1) println("complete final=", i) }