From 0769a11bec14904d01dd745e866c11bd9aad1635 Mon Sep 17 00:00:00 2001
From: "peng.li24" <734991033@qq.com>
Date: Wed, 26 Aug 2026 07:17:42 +0800
Subject: [PATCH] =?UTF-8?q?feat:=20=E6=88=90=E5=91=98=E5=88=86=E9=9A=94?=
 =?UTF-8?q?=E7=AC=A6=20.=20=E2=86=92=20=C2=B7=EF=BC=88=E4=B8=AD=E7=82=B9?=
 =?UTF-8?q?=E5=8F=B7=EF=BC=89=EF=BC=8C=E8=A7=A3=E6=94=BE=20.=20=E7=BB=99?=
 =?UTF-8?q?=E5=B0=8F=E6=95=B0=E7=82=B9/=E5=B0=8F=E6=95=B0=E5=9D=90?=
 =?UTF-8?q?=E6=A0=87=20key?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-Authored-By: Claude <noreply@anthropic.com>
---
 layout/examples/layout_file.rs                |  4 +-
 layout/src/capi.rs                            |  4 +-
 layout/src/code.rs                            | 20 ++++----
 layout/src/keytree.rs                         |  6 +--
 layout/src/lower.rs                           | 42 ++++++++--------
 layout/src/parser.rs                          | 39 +++++++++------
 layout/src/scanner.rs                         | 16 ++++--
 layout/src/symbol.rs                          |  2 +-
 layout/tests/pipeline_test.rs                 | 12 ++---
 layout/tests/redis_roundtrip_test.rs          |  2 +-
 runtime/src/builtin.c                         | 50 +++++++++----------
 runtime/src/const.h                           |  3 +-
 runtime/src/keytree.c                         |  9 ++--
 runtime/src/kvcpu.c                           | 24 ++++++---
 runtime/src/rwir.c                            |  2 +-
 tutorial/01-basics/arith.kv                   |  8 +--
 tutorial/01-basics/hello.kv                   |  8 +--
 tutorial/01-basics/kv_tree.kv                 | 24 ++++-----
 tutorial/01-basics/random.kv                  | 12 ++---
 tutorial/01-basics/strict_types.kv            |  2 +-
 tutorial/01-basics/strings.kv                 | 12 ++---
 tutorial/01-basics/time.kv                    | 28 +++++------
 tutorial/02-func/accumulator.kv               |  4 +-
 tutorial/03-control/for.kv                    | 32 ++++++------
 tutorial/03-control/if.kv                     |  6 +--
 tutorial/04-ndarray/continuous.kv             |  2 +-
 tutorial/04-ndarray/geo_coord.kv              | 14 ++++++
 tutorial/04-ndarray/map_coord.kv              |  8 +--
 tutorial/04-ndarray/separated.kv              | 26 +++++-----
 tutorial/04-ndarray/sparse_literal.kv         |  2 +-
 tutorial/04-ndarray/xv_shape.kv               | 10 ++--
 tutorial/05-dict/kv_has_string_key.kv         |  4 +-
 tutorial/05-dict/literal.kv                   | 16 +++---
 tutorial/06-algo/factorial.kv                 |  8 +--
 tutorial/06-algo/fibonacci.kv                 |  8 +--
 tutorial/06-algo/gcd.kv                       |  8 +--
 tutorial/06-algo/map_reduce.kv                | 20 ++++----
 tutorial/06-algo/prime_sieve.kv               |  8 +--
 tutorial/06-algo/word_count.kv                | 36 ++++++-------
 tutorial/07-lib/cross/inline.kv               |  2 +-
 tutorial/07-lib/cross/lib_b.kv                |  4 +-
 tutorial/07-lib/inline_lib.kv                 | 10 ++--
 tutorial/07-lib/multi/lib_b.kv                |  2 +-
 tutorial/07-lib/single/inline.kv              |  2 +-
 tutorial/07-lib/single/lib.kv                 |  2 +-
 tutorial/08-leetcode/001_two-sum-hash.kv      | 10 ++--
 tutorial/08-leetcode/001_two_sum.kv           |  2 +-
 tutorial/08-leetcode/002_add_two_numbers.kv   | 10 ++--
 tutorial/08-leetcode/003_longest_substring.kv |  6 +--
 tutorial/08-leetcode/008_string_to_int.kv     |  4 +-
 tutorial/08-leetcode/011_container_water.kv   |  2 +-
 tutorial/08-leetcode/013_roman-to-integer.kv  |  2 +-
 tutorial/08-leetcode/013_roman_v2.kv          |  6 +--
 tutorial/08-leetcode/014_longest_common.kv    | 14 +++---
 tutorial/08-leetcode/020_valid_parentheses.kv |  8 +--
 tutorial/08-leetcode/021_merge_two_lists.kv   | 14 +++---
 tutorial/08-leetcode/022_generate_parens.kv   |  2 +-
 tutorial/08-leetcode/026_remove_dupes.kv      |  2 +-
 tutorial/08-leetcode/027_remove_element.kv    |  2 +-
 tutorial/08-leetcode/028_strstr.kv            |  8 +--
 tutorial/08-leetcode/033_search_rotated.kv    |  2 +-
 tutorial/08-leetcode/034_search_range.kv      |  2 +-
 tutorial/08-leetcode/035_search_insert.kv     |  2 +-
 tutorial/08-leetcode/038_count_and_say.kv     | 10 ++--
 tutorial/08-leetcode/053_max_subarray.kv      |  2 +-
 tutorial/08-leetcode/055_jump_game.kv         |  2 +-
 tutorial/08-leetcode/056_merge_intervals.kv   | 18 +++----
 tutorial/08-leetcode/058_length_last_word.kv  |  4 +-
 tutorial/08-leetcode/062_unique_paths.kv      |  4 +-
 tutorial/08-leetcode/066_plus_one.kv          |  4 +-
 tutorial/08-leetcode/067_add_binary.kv        |  4 +-
 tutorial/08-leetcode/075_sort_colors.kv       |  2 +-
 tutorial/08-leetcode/083_remove_dup_list.kv   | 16 +++---
 tutorial/08-leetcode/094_inorder_traversal.kv |  8 +--
 tutorial/08-leetcode/100_same_tree.kv         |  6 +--
 tutorial/08-leetcode/104_max_tree_depth.kv    |  4 +-
 tutorial/08-leetcode/118_pascal_triangle.kv   | 10 ++--
 tutorial/08-leetcode/121_buy_sell_stock.kv    |  2 +-
 tutorial/08-leetcode/125_valid_palindrome.kv  |  4 +-
 .../08-leetcode/125_valid_palindrome_str.kv   |  6 +--
 tutorial/08-leetcode/136_single_number.kv     |  2 +-
 tutorial/08-leetcode/141_linked_list_cycle.kv |  6 +--
 tutorial/08-leetcode/153_find_min_rotated.kv  |  2 +-
 tutorial/08-leetcode/160_intersection_list.kv |  6 +--
 tutorial/08-leetcode/162_find_peak.kv         |  2 +-
 tutorial/08-leetcode/167_two_sum_ii.kv        |  2 +-
 tutorial/08-leetcode/169_majority.kv          |  2 +-
 tutorial/08-leetcode/171_excel_column.kv      |  6 +--
 tutorial/08-leetcode/189_rotate_array.kv      |  2 +-
 tutorial/08-leetcode/198_house_robber.kv      |  2 +-
 .../08-leetcode/203_remove_linked_elements.kv |  4 +-
 .../08-leetcode/206_reverse_linked_list.kv    |  8 +--
 tutorial/08-leetcode/217_contains_dup.kv      |  4 +-
 tutorial/08-leetcode/217_contains_dup_hash.kv | 12 ++---
 tutorial/08-leetcode/219_contains_dup_ii.kv   |  8 +--
 tutorial/08-leetcode/234_palindrome_list.kv   |  6 +--
 .../08-leetcode/238_product_except_self.kv    |  2 +-
 tutorial/08-leetcode/242_valid_anagram.kv     | 26 +++++-----
 tutorial/08-leetcode/268_missing_number.kv    |  2 +-
 tutorial/08-leetcode/283_move_zeroes.kv       |  2 +-
 tutorial/08-leetcode/303_range_sum.kv         |  2 +-
 tutorial/08-leetcode/344_reverse_string.kv    |  4 +-
 tutorial/08-leetcode/349_intersection.kv      |  4 +-
 tutorial/08-leetcode/414_third_max.kv         |  2 +-
 tutorial/09-debugger/chain_array.kv           |  2 +-
 tutorial/11-string/01-basic.kv                |  2 +-
 tutorial/11-string/02-char-ord.kv             |  6 +--
 tutorial/11-string/03-slice-find.kv           |  8 +--
 tutorial/11-string/04-cmp-concat.kv           |  8 +--
 tutorial/11-string/05-encodings.kv            |  4 +-
 tutorial/11-string/06-convert.kv              |  2 +-
 tutorial/12-struct/01-linked-list.kv          | 32 ++++++------
 tutorial/12-struct/02-tree.kv                 | 24 ++++-----
 tutorial/12-struct/03-graph.kv                | 30 +++++------
 .../error_cases/array_param/mutate_correct.kv |  8 +--
 .../error_cases/array_param/mutate_literal.kv |  2 +-
 tutorial/error_cases/index_error/at_oob.kv    |  4 +-
 tutorial/error_cases/index_error/char_oob.kv  |  2 +-
 tutorial/error_cases/index_error/slice_oob.kv |  2 +-
 .../index_error/typed_array_string_key.kv     |  4 +-
 .../error_cases/key_error/kv_at_missing.kv    |  4 +-
 .../error_cases/type_error/char_bad_args.kv   |  4 +-
 .../type_error/concat_non_string.kv           |  4 +-
 123 files changed, 540 insertions(+), 497 deletions(-)
 create mode 100644 tutorial/04-ndarray/geo_coord.kv

diff --git a/layout/examples/layout_file.rs b/layout/examples/layout_file.rs
index 9dfaffe9..fb158e53 100644
--- a/layout/examples/layout_file.rs
+++ b/layout/examples/layout_file.rs
@@ -7,12 +7,12 @@ use std::fs;
 
 use kvlang_layout::{compile, init_dirs, Kv};
 
-/// 复刻 Go runtime 的 findEntry：DFS /lib/ 找首个 `.init`，否则 "init"。
+/// 复刻 Go runtime 的 findEntry：DFS /lib/ 找首个 `·init`，否则 "init"。
 fn find_entry(kv: &mut Kv, prefix: &str) -> String {
     let children = kv.list(prefix, false, true);
     for c in &children {
         let c = c.trim_end_matches('/');
-        if c.ends_with(".init") {
+        if c.ends_with("·init") {
             return c.to_string();
         }
         let sub = format!("{prefix}{c}/");
diff --git a/layout/src/capi.rs b/layout/src/capi.rs
index 21d0e18e..68ae3064 100644
--- a/layout/src/capi.rs
+++ b/layout/src/capi.rs
@@ -18,11 +18,11 @@ use std::panic::catch_unwind;
 
 use crate::{compile, format, init_dirs, kvkind, vet, Kv};
 
-/// 复刻 Go runtime / layout_file 的 findEntry：DFS /lib/ 找首个 `.init`，否则 "init"。
+/// 复刻 Go runtime / layout_file 的 findEntry：DFS /lib/ 找首个 `·init`，否则 "init"。
 fn find_entry(kv: &mut Kv, prefix: &str) -> String {
     for c in kv.list(prefix, false, true) {
         let c = c.trim_end_matches('/');
-        if c.ends_with(".init") {
+        if c.ends_with("·init") {
             return c.to_string();
         }
         let sub = format!("{prefix}{c}/");
diff --git a/layout/src/code.rs b/layout/src/code.rs
index 1de79aa2..fdd0b033 100644
--- a/layout/src/code.rs
+++ b/layout/src/code.rs
@@ -1,11 +1,11 @@
 //! layoutcode（对齐 layout/layout.go 的编译期部分）：把 AST 写到 /lib/ 下的结构化 KV。
 //!
 //! 存储约定：
-//!   /lib/<pkg>.<name>/[0,0]         编译后签名（kind=rwfunc）
-//!   /lib/<pkg>.<name>/<param>       命名参数→slot 指针（kind=char, isptr=1）
-//!   /lib/<pkg>.<name>/[i,j]         编译后指令（kind=rwir），i 从 1 开始
-//!   /lib/<pkg>.<name>/<label>/      基本块子路径（scope 指令）
-//!   /lib/<pkg>.<name>.src           源码副本
+//!   /lib/<pkg>·<name>/[0,0]         编译后签名（kind=rwfunc）
+//!   /lib/<pkg>·<name>/<param>       命名参数→slot 指针（kind=char, isptr=1）
+//!   /lib/<pkg>·<name>/[i,j]         编译后指令（kind=rwir），i 从 1 开始
+//!   /lib/<pkg>·<name>/<label>/      基本块子路径（scope 指令）
+//!   /lib/<pkg>·<name>.src           源码副本
 
 use std::collections::HashMap;
 
@@ -320,7 +320,7 @@ mod tests {
 
     #[test]
     fn format_preserves_lib() {
-        roundtrip("lib http {\n\trwfunc get(url:[]char/utf32) -> (resp:[]char/utf32) {\n\t\thttp.call(\"GET\", \"\", url, \"\") -> resp\n\t}\n}\n");
+        roundtrip("lib http {\n\trwfunc get(url:[]char/utf32) -> (resp:[]char/utf32) {\n\t\thttp·call(\"GET\", \"\", url, \"\") -> resp\n\t}\n}\n");
         roundtrip("lib byteseek {\nlib session {\nlib s1 {\nrwfunc main() -> () {\n3 + 4 -> s\nprintln(s)\n}\n}\n}\n}\nmain()\n");
     }
 
@@ -330,11 +330,11 @@ mod tests {
         init_dirs(&mut kv).unwrap();
 
         compile(&mut kv, "lib a {\nlib b {\nrwfunc f() -> (r:int64) {\n1 -> r\n}\n}\n}\n").unwrap();
-        assert_eq!(kvkind::kind(&kv.get_one("/lib/a/b.f/[0,0]")), "defrwfunc");
+        assert_eq!(kvkind::kind(&kv.get_one("/lib/a/b·f/[0,0]")), "defrwfunc");
 
-        // 同 lib a 下再 layout 另一嵌套 lib c，验证 b.f 未被整库删除（增量合并）
+        // 同 lib a 下再 layout 另一嵌套 lib c，验证 b·f 未被整库删除（增量合并）
         compile(&mut kv, "lib a {\nlib c {\nrwfunc g() -> (r:int64) {\n2 -> r\n}\n}\n}\n").unwrap();
-        assert_eq!(kvkind::kind(&kv.get_one("/lib/a/b.f/[0,0]")), "defrwfunc", "b.f 应保留");
-        assert_eq!(kvkind::kind(&kv.get_one("/lib/a/c.g/[0,0]")), "defrwfunc");
+        assert_eq!(kvkind::kind(&kv.get_one("/lib/a/b·f/[0,0]")), "defrwfunc", "b·f 应保留");
+        assert_eq!(kvkind::kind(&kv.get_one("/lib/a/c·g/[0,0]")), "defrwfunc");
     }
 }
diff --git a/layout/src/keytree.rs b/layout/src/keytree.rs
index 625e0a98..faa46094 100644
--- a/layout/src/keytree.rs
+++ b/layout/src/keytree.rs
@@ -3,7 +3,7 @@
 
 // ── 常量 ─────────────────────────────────────────────────────────────
 
-pub const MEMBER_SEP: &str = "."; // 成员访问分隔符
+pub const MEMBER_SEP: &str = "·"; // 成员访问分隔符（U+00B7 中点号）：释放 '.' 供小数 key 使用
 pub const RUNTIME_MEMBER_SEP: &str = "\u{2025}"; // U+2025，运行时保留字段前缀
 pub const PATH_SEG_SEP: &str = "/"; // 路径分隔符
 pub const PATH_SEG_LIB: &str = "lib"; // /lib
@@ -33,7 +33,7 @@ pub fn lib_func(pkg: &str, name: &str) -> String {
     if pkg.is_empty() {
         format!("{LIB_ROOT}/{name}")
     } else {
-        format!("{LIB_ROOT}/{pkg}.{name}")
+        format!("{LIB_ROOT}/{pkg}{MEMBER_SEP}{name}")
     }
 }
 
@@ -41,7 +41,7 @@ pub fn lib_src(pkg: &str, name: &str) -> String {
     if pkg.is_empty() {
         format!("{LIB_ROOT}/{name}{SRC_EXT}")
     } else {
-        format!("{LIB_ROOT}/{pkg}.{name}{SRC_EXT}")
+        format!("{LIB_ROOT}/{pkg}{MEMBER_SEP}{name}{SRC_EXT}")
     }
 }
 
diff --git a/layout/src/lower.rs b/layout/src/lower.rs
index 2fb1bd5b..7bf33fc7 100644
--- a/layout/src/lower.rs
+++ b/layout/src/lower.rs
@@ -3,7 +3,7 @@
 use std::collections::HashMap;
 
 use super::ast::{self, Expr, Func, Instruction, LitKind, Stmt};
-use super::{builtin, symbol};
+use super::{builtin, keytree, symbol};
 
 // ── 控制流 lowering（续体传递风格） ──────────────────────────────────
 
@@ -218,7 +218,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("kv·listlen", vec![ast::leaf(&iter_slot)])),
             writes: vec![len_slot.clone()],
             write_types: Vec::new(),
             arrow_left: false,
@@ -227,7 +227,7 @@ fn lower_for_with_cont(
     } else {
         init_body.push(Stmt::Instruction(Instruction {
             comments: Vec::new(),
-            expr: Some(ast::call("ndarray.numel", vec![ast::leaf(&iter_slot)])),
+            expr: Some(ast::call("ndarray·numel", vec![ast::leaf(&iter_slot)])),
             writes: vec![len_slot.clone()],
             write_types: Vec::new(),
             arrow_left: false,
@@ -264,7 +264,7 @@ fn lower_for_with_cont(
     if is_obj {
         body_insts.push(Stmt::Instruction(Instruction {
             comments: Vec::new(),
-            expr: Some(ast::call("kv.listn", vec![ast::leaf(&iter_slot), ast::leaf(&idx_slot)])),
+            expr: Some(ast::call("kv·listn", vec![ast::leaf(&iter_slot), ast::leaf(&idx_slot)])),
             writes: vec![key_slot.clone()],
             write_types: Vec::new(),
             arrow_left: false,
@@ -272,7 +272,7 @@ fn lower_for_with_cont(
         }));
         body_insts.push(Stmt::Instruction(Instruction {
             comments: Vec::new(),
-            expr: Some(ast::call("kv.get", vec![ast::leaf(&iter_slot), ast::leaf(&key_slot)])),
+            expr: Some(ast::call("kv·get", vec![ast::leaf(&iter_slot), ast::leaf(&key_slot)])),
             writes: vec![s.var.clone()],
             write_types: Vec::new(),
             arrow_left: false,
@@ -281,7 +281,7 @@ fn lower_for_with_cont(
     } else {
         body_insts.push(Stmt::Instruction(Instruction {
             comments: Vec::new(),
-            expr: Some(ast::call("xv.at", vec![ast::leaf(&iter_slot), ast::leaf(&idx_slot)])),
+            expr: Some(ast::call("xv·at", vec![ast::leaf(&iter_slot), ast::leaf(&idx_slot)])),
             writes: vec![s.var.clone()],
             write_types: Vec::new(),
             arrow_left: false,
@@ -530,7 +530,7 @@ fn infer_inst(inst: &Instruction, tm: &mut HashMap<String, String>) {
         None => return,
     };
     // kv.set 成员形（3 读：base, key, val）是 void 无写槽，但 base 仍须推断为 obj/map（供 for-in / 成员访问）
-    if e.op == "kv.set" && e.args.len() >= 3 && !e.args[0].val.contains('/') {
+    if e.op == "kv·set" && e.args.len() >= 3 && !e.args[0].val.contains('/') {
         tm.entry(e.args[0].val.clone()).or_insert_with(|| "objindex".to_string());
     }
     if inst.writes.is_empty() {
@@ -545,7 +545,7 @@ fn infer_inst(inst: &Instruction, tm: &mut HashMap<String, String>) {
         let inferred = lit_to_type(e.lit);
         if !inferred.is_empty() {
             for w in &inst.writes {
-                if w.is_empty() || w.starts_with('.') {
+                if w.is_empty() || w.starts_with(keytree::MEMBER_SEP) {
                     continue;
                 }
                 tm.entry(w.clone()).or_insert_with(|| inferred.to_string());
@@ -562,7 +562,7 @@ fn infer_inst(inst: &Instruction, tm: &mut HashMap<String, String>) {
         return;
     }
     for w in &inst.writes {
-        if w.is_empty() || w.starts_with('.') {
+        if w.is_empty() || w.starts_with(keytree::MEMBER_SEP) {
             continue;
         }
         tm.entry(w.clone()).or_insert_with(|| inferred.clone());
@@ -603,7 +603,7 @@ fn infer_op_type(opcode: &str, reads: &[String], tm: &mut HashMap<String, String
     if opcode == "map" {
         return "[]strkeymapindex".to_string();
     }
-    if opcode == "kv.set" {
+    if opcode == "kv·set" {
         // 成员写 base.key = v（3 reads：base, key, value）→ base 是 obj/map。
         if reads.len() >= 3 {
             tm.entry(reads[0].clone()).or_insert_with(|| "objindex".to_string());
@@ -611,20 +611,20 @@ fn infer_op_type(opcode: &str, reads: &[String], tm: &mut HashMap<String, String
         return String::new();
     }
     match opcode {
-        "kvlen" | "ndarray.numel" | "ndarray.dim" | "kv.listlen" | "string.len" | "string.ord" | "string.cmp" | "string.find" => {
+        "kvlen" | "ndarray·numel" | "ndarray·dim" | "kv·listlen" | "string·len" | "string·ord" | "string·cmp" | "string·find" => {
             return "int64".to_string();
         }
-        "ndarray.shape" => return "[]int64".to_string(),
-        "kv.list" => return "[]char/utf8".to_string(),
-        "string.char" | "string.set" | "string.slice" | "string.concat" => return "char/utf32".to_string(),
+        "ndarray·shape" => return "[]int64".to_string(),
+        "kv·list" => return "[]char/utf8".to_string(),
+        "string·char" | "string·set" | "string·slice" | "string·concat" => return "char/utf32".to_string(),
         "random.int63" => return "int64".to_string(),
-        "random.intn" | "random.uint64" => return "uint64".to_string(),
+        "random·intn" | "random.uint64" => return "uint64".to_string(),
         "pow" | "sqrt" | "exp" | "log" => return "float64".to_string(),
         "sign" => return "int64".to_string(),
         "abs" | "neg" | "max" | "min" => {
             return if !reads.is_empty() { slot_type(&reads[0], tm) } else { String::new() };
         }
-        "xv.at" => {
+        "xv·at" => {
             if !reads.is_empty() {
                 if let Some(t) = tm.get(&format!("{}.0", reads[0])) {
                     return t.clone();
@@ -637,7 +637,7 @@ fn infer_op_type(opcode: &str, reads: &[String], tm: &mut HashMap<String, String
             }
             return String::new();
         }
-        "xv.set" => {
+        "xv·set" => {
             if let Some(last) = reads.last() {
                 let t = slot_type(last, tm);
                 if !t.is_empty() {
@@ -647,7 +647,7 @@ fn infer_op_type(opcode: &str, reads: &[String], tm: &mut HashMap<String, String
             }
             return if !reads.is_empty() { slot_type(&reads[0], tm) } else { String::new() };
         }
-        "xv.reshape" => {
+        "xv·reshape" => {
             return if !reads.is_empty() { slot_type(&reads[0], tm) } else { String::new() };
         }
         _ => {}
@@ -730,10 +730,10 @@ fn specialize_inst(inst: &mut Instruction, tm: &HashMap<String, String>) {
     }
     // xv.at/xv.set 基座是 obj → 降为 kv.get/kv.set（命名成员目录访问）。
     // map 是散 key 数组（base[i]），保持 xv.at/xv.set 走散 key 下标路径。
-    if (e.op == "xv.at" || e.op == "xv.set") && !e.args.is_empty() {
+    if (e.op == "xv·at" || e.op == "xv·set") && !e.args.is_empty() {
         if let Some(t) = tm.get(&e.args[0].val) {
             if t == "objindex" {
-                e.op = if e.op == "xv.at" { "kv.get".to_string() } else { "kv.set".to_string() };
+                e.op = if e.op == "xv·at" { "kv·get".to_string() } else { "kv·set".to_string() };
             }
         }
     }
@@ -764,5 +764,5 @@ fn specialize_inst(inst: &mut Instruction, tm: &HashMap<String, String>) {
     if k.is_empty() {
         return;
     }
-    e.op = format!("{k}.{word}");
+    e.op = format!("{k}{}{word}", keytree::MEMBER_SEP);
 }
diff --git a/layout/src/parser.rs b/layout/src/parser.rs
index b5b1a243..c9ef780d 100644
--- a/layout/src/parser.rs
+++ b/layout/src/parser.rs
@@ -294,7 +294,8 @@ impl Parser {
         if self.peek().kind == Kind::Ident {
             decl.sig.name = self.advance().value;
             if self.peek().kind == Kind::Dot {
-                decl.sig.name.push_str(&self.advance().value); // .
+                self.advance(); // .
+                decl.sig.name.push_str(keytree::MEMBER_SEP);
                 if self.peek().kind == Kind::Ident {
                     decl.sig.name.push_str(&self.advance().value);
                 }
@@ -550,7 +551,7 @@ impl Parser {
             }
             // kv.set 成员形（3 读：base, key, val）改写 base 的成员目录，命中读参即拒绝
             if let Some(e) = &inst.expr {
-                if e.op == "kv.set" && e.args.len() >= 3 {
+                if e.op == "kv·set" && e.args.len() >= 3 {
                     let base = &e.args[0].val;
                     if !base.contains('/') && ro.contains(base) {
                         bad(p, base, fname);
@@ -757,10 +758,10 @@ impl Parser {
                     let arr = s[..br].to_string();
                     let idxs = s[br + 1..s.len().saturating_sub(1)].to_string();
                     let e = inst.expr.take();
-                    // strkeymap 坐标写 m.[i,j] <- v：坐标段是成员名（kv.set 字符串键）。
-                    let dot_coord = arr.ends_with('.');
-                    let arr = arr.trim_end_matches('.').to_string();
-                    let op = if dot_coord { "kv.set" } else if arr.starts_with('/') { "kv.set" } else { "xv.set" };
+                    // strkeymap 坐标写 m·[i,j] <- v：坐标段是成员名（kv.set 字符串键）。
+                    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 { "kv·set" } else if arr.starts_with('/') { "kv·set" } else { "xv·set" };
                     if dot_coord {
                         inst.expr = Some(ast::call(
                             op,
@@ -857,13 +858,13 @@ impl Parser {
                     self.advance(); // consume *
                     if self.peek().kind == Kind::Ident {
                         let key = self.advance().value;
-                        left = ast::call("kv.get", vec![left, ast::leaf(&key)]);
+                        left = ast::call("kv·get", vec![left, ast::leaf(&key)]);
                         continue;
                     }
                 }
                 if self.peek().kind == Kind::Ident || self.peek().kind == Kind::Literal {
                     let field = self.advance().value;
-                    left = ast::call("kv.get", vec![left, ast::str_lit(&field)]);
+                    left = ast::call("kv·get", vec![left, ast::str_lit(&field)]);
                     continue;
                 }
                 // strkeymap 坐标访问 m.[i,j]：坐标段是单个成员名（kv.get 字符串键）。
@@ -883,7 +884,7 @@ impl Parser {
                         "[{}]",
                         idxs.iter().map(|e| e.to_string()).collect::<Vec<_>>().join(",")
                     );
-                    left = ast::call("kv.get", vec![left, ast::str_lit(&coord)]);
+                    left = ast::call("kv·get", vec![left, ast::str_lit(&coord)]);
                     continue;
                 }
             }
@@ -904,7 +905,7 @@ impl Parser {
                 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);
+                left = ast::call(if is_path { "kv·get" } else { "xv·at" }, args);
                 continue;
             }
             let t = self.peek();
@@ -1275,7 +1276,8 @@ impl Parser {
             }
             if (t.kind == Kind::Ident || is_path_literal) && self.peek_at(1).kind == Kind::Dot {
                 let mut w = self.advance().value;
-                w.push_str(&self.advance().value); // .
+                self.advance(); // .
+                w.push_str(keytree::MEMBER_SEP);
                 if self.peek().kind == Kind::Ident && self.peek().value == "*" && self.peek_at(1).kind == Kind::Ident {
                     w.push_str(&self.advance().value); // *
                 }
@@ -1338,9 +1340,13 @@ impl Parser {
                 continue;
             }
             let is_path_lit = t.kind == Kind::Literal && !t.value.is_empty() && t.value.as_bytes()[0] == b'/';
-            if (t.kind == Kind::Ident || is_path_lit) && self.peek_at(1).kind == Kind::Dot {
+            if (t.kind == Kind::Ident || is_path_lit)
+                && self.peek_at(1).kind == Kind::Dot
+                && self.peek_at(2).kind != Kind::LBrack
+            {
                 let mut w = self.advance().value;
-                w.push_str(&self.advance().value); // .
+                self.advance(); // .
+                w.push_str(keytree::MEMBER_SEP);
                 if self.peek().kind == Kind::Ident && self.peek().value == "*" && self.peek_at(1).kind == Kind::Ident {
                     w.push_str(&self.advance().value); // *
                 }
@@ -1368,7 +1374,8 @@ impl Parser {
             }
             if t.kind == Kind::Ident && self.peek_at(1).kind == Kind::Dot && self.peek_at(2).kind == Kind::LBrack {
                 let mut w = self.advance().value; // base
-                w.push_str(&self.advance().value); // .
+                self.advance(); // .
+                w.push_str(keytree::MEMBER_SEP);
                 w.push_str(&self.advance().value); // [
                 let mut depth = 1i32;
                 while depth > 0 && self.peek().kind != Kind::EOF && self.peek().kind != Kind::Arrow {
@@ -1398,7 +1405,7 @@ impl Parser {
         let s = inst.writes[0].clone();
         let dt = s.find(keytree::MEMBER_SEP).unwrap_or(s.len());
         let base = s[..dt].to_string();
-        let field = s[dt + 1..].to_string();
+        let field = s[dt + keytree::MEMBER_SEP.len()..].to_string();
         let key = if field.starts_with('*') {
             if field.len() == 1 {
                 let t = self.peek();
@@ -1419,7 +1426,7 @@ impl Parser {
         };
         let e = inst.expr.take();
         // base.key = v 脱糖为 kv.set(base, key, val)：kv.set 是 void（副作用写成员），无写槽
-        inst.expr = Some(ast::call("kv.set", vec![ast::leaf(&base), key, e.unwrap_or(ast::leaf(""))]));
+        inst.expr = Some(ast::call("kv·set", vec![ast::leaf(&base), key, e.unwrap_or(ast::leaf(""))]));
         inst.writes = Vec::new();
         inst.write_types = Vec::new();
     }
diff --git a/layout/src/scanner.rs b/layout/src/scanner.rs
index ff03716c..eda83a3f 100644
--- a/layout/src/scanner.rs
+++ b/layout/src/scanner.rs
@@ -2,7 +2,7 @@
 
 use std::fmt;
 
-use super::symbol;
+use super::{keytree, symbol};
 
 #[derive(Clone, Copy)]
 pub struct Pos {
@@ -140,7 +140,6 @@ fn single_char_token(c: u8) -> Option<Kind> {
         b'}' => Kind::RBrace,
         b'[' => Kind::LBrack,
         b']' => Kind::RBrack,
-        b'.' => Kind::Dot,
         b':' => Kind::Colon,
         _ => return None,
     })
@@ -216,7 +215,8 @@ fn is_token_delim(c: u8) -> bool {
             | b'}'
             | b'['
             | b']'
-            | b'.'
+            | b'.' // 小数点：仅数字字面量内合法，其余位置作分隔（不产 token）
+            | 0xC2 // ·（U+00B7）成员分隔符首字节
             | b'+'
             | b'-'
             | b'*'
@@ -400,7 +400,7 @@ pub fn scan(src: &str) -> Vec<Token> {
             if i + 1 < src.len() && is_abs_path_start(src[i + 1]) {
                 let start = i;
                 i += 1;
-                while i < src.len() && (!is_token_delim(src[i]) || src[i] == b'.') {
+                while i < src.len() && !is_token_delim(src[i]) {
                     i += 1;
                 }
                 tokens.push(Token {
@@ -416,6 +416,14 @@ pub fn scan(src: &str) -> Vec<Token> {
             continue;
         }
 
+        // 成员分隔符 ·（U+00B7，2 字节）
+        if c == 0xC2 && i + 1 < src.len() && src[i + 1] == 0xB7 {
+            tokens.push(Token { kind: Kind::Dot, value: "·".to_string(), pos: p, quote: 0 });
+            i += 2;
+            prev_newline = false;
+            continue;
+        }
+
         // 单字符标点
         if let Some(k) = single_char_token(c) {
             tokens.push(Token { kind: k, value: (c as char).to_string(), pos: p, quote: 0 });
diff --git a/layout/src/symbol.rs b/layout/src/symbol.rs
index 9fbac55b..e2058ae3 100644
--- a/layout/src/symbol.rs
+++ b/layout/src/symbol.rs
@@ -41,7 +41,7 @@ static ENTRIES: &[Entry] = &[
     Entry { word: "rbrack", glyphs: &["]"], precedence: 0, arith: false, cmp: false, unary: false },
     Entry { word: "comma", glyphs: &[","], precedence: 0, arith: false, cmp: false, unary: false },
     Entry { word: "semicolon", glyphs: &[";"], precedence: 0, arith: false, cmp: false, unary: false },
-    Entry { word: "dot", glyphs: &["."], precedence: 0, arith: false, cmp: false, unary: false },
+    Entry { word: "dot", glyphs: &["·"], precedence: 0, arith: false, cmp: false, unary: false },
     Entry { word: "colon", glyphs: &[":"], precedence: 0, arith: false, cmp: false, unary: false },
     // 箭头 / 赋值（= 兼作 copy opcode）
     Entry { word: "assign", glyphs: &["<-", "->", "="], precedence: 0, arith: false, cmp: false, unary: false },
diff --git a/layout/tests/pipeline_test.rs b/layout/tests/pipeline_test.rs
index 6f20af4a..7528b46e 100644
--- a/layout/tests/pipeline_test.rs
+++ b/layout/tests/pipeline_test.rs
@@ -41,10 +41,10 @@ fn compile_simple_func() {
     assert!(kvkind::is_ptr(&c));
     assert_eq!(kvkind::ptr_target(&c), "[0,1]");
 
-    // 指令（特化后 opcode = int64.add）
+    // 指令（特化后 opcode = int64·add）
     let op = kv.get_one("/lib/sum/[1,0]");
     assert_eq!(kvkind::kind(&op), "rwir|rwfunc");
-    assert_eq!(sig(&op), "int64.add");
+    assert_eq!(sig(&op), "int64·add");
     assert_eq!(sig(&kv.get_one("/lib/sum/[1,-1]")), "A");
     assert_eq!(sig(&kv.get_one("/lib/sum/[1,-2]")), "B");
     assert_eq!(sig(&kv.get_one("/lib/sum/[1,1]")), "C");
@@ -60,12 +60,12 @@ fn compile_string_literal_and_lib() {
     let src = "lib p { rwfunc hi() -> () {\n    \"hello\" -> _\n} }\n";
     compile(&mut kv, src).unwrap();
 
-    // 函数在 /lib/p.hi/ 下（lib 块 pkg 前缀）
-    let sig_val = kv.get_one("/lib/p.hi/[0,0]");
+    // 函数在 /lib/p·hi/ 下（lib 块 pkg 前缀）
+    let sig_val = kv.get_one("/lib/p·hi/[0,0]");
     assert_eq!(kvkind::kind(&sig_val), "defrwfunc");
 
     // 字符串字面量读槽 → char/utf32（UTF-32 LE 码点）
-    let r = kv.get_one("/lib/p.hi/[1,-1]");
+    let r = kv.get_one("/lib/p·hi/[1,-1]");
     assert_eq!(kvkind::kind(&r), "char/utf32");
     let b = body(&r);
     let s: String = b
@@ -81,7 +81,7 @@ fn compile_multiline_string_literal() {
     let src = "lib m { rwfunc ml() -> () {\n    \"\"\"hello\nworld\"\"\" -> _\n} }\n";
     compile(&mut kv, src).unwrap();
 
-    let r = kv.get_one("/lib/m.ml/[1,-1]");
+    let r = kv.get_one("/lib/m·ml/[1,-1]");
     assert_eq!(kvkind::kind(&r), "char/utf32");
     let b = body(&r);
     let s: String = b
diff --git a/layout/tests/redis_roundtrip_test.rs b/layout/tests/redis_roundtrip_test.rs
index d6704ab0..d6d87db2 100644
--- a/layout/tests/redis_roundtrip_test.rs
+++ b/layout/tests/redis_roundtrip_test.rs
@@ -42,5 +42,5 @@ fn redis_compile() {
 
     let op = kv.get_one("/lib/sum/[1,0]");
     assert_eq!(kvkind::kind(&op), "rwir|rwfunc");
-    assert_eq!(String::from_utf8_lossy(&body(&op)[4..]), "int64.add");
+    assert_eq!(String::from_utf8_lossy(&body(&op)[4..]), "int64·add");
 }
diff --git a/runtime/src/builtin.c b/runtime/src/builtin.c
index 0eb93d57..c8e9d8b4 100644
--- a/runtime/src/builtin.c
+++ b/runtime/src/builtin.c
@@ -589,28 +589,28 @@ static const struct { const char *op; kvlangBuiltinFn fn; } builtins[] = {
     {"char/utf32", kvlangBuiltinCastChar32}, {"char/utf8", kvlangBuiltinCastChar8}, {"char/ascii", kvlangBuiltinCastCharAscii},
     /* collection */
     {"array", kvlangBuiltinArray},
-    {"array.scatter", kvlangBuiltinScatter}, {"array.compact", kvlangBuiltinCompact},
-    {"array.append", kvlangBuiltinAppend}, {"array.slice", kvlangBuiltinSlice},
+    {"array·scatter", kvlangBuiltinScatter}, {"array·compact", kvlangBuiltinCompact},
+    {"array·append", kvlangBuiltinAppend}, {"array·slice", kvlangBuiltinSlice},
     {"obj", kvlangBuiltinObj}, {"map", kvlangBuiltinMap},
-    {"ndarray.numel", kvlangBuiltinNdarrayNumel}, {"ndarray.dim", kvlangBuiltinNdarrayDim}, {"ndarray.shape", kvlangBuiltinNdarrayShape},
-    {"xv.at", kvlangBuiltinXvAt}, {"xv.set", kvlangBuiltinXvSet}, {"xv.reshape", kvlangBuiltinXvReshape},
-    {"string.set", kvlangBuiltinStringSet}, {"string.char", kvlangBuiltinStringChar}, {"string.ord", kvlangBuiltinStringOrd},
-    {"string.cmp", kvlangBuiltinStringCmp}, {"string.find", kvlangBuiltinStringFind}, {"string.len", kvlangBuiltinStringLen},
-    {"string.slice", kvlangBuiltinStringSlice}, {"string.concat", kvlangBuiltinStringConcat},
-    {"time.now", kvlangBuiltinTimeNow}, {"time.sub", kvlangBuiltinTimeSub}, {"time.add", kvlangBuiltinTimeAdd},
-    {"time/duration.nanos", kvlangBuiltinDurFrom}, {"time/duration.millis", kvlangBuiltinDurFrom},
-    {"time/duration.seconds", kvlangBuiltinDurFrom}, {"time/duration.minutes", kvlangBuiltinDurFrom},
-    {"time/duration.hours", kvlangBuiltinDurFrom},
-    {"time/duration.as_nanos", kvlangBuiltinDurTo}, {"time/duration.as_millis", kvlangBuiltinDurTo},
-    {"time/duration.as_seconds", kvlangBuiltinDurTo}, {"time/duration.as_minutes", kvlangBuiltinDurTo},
-    {"time/duration.as_hours", kvlangBuiltinDurTo},
-    {"time/duration.add", kvlangBuiltinDurArith}, {"time/duration.sub", kvlangBuiltinDurArith},
-    {"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.list", kvlangBuiltinKvList}, {"kv.listlen", kvlangBuiltinKvListLen}, {"kv.listn", kvlangBuiltinKvListN}, {"kv.mkindex", kvlangBuiltinKvMkindex},
-    {"kv.extindex", kvlangBuiltinKvExtIndex}, {"kv.rmindexext", kvlangBuiltinKvRmIndexExt}, {"kv.watch", kvlangBuiltinKvWatch},
+    {"ndarray·numel", kvlangBuiltinNdarrayNumel}, {"ndarray·dim", kvlangBuiltinNdarrayDim}, {"ndarray·shape", kvlangBuiltinNdarrayShape},
+    {"xv·at", kvlangBuiltinXvAt}, {"xv·set", kvlangBuiltinXvSet}, {"xv·reshape", kvlangBuiltinXvReshape},
+    {"string·set", kvlangBuiltinStringSet}, {"string·char", kvlangBuiltinStringChar}, {"string·ord", kvlangBuiltinStringOrd},
+    {"string·cmp", kvlangBuiltinStringCmp}, {"string·find", kvlangBuiltinStringFind}, {"string·len", kvlangBuiltinStringLen},
+    {"string·slice", kvlangBuiltinStringSlice}, {"string·concat", kvlangBuiltinStringConcat},
+    {"time·now", kvlangBuiltinTimeNow}, {"time·sub", kvlangBuiltinTimeSub}, {"time·add", kvlangBuiltinTimeAdd},
+    {"time/duration·nanos", kvlangBuiltinDurFrom}, {"time/duration·millis", kvlangBuiltinDurFrom},
+    {"time/duration·seconds", kvlangBuiltinDurFrom}, {"time/duration·minutes", kvlangBuiltinDurFrom},
+    {"time/duration·hours", kvlangBuiltinDurFrom},
+    {"time/duration·as_nanos", kvlangBuiltinDurTo}, {"time/duration·as_millis", kvlangBuiltinDurTo},
+    {"time/duration·as_seconds", kvlangBuiltinDurTo}, {"time/duration·as_minutes", kvlangBuiltinDurTo},
+    {"time/duration·as_hours", kvlangBuiltinDurTo},
+    {"time/duration·add", kvlangBuiltinDurArith}, {"time/duration·sub", kvlangBuiltinDurArith},
+    {"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·list", kvlangBuiltinKvList}, {"kv·listlen", kvlangBuiltinKvListLen}, {"kv·listn", kvlangBuiltinKvListN}, {"kv·mkindex", kvlangBuiltinKvMkindex},
+    {"kv·extindex", kvlangBuiltinKvExtIndex}, {"kv·rmindexext", kvlangBuiltinKvRmIndexExt}, {"kv·watch", kvlangBuiltinKvWatch},
     {"debugger", kvlangBuiltinDebugger},
 };
 
@@ -621,11 +621,11 @@ static const size_t builtins_n = sizeof(builtins) / sizeof(builtins[0]);
 static const char *NUM_KINDS[] = {"int8", "int16", "int32", "int64", "uint8",
                                   "uint16", "uint32", "uint64", "float32", "float64"};
 static const char *strip_num_kind(const char *op) {
-    const char *dot = strchr(op, '.');
+    const char *dot = strstr(op, MEMBER_SEP);
     if (!dot) return op;
     size_t n = (size_t)(dot - op);
     for (size_t i = 0; i < sizeof(NUM_KINDS) / sizeof(NUM_KINDS[0]); i++)
-        if (strlen(NUM_KINDS[i]) == n && strncmp(op, NUM_KINDS[i], n) == 0) return dot + 1;
+        if (strlen(NUM_KINDS[i]) == n && strncmp(op, NUM_KINDS[i], n) == 0) return dot + MEMBER_SEP_LEN;
     return op;
 }
 
@@ -798,10 +798,10 @@ static int separated_len(kvlangKv_t *kv, const char *base) {
     }
 }
 
-/* 坐标段 key：base.[s0,s1,...]。1 维即 base.[s0]。 */
+/* 坐标段 key：base·[s0,s1,...]。1 维即 base·[s0]。 */
 static char *scatter_key(const char *base, const int64_t *coords, int ncoord) {
     kvlangStrbuf_t b; kvlangStrbufInit(&b);
-    kvlangStrbufPuts(&b, base); kvlangStrbufPutc(&b, '.'); kvlangStrbufPutc(&b, '[');
+    kvlangStrbufPuts(&b, base); kvlangStrbufPuts(&b, MEMBER_SEP); kvlangStrbufPutc(&b, '[');
     for (int i = 0; i < ncoord; i++) {
         if (i) kvlangStrbufPutc(&b, ',');
         kvlangStrbufPrintf(&b, "%lld", (long long)coords[i]);
diff --git a/runtime/src/const.h b/runtime/src/const.h
index c6f7ae9c..2b5693bd 100644
--- a/runtime/src/const.h
+++ b/runtime/src/const.h
@@ -37,7 +37,8 @@
 
 #define PATH_SEP           "/"
 #define DIR_INDEX_SUF      "/"
-#define MEMBER_SEP         "."
+#define MEMBER_SEP         "\xC2\xB7"   /* · U+00B7 中点号：成员分隔符，释放 '.' 供小数 key */
+#define MEMBER_SEP_LEN     2            /* MEMBER_SEP 的 UTF-8 字节数 */
 #define INDEX_VALUE_SEP    "\n"
 #define RUNTIME_MEMBER_SEP "\xE2\x80\xA5"   /* ‥ U+2025 */
 #define EXT_INDEX_HEAD     "\xE2\x80\xA6"   /* … U+2026 */
diff --git a/runtime/src/keytree.c b/runtime/src/keytree.c
index 7a0a5977..7f93cdd5 100644
--- a/runtime/src/keytree.c
+++ b/runtime/src/keytree.c
@@ -57,15 +57,18 @@ char *kvlangKeytreeParentFrame(const char *root) {
 
 char *kvlangKeytreeMember(const char *base, const char *name) {
     size_t bl = strlen(base), nl = strlen(name);
-    char *r = malloc(bl + nl + 2);
-    memcpy(r, base, bl); r[bl] = '.'; memcpy(r + bl + 1, name, nl); r[bl + 1 + nl] = 0;
+    char *r = malloc(bl + nl + MEMBER_SEP_LEN + 1);
+    memcpy(r, base, bl);
+    memcpy(r + bl, MEMBER_SEP, MEMBER_SEP_LEN);
+    memcpy(r + bl + MEMBER_SEP_LEN, name, nl);
+    r[bl + MEMBER_SEP_LEN + nl] = 0;
     return r;
 }
 
 char *kvlangKeytreeLibFunc(const char *pkg, const char *name) {
     kvlangStrbuf_t b; kvlangStrbufInit(&b);
     kvlangStrbufPuts(&b, LIB_ROOT PATH_SEP);
-    if (pkg && pkg[0]) { kvlangStrbufPuts(&b, pkg); kvlangStrbufPutc(&b, '.'); }
+    if (pkg && pkg[0]) { kvlangStrbufPuts(&b, pkg); kvlangStrbufPuts(&b, MEMBER_SEP); }
     kvlangStrbufPuts(&b, name);
     return kvlangStrbufDetach(&b);
 }
diff --git a/runtime/src/kvcpu.c b/runtime/src/kvcpu.c
index 01c84e56..d46c7de1 100644
--- a/runtime/src/kvcpu.c
+++ b/runtime/src/kvcpu.c
@@ -1,5 +1,15 @@
 #include "runtime_internal.h"
 
+/* 找末个成员分隔符（·，多字节），对齐 strrchr('.') 的单字节旧语义。 */
+static const char *rfind_sep(const char *s) {
+    const char *found = NULL, *p = s;
+    while ((p = strstr(p, MEMBER_SEP)) != NULL) {
+        found = p;
+        p += MEMBER_SEP_LEN;
+    }
+    return found;
+}
+
 static int stack_depth(const char *pc) {
     int d = 0;
     for (; *pc; pc++) if (*pc == '[') d++;
@@ -103,7 +113,7 @@ static char *load_def_reads(kvlangKv_t *kv, const char *key, int *out_nr) {
 static char *frame_slot_key(const char *frame_root, const char *slot) {
     if (!slot || !slot[0]) return NULL;
     if (slot[0] == '/') return strdup(slot);
-    if (slot[0] == '.') return NULL;
+    if (strncmp(slot, MEMBER_SEP, MEMBER_SEP_LEN) == 0) return NULL;
     kvlangStrbuf_t b; kvlangStrbufInit(&b);
     char *stk = kvlangKeytreeStack(frame_root);
     kvlangStrbufPuts(&b, stk); free(stk);
@@ -242,12 +252,12 @@ static char *handle_call(kvlangKv_t *kv, const char *pc, kvlangRwirInst_t *inst)
     const char *lp = "/lib/";
     if (strncmp(fn, lp, 5) == 0) {
         const char *rest = fn + 5;
-        const char *dot = strrchr(rest, '.');
-        if (dot) { free(pkg); pkg = strndup(rest, (size_t)(dot - rest)); free(name); name = strdup(dot + 1); }
+        const char *dot = rfind_sep(rest);
+        if (dot) { free(pkg); pkg = strndup(rest, (size_t)(dot - rest)); free(name); name = strdup(dot + MEMBER_SEP_LEN); }
         else { free(name); name = strdup(rest); }
     } else {
-        const char *dot = strrchr(fn, '.');
-        if (dot) { free(pkg); pkg = strndup(fn, (size_t)(dot - fn)); free(name); name = strdup(dot + 1); }
+        const char *dot = rfind_sep(fn);
+        if (dot) { free(pkg); pkg = strndup(fn, (size_t)(dot - fn)); free(name); name = strdup(dot + MEMBER_SEP_LEN); }
     }
     char *func_key = kvlangKeytreeLibFunc(pkg, name);
     kvlangStrbuf_t func_dir; kvlangStrbufInit(&func_dir);
@@ -468,8 +478,8 @@ char *kvlangKvcpuBootstrap(kvlangKv_t *kv, const char *vtid, const char *funcnam
                       const char *const *args, int nargs) {
     char *pkg = strdup("");
     char *name = strdup(funcname);
-    const char *dot = strrchr(funcname, '.');
-    if (dot) { free(pkg); pkg = strndup(funcname, (size_t)(dot - funcname)); free(name); name = strdup(dot + 1); }
+    const char *dot = rfind_sep(funcname);
+    if (dot) { free(pkg); pkg = strndup(funcname, (size_t)(dot - funcname)); free(name); name = strdup(dot + MEMBER_SEP_LEN); }
     char *func_key = kvlangKeytreeLibFunc(pkg, name);
     kvlangStrbuf_t func_dir; kvlangStrbufInit(&func_dir);
     kvlangStrbufPuts(&func_dir, func_key); kvlangStrbufPutc(&func_dir, '/');
diff --git a/runtime/src/rwir.c b/runtime/src/rwir.c
index 3cb4d9a4..a2f87988 100644
--- a/runtime/src/rwir.c
+++ b/runtime/src/rwir.c
@@ -57,7 +57,7 @@ static void scope_prefix_and_base(const char *link_base, kvlangStrbuf_t *sp, kvl
         }
     }
     for (int i = nscopes - 1; i >= 0; i--) {
-        if (sp->len > 0) kvlangStrbufPutc(sp, '.');
+        if (sp->len > 0) kvlangStrbufPuts(sp, MEMBER_SEP);
         kvlangStrbufPuts(sp, scopes[i]);
         free(scopes[i]);
     }
diff --git a/tutorial/01-basics/arith.kv b/tutorial/01-basics/arith.kv
index 0db8cff0..c02e93e6 100644
--- a/tutorial/01-basics/arith.kv
+++ b/tutorial/01-basics/arith.kv
@@ -10,7 +10,7 @@
 #   sqrt: 12.0
 #   sqrt(√): 12.0
 rwfunc main() -> () {
-	t0 <- time.now()
+	t0 <- time·now()
 	10 + 3 -> add_r
 	println("add:", add_r)
 
@@ -38,9 +38,9 @@ rwfunc main() -> () {
 	sqrt_r2 = √(144)  # = 等价于 <-
 	println("sqrt(√):", sqrt_r2)
 
-	t1 <- time.now()
-	delta <- time.sub(t1, t0)
-	ns <- time/duration.as_nanos(delta)
+	t1 <- time·now()
+	delta <- time·sub(t1, t0)
+	ns <- time/duration·as_nanos(delta)
 	println("__bench_ns:", ns)
 }
 
diff --git a/tutorial/01-basics/hello.kv b/tutorial/01-basics/hello.kv
index 51908ad7..2d65c41d 100644
--- a/tutorial/01-basics/hello.kv
+++ b/tutorial/01-basics/hello.kv
@@ -1,11 +1,11 @@
 # 期望输出:
 #   hello kvlang
 rwfunc main() -> () {
-	t0 <- time.now()
+	t0 <- time·now()
 	println("hello kvlang")
-	t1 <- time.now()
-	delta <- time.sub(t1, t0)
-	ns <- time/duration.as_nanos(delta)
+	t1 <- time·now()
+	delta <- time·sub(t1, t0)
+	ns <- time/duration·as_nanos(delta)
 	println("__bench_ns:", ns)
 }
 
diff --git a/tutorial/01-basics/kv_tree.kv b/tutorial/01-basics/kv_tree.kv
index 83c05673..c91944ab 100644
--- a/tutorial/01-basics/kv_tree.kv
+++ b/tutorial/01-basics/kv_tree.kv
@@ -6,23 +6,23 @@
 #   numel= 3 dim= 1
 #   shape0= 3
 rwfunc main() -> () {
-	kv.set("/tmp/kvt.data", 42)
-	kv.get("/tmp/kvt.data") -> v
+	kv·set("/tmp/kvt·data", 42)
+	kv·get("/tmp/kvt·data") -> v
 	println("v=", v)
-	kv.get("/tmp/kvt", "data") != None -> h
+	kv·get("/tmp/kvt", "data") != None -> h
 	println("has_data=", h)
-	kv.get("/tmp/kvt", "data") -> x
+	kv·get("/tmp/kvt", "data") -> x
 	println("x=", x)
-	kv.mkindex("/tmp/kvt/")
-	kv.set("/tmp/kvt/a", 1)
-	kv.set("/tmp/kvt/b", 2)
-	kv.list("/tmp/kvt/") -> names
-	ndarray.numel(names) -> n
+	kv·mkindex("/tmp/kvt/")
+	kv·set("/tmp/kvt/a", 1)
+	kv·set("/tmp/kvt/b", 2)
+	kv·list("/tmp/kvt/") -> names
+	ndarray·numel(names) -> n
 	println("n=", n)
-	ndarray.numel([10,20,30]) -> m
-	ndarray.dim([10,20,30]) -> d
+	ndarray·numel([10,20,30]) -> m
+	ndarray·dim([10,20,30]) -> d
 	println("numel=", m, "dim=", d)
-	ndarray.shape([10,20,30]) -> s
+	ndarray·shape([10,20,30]) -> s
 	println("shape0=", s[0])
 }
 main()
diff --git a/tutorial/01-basics/random.kv b/tutorial/01-basics/random.kv
index 10e72077..f7e62f92 100644
--- a/tutorial/01-basics/random.kv
+++ b/tutorial/01-basics/random.kv
@@ -1,19 +1,19 @@
 # random: 随机数生成（crypto/rand 真随机，非伪随机）
-# 语义: random.uint64() 返回随机 uint64；random.int63() 返回非负 int64（≤ 2^63-1）；
-#       random.intn(n) 返回 [0, n) 的 uint64
+# 语义: random·uint64() 返回随机 uint64；random·int63() 返回非负 int64（≤ 2^63-1）；
+#       random·intn(n) 返回 [0, n) 的 uint64
 # 期望输出:
 #   int63 >= 0: true
 #   intn in [0,100): true
 #   two randoms differ: true
 rwfunc main() -> () {
-	n <- random.int63()
+	n <- random·int63()
 	println("int63 >= 0:", n >= 0)
 
-	m <- random.intn(100)
+	m <- random·intn(100)
 	println("intn in [0,100):", m >= 0 && m < 100)
 
-	a <- random.uint64()
-	b <- random.uint64()
+	a <- random·uint64()
+	b <- random·uint64()
 	println("two randoms differ:", a != b)
 }
 
diff --git a/tutorial/01-basics/strict_types.kv b/tutorial/01-basics/strict_types.kv
index 622cb93e..a4b931bf 100644
--- a/tutorial/01-basics/strict_types.kv
+++ b/tutorial/01-basics/strict_types.kv
@@ -74,7 +74,7 @@ rwfunc main() -> () {
 	println(p)
 
 	# 字符串比较（C 语义）
-	string.cmp("a", "b") -> q
+	string·cmp("a", "b") -> q
 	println(q)
 
 	# bool 显式比较
diff --git a/tutorial/01-basics/strings.kv b/tutorial/01-basics/strings.kv
index 1001eb78..6aa1d41f 100644
--- a/tutorial/01-basics/strings.kv
+++ b/tutorial/01-basics/strings.kv
@@ -24,16 +24,16 @@ rwfunc main() -> () {
 	println(t)
 	s + " " + t -> w
 	println(w)
-	println(string.len(w))
+	println(string·len(w))
 
-	println(string.cmp("abc", "abd"))
-	println(string.cmp("x", "x"))
-	println(string.find(w, "kv"))
-	println(string.find(w, "zz"))
+	println(string·cmp("abc", "abd"))
+	println(string·cmp("x", "x"))
+	println(string·find(w, "kv"))
+	println(string·find(w, "zz"))
 
 	c <- w[3]
 	println(c)
-	println(string.ord(c))
+	println(string·ord(c))
 }
 
 main()
diff --git a/tutorial/01-basics/time.kv b/tutorial/01-basics/time.kv
index 0f88e996..540c2dde 100644
--- a/tutorial/01-basics/time.kv
+++ b/tutorial/01-basics/time.kv
@@ -12,43 +12,43 @@
 #   1 s = 1000000000 ns
 rwfunc main() -> () {
     println("before")
-    t0 <- time.now()
-    t1 <- time.now()
+    t0 <- time·now()
+    t1 <- time·now()
     println("after")
 
-    before <- time.before(t0, t1)
+    before <- time·before(t0, t1)
     print("t0 < t1: ")
     println(before)
 
-    after <- time.after(t0, t1)
+    after <- time·after(t0, t1)
     print("t0 > t1: ")
     println(after)
 
-    delta <- time.sub(t1, t0)
+    delta <- time·sub(t1, t0)
     print("delta >= 0 ns: ")
-    zero = time/duration.nanos(0)  # = 等价于 <-
-    println(time/duration.before(zero, delta))
+    zero = time/duration·nanos(0)  # = 等价于 <-
+    println(time/duration·before(zero, delta))
 
-    ms <- time/duration.as_millis(delta)
+    ms <- time/duration·as_millis(delta)
     print("delta ms = ")
     println(ms)
 
-    s <- time/duration.as_seconds(delta)
+    s <- time/duration·as_seconds(delta)
     print("delta s = ")
     println(s)
 
-    sum <- time.add(t0, delta)
+    sum <- time·add(t0, delta)
     print("t0 + delta == t1: ")
-    a <- not(time.before(sum, t1))
-    b <- not(time.after(sum, t1))
+    a <- not(time·before(sum, t1))
+    b <- not(time·after(sum, t1))
     println(and(a, b))
 
     1000 -> n  # = 等价于 <-
     print(n)
     println(" ms")
 
-    one_sec <- time/duration.seconds(1)
-    ns <- time/duration.as_nanos(one_sec)
+    one_sec <- time/duration·seconds(1)
+    ns <- time/duration·as_nanos(one_sec)
     print("1 s = ")
     print(ns)
     println(" ns")
diff --git a/tutorial/02-func/accumulator.kv b/tutorial/02-func/accumulator.kv
index 9d460752..b347c324 100644
--- a/tutorial/02-func/accumulator.kv
+++ b/tutorial/02-func/accumulator.kv
@@ -7,7 +7,7 @@
 #   10
 #   10
 rwfunc sum(arr:[]int64) -> (acc:int64) {
-	n = ndarray.numel(arr)  # = 等价于 <-
+	n = ndarray·numel(arr)  # = 等价于 <-
 	0 -> acc  # 显式初始化累加器（strict null：write parm 首读为 null，拒绝 null 算术）
 	0 -> i
 	while (i < n) {
@@ -17,7 +17,7 @@ rwfunc sum(arr:[]int64) -> (acc:int64) {
 }
 
 rwfunc rsum(arr:[]int64, i:int64, acc:int64) -> (r:int64) {
-	n <- ndarray.numel(arr)
+	n <- ndarray·numel(arr)
 
 	if (i >= n) {
 		acc -> r
diff --git a/tutorial/03-control/for.kv b/tutorial/03-control/for.kv
index c9de8da1..ecdf34f7 100644
--- a/tutorial/03-control/for.kv
+++ b/tutorial/03-control/for.kv
@@ -5,22 +5,22 @@
 #   0 F = -17.77777777777778 C
 #   300 F = 148.88888888888889 C
 rwfunc main() -> () {
-	data.0 <- 0
-	data.1 = 20  # = 等价于 <-
-	40 -> data.2
-	data.3 <- 60
-	data.4 = 80  # = 等价于 <-
-	100 -> data.5
-	data.6 <- 120
-	data.7 = 140  # = 等价于 <-
-	160 -> data.8
-	data.9 <- 180
-	data.10 = 200  # = 等价于 <-
-	220 -> data.11
-	data.12 <- 240
-	data.13 = 260  # = 等价于 <-
-	280 -> data.14
-	data.15 <- 300
+	data·0 <- 0
+	data·1 = 20  # = 等价于 <-
+	40 -> data·2
+	data·3 <- 60
+	data·4 = 80  # = 等价于 <-
+	100 -> data·5
+	data·6 <- 120
+	data·7 = 140  # = 等价于 <-
+	160 -> data·8
+	data·9 <- 180
+	data·10 = 200  # = 等价于 <-
+	220 -> data·11
+	data·12 <- 240
+	data·13 = 260  # = 等价于 <-
+	280 -> data·14
+	data·15 <- 300
 	for (fahr in data) {
 		factor = 5.0 ÷ 9.0  # = 等价于 <-
 		fahr - 32 -> diff
diff --git a/tutorial/03-control/if.kv b/tutorial/03-control/if.kv
index 8fc3a5cc..e8395efd 100644
--- a/tutorial/03-control/if.kv
+++ b/tutorial/03-control/if.kv
@@ -11,11 +11,11 @@ lib my {
     }
 }
 
-a = my.abs(-5)  # = 等价于 <-
+a = my·abs(-5)  # = 等价于 <-
 println("abs(-5) =", a)
-my.abs(3) -> b
+my·abs(3) -> b
 println("abs(3) =", b)
-c <- my.abs(-10)
+c <- my·abs(-10)
 println("abs(-10) =", c)
 d = b >= 90  # = 等价于 <-
 d_m = b ≥ 90  # = 等价于 <-
diff --git a/tutorial/04-ndarray/continuous.kv b/tutorial/04-ndarray/continuous.kv
index d6f01753..694da1b3 100644
--- a/tutorial/04-ndarray/continuous.kv
+++ b/tutorial/04-ndarray/continuous.kv
@@ -7,7 +7,7 @@
 #   sum = 179
 rwfunc main() -> () {
 	a:[]int64 = [10, 20, 30, 40]
-	ndarray.numel(a) -> n
+	ndarray·numel(a) -> n
 	println("len =", n)
 	v0 <- a[0]
 	println("[0] =", v0)
diff --git a/tutorial/04-ndarray/geo_coord.kv b/tutorial/04-ndarray/geo_coord.kv
new file mode 100644
index 00000000..ebeb22b0
--- /dev/null
+++ b/tutorial/04-ndarray/geo_coord.kv
@@ -0,0 +1,14 @@
+# 经纬度坐标：二维散 key 数组，坐标段 [lat,lng] 带小数点
+# 语义: 成员分隔符是 ·（middot），小数点仍是 .（dot）；geo·[39.9,116.4] 是带小数的数组 key
+# 期望输出:
+#   [39.9,116.4] -> Beijing
+#   [31.23,121.47] -> Shanghai
+rwfunc main() -> () {
+	geo·[39.9,116.4] <- "Beijing"
+	geo·[31.23,121.47] <- "Shanghai"
+	geo·[39.9,116.4] -> bj
+	geo·[31.23,121.47] -> sh
+	println("[39.9,116.4] ->", bj)
+	println("[31.23,121.47] ->", sh)
+}
+main()
diff --git a/tutorial/04-ndarray/map_coord.kv b/tutorial/04-ndarray/map_coord.kv
index 09fa3816..c802b4a9 100644
--- a/tutorial/04-ndarray/map_coord.kv
+++ b/tutorial/04-ndarray/map_coord.kv
@@ -1,12 +1,12 @@
-# strkeymap_coord: strkeymapindex 坐标段访问 a.[i]
-# 语义: {..} 创建 1 维散 key map，成员名是坐标段 "[i]"，a.[i] 走 kv.get
+# strkeymap_coord: strkeymapindex 坐标段访问 a·[i]
+# 语义: {..} 创建 1 维散 key map，成员名是坐标段 "[i]"，a·[i] 走 kv·get
 # 期望输出:
 #   a[0] = 10
 #   a[2] = 30
 rwfunc main() -> () {
 	a = {10, 20, 30}
-	a.[0] -> v0
-	a.[2] -> v2
+	a·[0] -> v0
+	a·[2] -> v2
 	println("a[0] =", v0)
 	println("a[2] =", v2)
 }
diff --git a/tutorial/04-ndarray/separated.kv b/tutorial/04-ndarray/separated.kv
index b8c27c2a..e95a81a7 100644
--- a/tutorial/04-ndarray/separated.kv
+++ b/tutorial/04-ndarray/separated.kv
@@ -1,22 +1,22 @@
-# 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）
+# 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）
 # 期望输出:
-#   ndarray.numel(b) = 3
+#   ndarray·numel(b) = 3
 #   b[0] = 10
 #   b[2] = 30
-#   ndarray.numel(c) = 3
+#   ndarray·numel(c) = 3
 #   c[0] = 10
 rwfunc main() -> () {
 	a:[]int64 = [10, 20, 30]       # 字面量初始化 → compact
-	b <- array.scatter(a)          # 显式 scatter：compact a → 散 key b（b.[0]..b.[2]）
-	ndarray.numel(b) -> n1
-	println("ndarray.numel(b) =", n1)
-	println("b[0] =", b.[0])       # 散 key 元素访问 .[i]
-	println("b[2] =", b.[2])
-	c <- array.compact(b)          # 显式 compact：散 key b → compact c
-	ndarray.numel(c) -> n2
-	println("ndarray.numel(c) =", n2)
+	b <- array·scatter(a)          # 显式 scatter：compact a → 散 key b（b·[0]..b·[2]）
+	ndarray·numel(b) -> n1
+	println("ndarray·numel(b) =", n1)
+	println("b[0] =", b·[0])       # 散 key 元素访问 ·[i]
+	println("b[2] =", b·[2])
+	c <- array·compact(b)          # 显式 compact：散 key b → compact c
+	ndarray·numel(c) -> n2
+	println("ndarray·numel(c) =", n2)
 	println("c[0] =", c[0])        # compact 元素访问 [i]
 }
 
diff --git a/tutorial/04-ndarray/sparse_literal.kv b/tutorial/04-ndarray/sparse_literal.kv
index ec4db61f..a0e88a48 100644
--- a/tutorial/04-ndarray/sparse_literal.kv
+++ b/tutorial/04-ndarray/sparse_literal.kv
@@ -1,4 +1,4 @@
-# sparse_literal: 花括号 {..} 字面量 = 散 key 数组（每元素落 base.i 独立 key）
+# sparse_literal: 花括号 {..} 字面量 = 散 key 数组（每元素落 base·i 独立 key）
 # 括号规约: [1,2,3] = compact 定长打包进单 XValue；{1,2,3} = 散 key，变长/可增长
 # 语义: {..} 只作赋值右值或 for-in 源；for (x in nums) 遍历散 key 元素
 # 期望输出:
diff --git a/tutorial/04-ndarray/xv_shape.kv b/tutorial/04-ndarray/xv_shape.kv
index 14b0167d..abf7c489 100644
--- a/tutorial/04-ndarray/xv_shape.kv
+++ b/tutorial/04-ndarray/xv_shape.kv
@@ -5,14 +5,14 @@
 #   set1= 99
 rwfunc main() -> () {
 	a:[]int64 = [10, 20, 30, 40]
-	ndarray.numel(a) -> n
-	ndarray.dim(a) -> d
+	ndarray·numel(a) -> n
+	ndarray·dim(a) -> d
 	println("numel=", n, "dim=", d)
-	ndarray.shape(a) -> s
+	ndarray·shape(a) -> s
 	println("shape0=", s[0])
-	xv.at(a, 1) -> e
+	xv·at(a, 1) -> e
 	println("at1=", e)
-	xv.set(a, 1, 99) -> a
+	xv·set(a, 1, 99) -> a
 	println("set1=", a[1])
 }
 main()
diff --git a/tutorial/05-dict/kv_has_string_key.kv b/tutorial/05-dict/kv_has_string_key.kv
index 6d281eaf..b8928b9b 100644
--- a/tutorial/05-dict/kv_has_string_key.kv
+++ b/tutorial/05-dict/kv_has_string_key.kv
@@ -1,8 +1,8 @@
 # 期望输出
 #   true
 rwfunc main() -> () {
-	/tmp/kvhas_test.data = 42
-	kv.get(/tmp/kvhas_test, "data") != None -> ok
+	/tmp/kvhas_test·data = 42
+	kv·get(/tmp/kvhas_test, "data") != None -> ok
 	println(ok)
 }
 main()
diff --git a/tutorial/05-dict/literal.kv b/tutorial/05-dict/literal.kv
index 775ff3b3..b8c10cff 100644
--- a/tutorial/05-dict/literal.kv
+++ b/tutorial/05-dict/literal.kv
@@ -1,16 +1,16 @@
 # literal: 字典字面量与成员访问
-# 语义: { k=v; ... } 创建 dict 目录；base.key 成员访问；has 检查存在性
+# 语义: { k=v; ... } 创建 dict 目录；base·key 成员访问；has 检查存在性
 # 期望输出:
-#   h.x = 1
-#   h.z = 42
+#   h·x = 1
+#   h·z = 42
 #   has x: true
 rwfunc main() -> () {
 	h = {x=1; y=2}
-	h.x -> v
-	println("h.x =", v)
-	42 -> h.z
-	println("h.z =", h.z)
-	kv.get(h, "x") != None -> ok
+	h·x -> v
+	println("h·x =", v)
+	42 -> h·z
+	println("h·z =", h·z)
+	kv·get(h, "x") != None -> ok
 	println("has x:", ok)
 }
 
diff --git a/tutorial/06-algo/factorial.kv b/tutorial/06-algo/factorial.kv
index d629dda8..d39a6c5e 100644
--- a/tutorial/06-algo/factorial.kv
+++ b/tutorial/06-algo/factorial.kv
@@ -11,10 +11,10 @@ rwfunc factorial(n:int64) -> (result:int64) {
 	}
 }
 
-t0 <- time.now()
+t0 <- time·now()
 ans <- factorial(10)
-t1 <- time.now()
+t1 <- time·now()
 println("fact =", ans)
-delta <- time.sub(t1, t0)
-ns <- time/duration.as_nanos(delta)
+delta <- time·sub(t1, t0)
+ns <- time/duration·as_nanos(delta)
 println("__bench_ns:", ns)
diff --git a/tutorial/06-algo/fibonacci.kv b/tutorial/06-algo/fibonacci.kv
index 81c5b5c4..28a8ca53 100644
--- a/tutorial/06-algo/fibonacci.kv
+++ b/tutorial/06-algo/fibonacci.kv
@@ -19,10 +19,10 @@ rwfunc fibonacci(n:int64) -> (result:int64) {
 	}
 }
 
-t0 <- time.now()
+t0 <- time·now()
 fibonacci(10) -> ans
-t1 <- time.now()
+t1 <- time·now()
 println("fib =", ans)
-delta <- time.sub(t1, t0)
-ns <- time/duration.as_nanos(delta)
+delta <- time·sub(t1, t0)
+ns <- time/duration·as_nanos(delta)
 println("__bench_ns:", ns)
diff --git a/tutorial/06-algo/gcd.kv b/tutorial/06-algo/gcd.kv
index 16cf5843..64eb0a57 100644
--- a/tutorial/06-algo/gcd.kv
+++ b/tutorial/06-algo/gcd.kv
@@ -11,10 +11,10 @@ rwfunc gcd(A:int64, B:int64) -> (R:int64) {
 	}
 }
 
-t0 <- time.now()
+t0 <- time·now()
 gcd(48, 18) -> ans
-t1 <- time.now()
+t1 <- time·now()
 println("gcd =", ans)
-delta <- time.sub(t1, t0)
-ns <- time/duration.as_nanos(delta)
+delta <- time·sub(t1, t0)
+ns <- time/duration·as_nanos(delta)
 println("__bench_ns:", ns)
diff --git a/tutorial/06-algo/map_reduce.kv b/tutorial/06-algo/map_reduce.kv
index 509f7c2e..f9003ff1 100644
--- a/tutorial/06-algo/map_reduce.kv
+++ b/tutorial/06-algo/map_reduce.kv
@@ -4,16 +4,16 @@
 #   odd squares count: 5
 #   sum of squares: 165
 rwfunc main() -> () {
-	nums.0 = 1  # = 等价于 <-
-	3 -> nums.1
-	nums.2 <- 5
-	nums.3 = 7  # = 等价于 <-
-	9 -> nums.4
-	nums.5 <- 2
-	nums.6 = 4  # = 等价于 <-
-	6 -> nums.7
-	nums.8 <- 8
-	nums.9 = 10  # = 等价于 <-
+	nums·0 = 1  # = 等价于 <-
+	3 -> nums·1
+	nums·2 <- 5
+	nums·3 = 7  # = 等价于 <-
+	9 -> nums·4
+	nums·5 <- 2
+	nums·6 = 4  # = 等价于 <-
+	6 -> nums·7
+	nums·8 <- 8
+	nums·9 = 10  # = 等价于 <-
 	0 -> count
 	total <- 0
 	for (n in nums) {
diff --git a/tutorial/06-algo/prime_sieve.kv b/tutorial/06-algo/prime_sieve.kv
index 9a4e2945..93e0c4c8 100644
--- a/tutorial/06-algo/prime_sieve.kv
+++ b/tutorial/06-algo/prime_sieve.kv
@@ -33,9 +33,9 @@ rwfunc prime_sieve(limit:int64) -> () {
 	println("total primes up to", limit, "=", count)
 }
 
-t0 <- time.now()
+t0 <- time·now()
 prime_sieve(200)
-t1 <- time.now()
-delta <- time.sub(t1, t0)
-ns <- time/duration.as_nanos(delta)
+t1 <- time·now()
+delta <- time·sub(t1, t0)
+ns <- time/duration·as_nanos(delta)
 println("__bench_ns:", ns)
diff --git a/tutorial/06-algo/word_count.kv b/tutorial/06-algo/word_count.kv
index 91ecb011..106c9292 100644
--- a/tutorial/06-algo/word_count.kv
+++ b/tutorial/06-algo/word_count.kv
@@ -3,24 +3,24 @@
 # 期望输出:
 #   word count = 3
 rwfunc main() -> () {
-	chars.0 = "h"  # = 等价于 <-
-	"e" -> chars.1
-	chars.2 <- "l"
-	chars.3 = "l"  # = 等价于 <-
-	"o" -> chars.4
-	chars.5 <- " "
-	chars.6 = "w"  # = 等价于 <-
-	"o" -> chars.7
-	chars.8 <- "r"
-	chars.9 = "l"  # = 等价于 <-
-	"d" -> chars.10
-	chars.11 <- " "
-	chars.12 = "k"  # = 等价于 <-
-	"v" -> chars.13
-	chars.14 <- "l"
-	chars.15 = "a"  # = 等价于 <-
-	"n" -> chars.16
-	chars.17 <- "g"
+	chars·0 = "h"  # = 等价于 <-
+	"e" -> chars·1
+	chars·2 <- "l"
+	chars·3 = "l"  # = 等价于 <-
+	"o" -> chars·4
+	chars·5 <- " "
+	chars·6 = "w"  # = 等价于 <-
+	"o" -> chars·7
+	chars·8 <- "r"
+	chars·9 = "l"  # = 等价于 <-
+	"d" -> chars·10
+	chars·11 <- " "
+	chars·12 = "k"  # = 等价于 <-
+	"v" -> chars·13
+	chars·14 <- "l"
+	chars·15 = "a"  # = 等价于 <-
+	"n" -> chars·16
+	chars·17 <- "g"
 	nw = 0  # = 等价于 <-
 	0 -> state
 	for (c in chars) {
diff --git a/tutorial/07-lib/cross/inline.kv b/tutorial/07-lib/cross/inline.kv
index 17d103da..a41a96fc 100644
--- a/tutorial/07-lib/cross/inline.kv
+++ b/tutorial/07-lib/cross/inline.kv
@@ -5,6 +5,6 @@ lib math {
     rwfunc sum(A:int64, B:int64) -> (C:int64) { A + B -> C }
 }
 rwfunc init() -> () {
-    /lib/math.sum(3, 4) -> s
+    /lib/math·sum(3, 4) -> s
     println(s)
 }
diff --git a/tutorial/07-lib/cross/lib_b.kv b/tutorial/07-lib/cross/lib_b.kv
index 55d47c19..ca097ea4 100644
--- a/tutorial/07-lib/cross/lib_b.kv
+++ b/tutorial/07-lib/cross/lib_b.kv
@@ -1,7 +1,7 @@
-# 运行: kvlang loadandrun lib_a.kv lib_b.kv
+# 运行: kvlang loadandrun lib_a·kv lib_b·kv
 lib calc {
     rwfunc init() -> () {
-        /lib/math.sum(3, 4) -> s
+        /lib/math·sum(3, 4) -> s
         println(s)
     }
 }
diff --git a/tutorial/07-lib/inline_lib.kv b/tutorial/07-lib/inline_lib.kv
index 9d517536..5e8a326b 100644
--- a/tutorial/07-lib/inline_lib.kv
+++ b/tutorial/07-lib/inline_lib.kv
@@ -1,6 +1,6 @@
 # 期望输出:
-#   mylib.add(10,20) = 30
-#   double(mylib.add(10,20)) = 60
+#   mylib·add(10,20) = 30
+#   double(mylib·add(10,20)) = 60
 lib mylib {
 	rwfunc add(A:int64, B:int64) -> (C:int64) {
 		A + B -> C
@@ -13,10 +13,10 @@ rwfunc double(x:int64) -> (y:int64) {
 }
 
 rwfunc main() -> () {
-	a = mylib.add(10, 20)  # = 等价于 <-
-	println("mylib.add(10,20) =", a)
+	a = mylib·add(10, 20)  # = 等价于 <-
+	println("mylib·add(10,20) =", a)
 	double(a) -> b
-	println("double(mylib.add(10,20)) =", b)
+	println("double(mylib·add(10,20)) =", b)
 }
 
 main()
diff --git a/tutorial/07-lib/multi/lib_b.kv b/tutorial/07-lib/multi/lib_b.kv
index cc131b58..870e3252 100644
--- a/tutorial/07-lib/multi/lib_b.kv
+++ b/tutorial/07-lib/multi/lib_b.kv
@@ -1,4 +1,4 @@
-# 运行: kvlang loadandrun lib_a.kv lib_b.kv
+# 运行: kvlang loadandrun lib_a·kv lib_b·kv
 lib math {
     rwfunc twice(A:int64) -> (R:int64) { A × 2 -> R }
     rwfunc twice(A:int64) -> (R:int64) { A × 2 -> R_m }
diff --git a/tutorial/07-lib/single/inline.kv b/tutorial/07-lib/single/inline.kv
index b7100908..3a534dce 100644
--- a/tutorial/07-lib/single/inline.kv
+++ b/tutorial/07-lib/single/inline.kv
@@ -4,7 +4,7 @@
 lib math {
     rwfunc sum(A:int64, B:int64) -> (C:int64) { A + B -> C }
     rwfunc init() -> () {
-        math.sum(3, 4) -> s
+        math·sum(3, 4) -> s
         println(s)
     }
 }
diff --git a/tutorial/07-lib/single/lib.kv b/tutorial/07-lib/single/lib.kv
index f0530893..24c0bc5f 100644
--- a/tutorial/07-lib/single/lib.kv
+++ b/tutorial/07-lib/single/lib.kv
@@ -2,7 +2,7 @@
 lib math {
     rwfunc sum(A:int64, B:int64) -> (C:int64) { A + B -> C }
     rwfunc init() -> () {
-        math.sum(3, 4) -> s
+        math·sum(3, 4) -> s
         println(s)
     }
 }
diff --git a/tutorial/08-leetcode/001_two-sum-hash.kv b/tutorial/08-leetcode/001_two-sum-hash.kv
index 6f6c6d7d..b8da8603 100644
--- a/tutorial/08-leetcode/001_two-sum-hash.kv
+++ b/tutorial/08-leetcode/001_two-sum-hash.kv
@@ -1,24 +1,24 @@
-# 001: Two Sum — O(n) hash map (h.*key 动态解引用，has 检存在)
+# 001: Two Sum — O(n) hash map (h·*key 动态解引用，has 检存在)
 # 来源: LeetCode #1
 # 期望输出:
 #   [ 0 , 1 ]
 rwfunc two_sum(nums:[]int64, target:int64) -> () {
-	n <- ndarray.numel(nums)
+	n <- ndarray·numel(nums)
 	i = 0  # = 等价于 <-
 	"/tmp" -> h
 	while (i < n) {
 		x <- nums[i]
 		need = target - x  # = 等价于 <-
-		kv.get(h, need) != None -> exists
+		kv·get(h, need) != None -> exists
 
 		if (exists) {
-			kv.get(h, need) -> j
+			kv·get(h, need) -> j
 			k = j - 1  # = 等价于 <-
 			println("[", k, ",", i, "]")
 			n -> i
 		} else {
 			v <- i + 1
-			_ = kv.set(h, x, v)  # = 等价于 <-
+			_ = kv·set(h, x, v)  # = 等价于 <-
 			i + 1 -> i
 		}
 	}
diff --git a/tutorial/08-leetcode/001_two_sum.kv b/tutorial/08-leetcode/001_two_sum.kv
index be9d267d..d4aaa3b4 100644
--- a/tutorial/08-leetcode/001_two_sum.kv
+++ b/tutorial/08-leetcode/001_two_sum.kv
@@ -4,7 +4,7 @@
 #   [ 0 , 1 ]
 #   [-1, -1]
 rwfunc two_sum(nums:[]int64, target:int64) -> () {
-	n <- ndarray.numel(nums)
+	n <- ndarray·numel(nums)
 	found = 0  # = 等价于 <-
 	0 -> i
 	while (i < n) {
diff --git a/tutorial/08-leetcode/002_add_two_numbers.kv b/tutorial/08-leetcode/002_add_two_numbers.kv
index 0fae91ec..77967a67 100644
--- a/tutorial/08-leetcode/002_add_two_numbers.kv
+++ b/tutorial/08-leetcode/002_add_two_numbers.kv
@@ -24,15 +24,15 @@ rwfunc add(a:[]char/utf32, b:[]char/utf32) -> () {
 		sum <- carry
 
 		if (pa != "") {
-			pa.val -> av
+			pa·val -> av
 			sum + av -> sum
-			pa = pa.next
+			pa = pa·next
 		}
 
 		if (pb != "") {
-			pb.val -> bv
+			pb·val -> bv
 			bv + sum -> sum
-			pb.next -> pb
+			pb·next -> pb
 		}
 
 		digit <- sum % 10
@@ -52,7 +52,7 @@ rwfunc add(a:[]char/utf32, b:[]char/utf32) -> () {
 
 rwfunc main() -> () {
 	build_lists()
-	lc.add("/l1_0", "/l2_0")
+	lc·add("/l1_0", "/l2_0")
 }
 
 main()
diff --git a/tutorial/08-leetcode/003_longest_substring.kv b/tutorial/08-leetcode/003_longest_substring.kv
index 70ec87c3..2c58a2e0 100644
--- a/tutorial/08-leetcode/003_longest_substring.kv
+++ b/tutorial/08-leetcode/003_longest_substring.kv
@@ -5,20 +5,20 @@
 #   1
 #   5
 rwfunc length_of_longest(s:[]char/utf32) -> (max_len:int64) {
-	n <- string.len(s)
+	n <- string·len(s)
 	last = {}  # = 等价于 <-
 	max_len = 0  # = 等价于 <-
 	left = 0  # = 等价于 <-
 	right <- 0
 	while (right < n) {
 		s[right] -> c
-		exists <- kv.get(last, c) != None
+		exists <- kv·get(last, c) != None
 		if (exists) {
 			prev = last[c]  # = 等价于 <-
 			cand <- prev + 1
 			if (cand > left) { left <- cand }
 		}
-		_ = kv.set(last, c, right)  # = 等价于 <-
+		_ = kv·set(last, c, right)  # = 等价于 <-
 		cur <- right - left + 1
 		if (cur > max_len) { cur -> max_len }
 		right + 1 -> right
diff --git a/tutorial/08-leetcode/008_string_to_int.kv b/tutorial/08-leetcode/008_string_to_int.kv
index e8d21f94..f20513bd 100644
--- a/tutorial/08-leetcode/008_string_to_int.kv
+++ b/tutorial/08-leetcode/008_string_to_int.kv
@@ -7,14 +7,14 @@
 #   4193
 rwfunc my_atoi(s:[]char/utf32) -> (result:int64) {
 	result = 0  # = 等价于 <-
-	n = string.len(s)  # = 等价于 <-
+	n = string·len(s)  # = 等价于 <-
 	i <- 0
 	sign = 1  # = 等价于 <-
 	if (s[i] == "-") { -1 -> sign ; i + 1 -> i }
 	if (s[i] == "+") { i + 1 -> i }
 	while (i < n) {
 		c2 = s[i]  # = 等价于 <-
-		digit <- string.ord(c2) - 48
+		digit <- string·ord(c2) - 48
 		if (digit >= 0 && digit <= 9) {
 			result = result × 10 + digit  # = 等价于 <-
 			result_m = result × 10 + digit  # = 等价于 <-
diff --git a/tutorial/08-leetcode/011_container_water.kv b/tutorial/08-leetcode/011_container_water.kv
index 94901be3..61f25898 100644
--- a/tutorial/08-leetcode/011_container_water.kv
+++ b/tutorial/08-leetcode/011_container_water.kv
@@ -3,7 +3,7 @@
 # 期望输出:
 #   49
 rwfunc max_area(h:[]int64) -> (mx:int64) {
-	ndarray.numel(h) -> n
+	ndarray·numel(h) -> n
 	l <- 0
 	r = n - 1  # = 等价于 <-
 	0 -> mx
diff --git a/tutorial/08-leetcode/013_roman-to-integer.kv b/tutorial/08-leetcode/013_roman-to-integer.kv
index 223ab010..be5434be 100644
--- a/tutorial/08-leetcode/013_roman-to-integer.kv
+++ b/tutorial/08-leetcode/013_roman-to-integer.kv
@@ -3,7 +3,7 @@
 rwfunc romanToInt(s:[]char/utf32) -> (val:int64) {
 	0 -> val
 	i <- 0
-	n = string.len(s)  # = 等价于 <-
+	n = string·len(s)  # = 等价于 <-
 	"" -> prev
 	while (i < n) {
 		c <- s[i]
diff --git a/tutorial/08-leetcode/013_roman_v2.kv b/tutorial/08-leetcode/013_roman_v2.kv
index 99ec6447..ceee7fc2 100644
--- a/tutorial/08-leetcode/013_roman_v2.kv
+++ b/tutorial/08-leetcode/013_roman_v2.kv
@@ -3,11 +3,11 @@
 # 期望输出:
 #   58
 rwfunc roman_to_int(s:[]char/utf32) -> () {
-	string.len(s) -> n
+	string·len(s) -> n
 	result <- 0
 	i = 0  # = 等价于 <-
 	while (i < n) {
-		string.char(s, i) -> c
+		string·char(s, i) -> c
 		is_I <- c == "I"
 		is_V = c == "V"  # = 等价于 <-
 		c == "X" -> is_X
@@ -21,7 +21,7 @@ rwfunc roman_to_int(s:[]char/utf32) -> () {
 			ni < n -> has_next
 
 			if (has_next) {
-				nc <- string.char(s, ni)
+				nc <- string·char(s, ni)
 				iv = nc == "V"  # = 等价于 <-
 				nc == "X" -> ix
 
diff --git a/tutorial/08-leetcode/014_longest_common.kv b/tutorial/08-leetcode/014_longest_common.kv
index 19fb95d7..cfa2dc5a 100644
--- a/tutorial/08-leetcode/014_longest_common.kv
+++ b/tutorial/08-leetcode/014_longest_common.kv
@@ -6,9 +6,9 @@ rwfunc lcp() -> () {
 	"flower" -> a
 	b <- "flow"
 	c = "flight"  # = 等价于 <-
-	string.len(a) -> na
-	nb <- string.len(b)
-	nc = string.len(c)  # = 等价于 <-
+	string·len(a) -> na
+	nb <- string·len(b)
+	nc = string·len(c)  # = 等价于 <-
 	0 -> i
 	ok <- true
 	while (ok) {
@@ -18,9 +18,9 @@ rwfunc lcp() -> () {
 		all_ok = ca && cb && cc  # = 等价于 <-
 
 		if (all_ok) {
-			string.char(a, i) -> va
-			vb <- string.char(b, i)
-			vc = string.char(c, i)  # = 等价于 <-
+			string·char(a, i) -> va
+			vb <- string·char(b, i)
+			vc = string·char(c, i)  # = 等价于 <-
 			va == vb -> ab
 			bc <- vb == vc
 			match = ab && bc  # = 等价于 <-
@@ -34,7 +34,7 @@ rwfunc lcp() -> () {
 			ok = false  # = 等价于 <-
 		}
 	}
-	string.slice(a, 0, i) -> ans
+	string·slice(a, 0, i) -> ans
 	println(ans)
 }
 
diff --git a/tutorial/08-leetcode/020_valid_parentheses.kv b/tutorial/08-leetcode/020_valid_parentheses.kv
index c8fb2e83..436da919 100644
--- a/tutorial/08-leetcode/020_valid_parentheses.kv
+++ b/tutorial/08-leetcode/020_valid_parentheses.kv
@@ -7,21 +7,21 @@
 rwfunc is_valid(s:[]char/utf32) -> (ok:int64) {
 	ok <- 1
 	si = -1  # = 等价于 <-
-	n = string.len(s)  # = 等价于 <-
+	n = string·len(s)  # = 等价于 <-
 	i <- 0
 	while (i < n) {
 		c = s[i]  # = 等价于 <-
 		if (c == "(") {
 			si + 1 -> si
-			_ <- kv.set("/tmp/vp", si, 1)
+			_ <- kv·set("/tmp/vp", si, 1)
 		}
 		if (c == "[") {
 			si = si + 1  # = 等价于 <-
-			kv.set("/tmp/vp", si, 2) -> _
+			kv·set("/tmp/vp", si, 2) -> _
 		}
 		if (c == "{") {
 			si + 1 -> si
-			_ = kv.set("/tmp/vp", si, 3)  # = 等价于 <-
+			_ = kv·set("/tmp/vp", si, 3)  # = 等价于 <-
 		}
 		if (c == ")") {
 			if (si < 0) { 0 -> ok ; n -> i }
diff --git a/tutorial/08-leetcode/021_merge_two_lists.kv b/tutorial/08-leetcode/021_merge_two_lists.kv
index 06f8443c..fab3dc07 100644
--- a/tutorial/08-leetcode/021_merge_two_lists.kv
+++ b/tutorial/08-leetcode/021_merge_two_lists.kv
@@ -20,30 +20,30 @@ rwfunc merge(a:[]char/utf32, b:[]char/utf32) -> () {
 	pa <- a
 	pb = b  # = 等价于 <-
 	while (pa != "") {
-		pa.val -> av
+		pa·val -> av
 		pick_a <- pb == ""
 
 		if (pick_a) {
 			println(av)
-			pa = pa.next  # = 等价于 <-
+			pa = pa·next  # = 等价于 <-
 		} else {
-			pb.val -> bv
+			pb·val -> bv
 			take <- av <= bv
 			take_m <- av ≤ bv
 
 			if (take) {
 				println(av)
-				pa = pa.next  # = 等价于 <-
+				pa = pa·next  # = 等价于 <-
 			} else {
 				println(bv)
-				pb.next -> pb
+				pb·next -> pb
 			}
 		}
 	}
 	while (pb != "") {
-		bv <- pb.val
+		bv <- pb·val
 		println(bv)
-		pb = pb.next  # = 等价于 <-
+		pb = pb·next  # = 等价于 <-
 	}
 }
 
diff --git a/tutorial/08-leetcode/022_generate_parens.kv b/tutorial/08-leetcode/022_generate_parens.kv
index 606e1558..b674bf68 100644
--- a/tutorial/08-leetcode/022_generate_parens.kv
+++ b/tutorial/08-leetcode/022_generate_parens.kv
@@ -25,7 +25,7 @@ rwfunc generate() -> () {
 			pow ÷ 2 -> pow
 			pow ÷ 2 -> pow_m
 		}
-		if (bal == 0 && ok2 == 1 && string.len(s) == 4) { println(s) }
+		if (bal == 0 && ok2 == 1 && string·len(s) == 4) { println(s) }
 		idx + 1 -> idx
 	}
 }
diff --git a/tutorial/08-leetcode/026_remove_dupes.kv b/tutorial/08-leetcode/026_remove_dupes.kv
index d6f60e0b..02dcc50e 100644
--- a/tutorial/08-leetcode/026_remove_dupes.kv
+++ b/tutorial/08-leetcode/026_remove_dupes.kv
@@ -5,7 +5,7 @@
 #   k = 5
 rwfunc remove_dupes() -> (k:int64) {
     a:[]int64 = [0, 0, 1, 1, 1, 2, 2, 3, 3, 4]
-    ndarray.numel(a) -> n
+    ndarray·numel(a) -> n
     k <- 1
     i = 1  # = 等价于 <-
     while (i < n) {
diff --git a/tutorial/08-leetcode/027_remove_element.kv b/tutorial/08-leetcode/027_remove_element.kv
index ef96ddfa..6508caf6 100644
--- a/tutorial/08-leetcode/027_remove_element.kv
+++ b/tutorial/08-leetcode/027_remove_element.kv
@@ -9,7 +9,7 @@
 rwfunc remove_element() -> () {
 	a:[]int64 = [3, 2, 2, 3]  # = 等价于 <-
 	3 -> val
-	n <- ndarray.numel(a)
+	n <- ndarray·numel(a)
 	k = 0  # = 等价于 <-
 	0 -> i
 	while (i < n) {
diff --git a/tutorial/08-leetcode/028_strstr.kv b/tutorial/08-leetcode/028_strstr.kv
index fd03343e..740abe3f 100644
--- a/tutorial/08-leetcode/028_strstr.kv
+++ b/tutorial/08-leetcode/028_strstr.kv
@@ -4,8 +4,8 @@
 #   2
 #   2
 rwfunc str_str(hay:[]char/utf32, needle:[]char/utf32) -> () {
-	string.len(hay) -> nh
-	nn <- string.len(needle)
+	string·len(hay) -> nh
+	nn <- string·len(needle)
 	i = 0  # = 等价于 <-
 	-1 -> ans
 	limit <- nh - nn
@@ -13,8 +13,8 @@ rwfunc str_str(hay:[]char/utf32, needle:[]char/utf32) -> () {
 		match = true  # = 等价于 <-
 		0 -> j
 		while (j < nn) {
-			hc <- string.char(hay, i + j)
-			nc = string.char(needle, j)  # = 等价于 <-
+			hc <- string·char(hay, i + j)
+			nc = string·char(needle, j)  # = 等价于 <-
 			hc == nc -> eq
 
 			if (eq) {
diff --git a/tutorial/08-leetcode/033_search_rotated.kv b/tutorial/08-leetcode/033_search_rotated.kv
index bf1d851f..845c0852 100644
--- a/tutorial/08-leetcode/033_search_rotated.kv
+++ b/tutorial/08-leetcode/033_search_rotated.kv
@@ -5,7 +5,7 @@
 #   4
 rwfunc search() -> () {
 	a:[]int64 <- [4, 5, 6, 7, 0, 1, 2]
-	n = ndarray.numel(a)  # = 等价于 <-
+	n = ndarray·numel(a)  # = 等价于 <-
 	0 -> target
 	lo <- 0
 	hi = n - 1  # = 等价于 <-
diff --git a/tutorial/08-leetcode/034_search_range.kv b/tutorial/08-leetcode/034_search_range.kv
index 20524142..ad8e0ed3 100644
--- a/tutorial/08-leetcode/034_search_range.kv
+++ b/tutorial/08-leetcode/034_search_range.kv
@@ -5,7 +5,7 @@
 #   [ 3 , 4 ]
 rwfunc search_range() -> () {
 	[5, 7, 7, 8, 8, 10] -> a:[]int64
-	n <- ndarray.numel(a)
+	n <- ndarray·numel(a)
 	target = 8  # = 等价于 <-
 	# find left
 	0 -> lo
diff --git a/tutorial/08-leetcode/035_search_insert.kv b/tutorial/08-leetcode/035_search_insert.kv
index ed9b410a..ec588b92 100644
--- a/tutorial/08-leetcode/035_search_insert.kv
+++ b/tutorial/08-leetcode/035_search_insert.kv
@@ -6,7 +6,7 @@
 rwfunc search_insert() -> () {
 	a:[]int64 = [1, 3, 5, 6]  # = 等价于 <-
 	5 -> target
-	n <- ndarray.numel(a)
+	n <- ndarray·numel(a)
 	lo = 0  # = 等价于 <-
 	n - 1 -> hi
 	pos <- 0
diff --git a/tutorial/08-leetcode/038_count_and_say.kv b/tutorial/08-leetcode/038_count_and_say.kv
index 6a99a338..8f342c09 100644
--- a/tutorial/08-leetcode/038_count_and_say.kv
+++ b/tutorial/08-leetcode/038_count_and_say.kv
@@ -19,8 +19,8 @@ rwfunc next_seq(src_len:int64) -> (dst_len:int64) {
 			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)
+		_ = kv·set("/tmp/s2", di, count)
+		_ = kv·set("/tmp/s2", di+1, cur)
 		di + 2 -> di
 		i + count -> i
 	}
@@ -46,14 +46,14 @@ 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)  # = 等价于 <-
+		_ = kv·set("/tmp/s", i, v)  # = 等价于 <-
 		i + 1 -> i
 	}
 }
 
 rwfunc count_and_say(N:int64) -> () {
-	_ = kv.set("/tmp/s", 0, 1)   # count=1 of digit 1
-	_ = kv.set("/tmp/s", 1, 1)
+	_ = kv·set("/tmp/s", 0, 1)   # count=1 of digit 1
+	_ = kv·set("/tmp/s", 1, 1)
 	cur_len = 2  # = 等价于 <-
 	round = 1  # = 等价于 <-
 	while (round < N) {
diff --git a/tutorial/08-leetcode/053_max_subarray.kv b/tutorial/08-leetcode/053_max_subarray.kv
index b4ece722..b07abcd3 100644
--- a/tutorial/08-leetcode/053_max_subarray.kv
+++ b/tutorial/08-leetcode/053_max_subarray.kv
@@ -5,7 +5,7 @@
 #   6
 rwfunc max_subarray(nums:[]int64) -> () {
 	a:[]int64 <- [-2, 1, -3, 4, -1, 2, 1, -5, 4]
-	n = ndarray.numel(a)  # = 等价于 <-
+	n = ndarray·numel(a)  # = 等价于 <-
 	a[0] -> cur
 	max <- a[0]
 	i = 1  # = 等价于 <-
diff --git a/tutorial/08-leetcode/055_jump_game.kv b/tutorial/08-leetcode/055_jump_game.kv
index 4764cc0c..05045833 100644
--- a/tutorial/08-leetcode/055_jump_game.kv
+++ b/tutorial/08-leetcode/055_jump_game.kv
@@ -5,7 +5,7 @@
 #   false
 rwfunc can_jump(nums:[]int64) -> (ok:int64) {
 	ok = 1  # = 等价于 <-
-	n <- ndarray.numel(nums)
+	n <- ndarray·numel(nums)
 	0 -> reach
 	i = 0  # = 等价于 <-
 	while (i < n) {
diff --git a/tutorial/08-leetcode/056_merge_intervals.kv b/tutorial/08-leetcode/056_merge_intervals.kv
index 20e85223..3c4c7720 100644
--- a/tutorial/08-leetcode/056_merge_intervals.kv
+++ b/tutorial/08-leetcode/056_merge_intervals.kv
@@ -16,8 +16,8 @@ rwfunc bubble_sort(n:int64) -> () {
 				# swap start
 				/tmp/mi[j][1] -> a1
 				/tmp/mi[j+1][1] -> b1
-				_ = kv.set("/tmp/mi", j, [b, b1])  # = 等价于 <-
-				_ = kv.set("/tmp/mi", j+1, [a, a1])  # = 等价于 <-
+				_ = kv·set("/tmp/mi", j, [b, b1])  # = 等价于 <-
+				_ = kv·set("/tmp/mi", j+1, [a, a1])  # = 等价于 <-
 			}
 			j + 1 -> j
 		}
@@ -38,26 +38,26 @@ rwfunc merge(n:int64) -> (m:int64) {
 		nxt[1] -> nxt_end
 		if (cur_end >= nxt_start) {
 			if (nxt_end > cur_end) {
-				_ = kv.set("/tmp/mr", ki, [cur[0], nxt_end])  # = 等价于 <-
+				_ = kv·set("/tmp/mr", ki, [cur[0], nxt_end])  # = 等价于 <-
 				/tmp/mr[ki] -> cur
 			}
 		} else {
-			_ = kv.set("/tmp/mr", ki, cur)
+			_ = kv·set("/tmp/mr", ki, cur)
 			ki = ki + 1  # = 等价于 <-
 			nxt -> cur
 		}
 		idx + 1 -> idx
 	}
-	_ = kv.set("/tmp/mr", ki, cur)
+	_ = kv·set("/tmp/mr", ki, cur)
 	ki + 1 -> m
 }
 
 rwfunc main() -> () {
 	# init intervals in tmp storage
-	_ = 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])
+	_ = 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])
 	cnt <- merge(4)
 	i = 0  # = 等价于 <-
 	while (i < cnt) {
diff --git a/tutorial/08-leetcode/058_length_last_word.kv b/tutorial/08-leetcode/058_length_last_word.kv
index 3c8307f7..595dcd5b 100644
--- a/tutorial/08-leetcode/058_length_last_word.kv
+++ b/tutorial/08-leetcode/058_length_last_word.kv
@@ -3,11 +3,11 @@
 # 期望输出:
 #   5
 rwfunc last_word_len(s:[]char/utf32) -> () {
-	n = string.len(s)  # = 等价于 <-
+	n = string·len(s)  # = 等价于 <-
 	n - 1 -> i
 	count <- 0
 	while (i >= 0) {
-		c = string.char(s, i)  # = 等价于 <-
+		c = string·char(s, i)  # = 等价于 <-
 		c == " " -> sp
 
 		if (sp) {
diff --git a/tutorial/08-leetcode/062_unique_paths.kv b/tutorial/08-leetcode/062_unique_paths.kv
index 23c69bcf..045426f9 100644
--- a/tutorial/08-leetcode/062_unique_paths.kv
+++ b/tutorial/08-leetcode/062_unique_paths.kv
@@ -6,7 +6,7 @@
 rwfunc dp(m:int64, n:int64) -> (result:int64) {
 	i = 0  # = 等价于 <-
 	while (i < n) {
-		_ = kv.set("/tmp/up", i, 1)  # = 等价于 <-
+		_ = kv·set("/tmp/up", i, 1)  # = 等价于 <-
 		i + 1 -> i
 	}
 	j <- 1
@@ -15,7 +15,7 @@ rwfunc dp(m:int64, n:int64) -> (result:int64) {
 		while (k < n) {
 			/tmp/up[k] -> v
 			/tmp/up[k-1] -> prev
-			_ = kv.set("/tmp/up", k, prev + v)  # = 等价于 <-
+			_ = kv·set("/tmp/up", k, prev + v)  # = 等价于 <-
 			k + 1 -> k
 		}
 		j + 1 -> j
diff --git a/tutorial/08-leetcode/066_plus_one.kv b/tutorial/08-leetcode/066_plus_one.kv
index 7474fdcc..c1205a1d 100644
--- a/tutorial/08-leetcode/066_plus_one.kv
+++ b/tutorial/08-leetcode/066_plus_one.kv
@@ -10,7 +10,7 @@
 #   0
 rwfunc plus_one() -> () {
 	a:[]int64 <- [1, 2, 3]
-	n = ndarray.numel(a)  # = 等价于 <-
+	n = ndarray·numel(a)  # = 等价于 <-
 	n - 1 -> i
 	carry <- 1
 	while (i >= 0) {
@@ -41,7 +41,7 @@ rwfunc plus_one() -> () {
 
 rwfunc plus_one_nines() -> () {
 	a:[]int64 = [9, 9, 9]  # = 等价于 <-
-	ndarray.numel(a) -> n
+	ndarray·numel(a) -> n
 	i <- n - 1
 	carry = 1  # = 等价于 <-
 	while (i >= 0) {
diff --git a/tutorial/08-leetcode/067_add_binary.kv b/tutorial/08-leetcode/067_add_binary.kv
index 18fd2201..178d4e86 100644
--- a/tutorial/08-leetcode/067_add_binary.kv
+++ b/tutorial/08-leetcode/067_add_binary.kv
@@ -4,8 +4,8 @@
 #   100
 #   10101
 rwfunc add_binary(a:[]char/utf32, b:[]char/utf32) -> () {
-	na = string.len(a)  # = 等价于 <-
-	nb <- string.len(b)
+	na = string·len(a)  # = 等价于 <-
+	nb <- string·len(b)
 	carry = 0  # = 等价于 <-
 	i = na - 1  # = 等价于 <-
 	j <- nb - 1
diff --git a/tutorial/08-leetcode/075_sort_colors.kv b/tutorial/08-leetcode/075_sort_colors.kv
index be699b6b..63f3854c 100644
--- a/tutorial/08-leetcode/075_sort_colors.kv
+++ b/tutorial/08-leetcode/075_sort_colors.kv
@@ -9,7 +9,7 @@
 #   2
 rwfunc sort_colors() -> () {
 	nums:[]int64 = [2, 0, 2, 1, 1, 0]
-	n = ndarray.numel(nums)  # = 等价于 <-
+	n = ndarray·numel(nums)  # = 等价于 <-
 	lo = 0  # = 等价于 <-
 	mid <- 0
 	hi = n - 1  # = 等价于 <-
diff --git a/tutorial/08-leetcode/083_remove_dup_list.kv b/tutorial/08-leetcode/083_remove_dup_list.kv
index aef12693..a0bfaeb1 100644
--- a/tutorial/08-leetcode/083_remove_dup_list.kv
+++ b/tutorial/08-leetcode/083_remove_dup_list.kv
@@ -20,21 +20,21 @@ rwfunc build() -> () {
 rwfunc dedup(head:[]char/utf32) -> () {
 	head -> cur
 	while (cur != "") {
-		cur.next -> nxt
+		cur·next -> nxt
 		advance = true  # = 等价于 <-
 
 		if (nxt != "") {
-			cur.val -> v
-			nxt.val -> nv
+			cur·val -> v
+			nxt·val -> nv
 
 			if (nv == v) {
-				nxt.next -> nn
-				cur.next <- nn
+				nxt·next -> nn
+				cur·next <- nn
 				false -> advance
 			}
 		}
 		if (advance) {
-			cur.next -> cur
+			cur·next -> cur
 		}
 	}
 }
@@ -42,9 +42,9 @@ rwfunc dedup(head:[]char/utf32) -> () {
 rwfunc show(head:[]char/utf32) -> () {
 	head -> p
 	while (p != "") {
-		p.val -> v
+		p·val -> v
 		println(v)
-		p.next -> p
+		p·next -> p
 	}
 }
 
diff --git a/tutorial/08-leetcode/094_inorder_traversal.kv b/tutorial/08-leetcode/094_inorder_traversal.kv
index 2c9107dc..7d97da56 100644
--- a/tutorial/08-leetcode/094_inorder_traversal.kv
+++ b/tutorial/08-leetcode/094_inorder_traversal.kv
@@ -17,15 +17,15 @@ rwfunc inorder(root:[]char/utf32) -> () {
 	cur <- root
 	while (cur != "" || si > 0) {
 		while (cur != "") {
-			_ = kv.set(stack, si, cur)
+			_ = kv·set(stack, si, cur)
 			si + 1 -> si
-			cur.left -> cur
+			cur·left -> cur
 		}
 		si - 1 -> si
 		stack[si] -> node
-		node.val -> v
+		node·val -> v
 		println(v)
-		node.right -> cur
+		node·right -> cur
 	}
 }
 
diff --git a/tutorial/08-leetcode/100_same_tree.kv b/tutorial/08-leetcode/100_same_tree.kv
index 319b28b2..f0748c97 100644
--- a/tutorial/08-leetcode/100_same_tree.kv
+++ b/tutorial/08-leetcode/100_same_tree.kv
@@ -16,10 +16,10 @@ rwfunc same(a:[]char/utf32, b:[]char/utf32) -> (ok:int64) {
 	if (a == "" || b == "") {
 		if (a == b) { 1 -> ok } else { 0 -> ok }
 	} else {
-		if (a.val == b.val) {
-			same(a.left, b.left) -> ok
+		if (a·val == b·val) {
+			same(a·left, b·left) -> ok
 			if (ok == 1) {
-				same(a.right, b.right) -> ok
+				same(a·right, b·right) -> ok
 			}
 		} else { 0 -> ok }
 	}
diff --git a/tutorial/08-leetcode/104_max_tree_depth.kv b/tutorial/08-leetcode/104_max_tree_depth.kv
index f3f60c70..c4953cab 100644
--- a/tutorial/08-leetcode/104_max_tree_depth.kv
+++ b/tutorial/08-leetcode/104_max_tree_depth.kv
@@ -13,8 +13,8 @@ rwfunc build_tree() -> () {
 rwfunc max_depth(root:[]char/utf32) -> (depth:int64) {
 	if (root == "") { 0 -> depth }
 	else {
-		ld = max_depth(root.left)  # = 等价于 <-
-		rd <- max_depth(root.right)
+		ld = max_depth(root·left)  # = 等价于 <-
+		rd <- max_depth(root·right)
 		if (ld > rd) { ld + 1 -> depth }
 		else { depth <- rd + 1 }
 	}
diff --git a/tutorial/08-leetcode/118_pascal_triangle.kv b/tutorial/08-leetcode/118_pascal_triangle.kv
index d0d8e9c5..573c8902 100644
--- a/tutorial/08-leetcode/118_pascal_triangle.kv
+++ b/tutorial/08-leetcode/118_pascal_triangle.kv
@@ -19,29 +19,29 @@
 #   1
 rwfunc generate(num_rows:int64) -> () {
 	# store prev row in dict
-	_ = kv.set("/tmp/pt", 0, 1)
+	_ = kv·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)
+		_ = kv·set("/tmp/cur", 0, 1)
 		i = 1  # = 等价于 <-
 		while (i < r) {
 			/tmp/pt[i-1] -> a
 			/tmp/pt[i] -> b
 			v <- a + b
 			println(v)
-			_ = kv.set("/tmp/cur", i, v)
+			_ = kv·set("/tmp/cur", i, v)
 			i + 1 -> i
 		}
 		println(1)
-		_ = kv.set("/tmp/cur", r, 1)
+		_ = kv·set("/tmp/cur", r, 1)
 		# copy cur to pt
 		k = 0  # = 等价于 <-
 		while (k <= r) {
 			/tmp/cur[k] -> val
-			_ = kv.set("/tmp/pt", k, val)
+			_ = kv·set("/tmp/pt", k, val)
 			k + 1 -> k
 		}
 		r + 1 -> r
diff --git a/tutorial/08-leetcode/121_buy_sell_stock.kv b/tutorial/08-leetcode/121_buy_sell_stock.kv
index 18957529..9d80afab 100644
--- a/tutorial/08-leetcode/121_buy_sell_stock.kv
+++ b/tutorial/08-leetcode/121_buy_sell_stock.kv
@@ -5,7 +5,7 @@
 #   5
 rwfunc max_profit() -> () {
 	a:[]int64 = [7, 1, 5, 3, 6, 4]  # = 等价于 <-
-	ndarray.numel(a) -> n
+	ndarray·numel(a) -> n
 	min_price <- a[0]
 	max_profit = 0  # = 等价于 <-
 	1 -> i
diff --git a/tutorial/08-leetcode/125_valid_palindrome.kv b/tutorial/08-leetcode/125_valid_palindrome.kv
index fd7a1c7b..362612fb 100644
--- a/tutorial/08-leetcode/125_valid_palindrome.kv
+++ b/tutorial/08-leetcode/125_valid_palindrome.kv
@@ -6,7 +6,7 @@
 # 用整数数组模拟字符串，1='a', 2='b', etc.
 rwfunc is_pal() -> () {
 	s:[]int64 = [1, 2, 1]  # = 等价于 <-
-	ndarray.numel(s) -> n
+	ndarray·numel(s) -> n
 	l <- 0
 	r = n - 1  # = 等价于 <-
 	1 -> ok
@@ -28,7 +28,7 @@ rwfunc is_pal() -> () {
 
 rwfunc not_pal() -> () {
 	s:[]int64 = [1, 2]  # = 等价于 <-
-	ndarray.numel(s) -> n
+	ndarray·numel(s) -> n
 	l <- 0
 	r = n - 1  # = 等价于 <-
 	1 -> ok
diff --git a/tutorial/08-leetcode/125_valid_palindrome_str.kv b/tutorial/08-leetcode/125_valid_palindrome_str.kv
index 7681de51..d9e24c95 100644
--- a/tutorial/08-leetcode/125_valid_palindrome_str.kv
+++ b/tutorial/08-leetcode/125_valid_palindrome_str.kv
@@ -4,13 +4,13 @@
 #   1
 #   0
 rwfunc is_pal(s:[]char/utf32) -> () {
-	n = string.len(s)  # = 等价于 <-
+	n = string·len(s)  # = 等价于 <-
 	0 -> l
 	r <- n - 1
 	ok = 1  # = 等价于 <-
 	while (l < r) {
-		string.char(s, l) -> lc
-		rc <- string.char(s, r)
+		string·char(s, l) -> lc
+		rc <- string·char(s, r)
 		match = lc == rc  # = 等价于 <-
 
 		if (match) {
diff --git a/tutorial/08-leetcode/136_single_number.kv b/tutorial/08-leetcode/136_single_number.kv
index 3e69dafe..6a04fafb 100644
--- a/tutorial/08-leetcode/136_single_number.kv
+++ b/tutorial/08-leetcode/136_single_number.kv
@@ -5,7 +5,7 @@
 #   4
 rwfunc single_number() -> () {
 	a:[]int64 <- [4, 1, 2, 1, 2]
-	n = ndarray.numel(a)  # = 等价于 <-
+	n = ndarray·numel(a)  # = 等价于 <-
 	a[0] -> result
 	i <- 1
 	while (i < n) {
diff --git a/tutorial/08-leetcode/141_linked_list_cycle.kv b/tutorial/08-leetcode/141_linked_list_cycle.kv
index 1c7e0a97..33abca39 100644
--- a/tutorial/08-leetcode/141_linked_list_cycle.kv
+++ b/tutorial/08-leetcode/141_linked_list_cycle.kv
@@ -8,14 +8,14 @@ rwfunc has_cycle(head:[]char/utf32) -> (result:int64) {
 	head -> slow
 	fast <- head
 	while (fast != "") {
-		slow = slow.next  # = 等价于 <-
-		fast.next -> n1
+		slow = slow·next  # = 等价于 <-
+		fast·next -> n1
 		at_end <- n1 == ""
 
 		if (at_end) {
 			fast = ""  # = 等价于 <-
 		} else {
-			n1.next -> fast
+			n1·next -> fast
 			match <- slow == fast
 
 			if (match) {
diff --git a/tutorial/08-leetcode/153_find_min_rotated.kv b/tutorial/08-leetcode/153_find_min_rotated.kv
index 74b09698..cf6af8a4 100644
--- a/tutorial/08-leetcode/153_find_min_rotated.kv
+++ b/tutorial/08-leetcode/153_find_min_rotated.kv
@@ -4,7 +4,7 @@
 #   0
 rwfunc find_min() -> () {
 	a:[]int64 <- [4, 5, 6, 7, 0, 1, 2]
-	n = ndarray.numel(a)  # = 等价于 <-
+	n = ndarray·numel(a)  # = 等价于 <-
 	0 -> lo
 	hi <- n - 1
 	while (lo < hi) {
diff --git a/tutorial/08-leetcode/160_intersection_list.kv b/tutorial/08-leetcode/160_intersection_list.kv
index eef1ce23..4f08e675 100644
--- a/tutorial/08-leetcode/160_intersection_list.kv
+++ b/tutorial/08-leetcode/160_intersection_list.kv
@@ -23,7 +23,7 @@ rwfunc get_intersection(ha:[]char/utf32, hb:[]char/utf32) -> () {
 	switch_a = 0  # = 等价于 <-
 	switch_b <- 0
 	while (pa != pb) {
-		pa.next -> nxt
+		pa·next -> nxt
 		if (nxt == "") {
 			if (switch_a == 0) {
 				hb -> pa
@@ -34,7 +34,7 @@ rwfunc get_intersection(ha:[]char/utf32, hb:[]char/utf32) -> () {
 		} else {
 			nxt -> pa
 		}
-		pb.next -> nxt2
+		pb·next -> nxt2
 		if (nxt2 == "") {
 			if (switch_b == 0) {
 				ha -> pb
@@ -47,7 +47,7 @@ rwfunc get_intersection(ha:[]char/utf32, hb:[]char/utf32) -> () {
 		}
 	}
 	if (pa != "") {
-		pa.val -> v
+		pa·val -> v
 		println(v)
 	}
 }
diff --git a/tutorial/08-leetcode/162_find_peak.kv b/tutorial/08-leetcode/162_find_peak.kv
index f2c9d8b5..a21c2e7f 100644
--- a/tutorial/08-leetcode/162_find_peak.kv
+++ b/tutorial/08-leetcode/162_find_peak.kv
@@ -4,7 +4,7 @@
 #   2
 rwfunc find_peak() -> () {
 	a:[]int64 <- [1, 2, 3, 1]
-	n = ndarray.numel(a)  # = 等价于 <-
+	n = ndarray·numel(a)  # = 等价于 <-
 	0 -> lo
 	hi <- n - 1
 	while (lo < hi) {
diff --git a/tutorial/08-leetcode/167_two_sum_ii.kv b/tutorial/08-leetcode/167_two_sum_ii.kv
index 242ad87a..e19414dd 100644
--- a/tutorial/08-leetcode/167_two_sum_ii.kv
+++ b/tutorial/08-leetcode/167_two_sum_ii.kv
@@ -5,7 +5,7 @@
 rwfunc two_sum_ii() -> () {
 	[2, 7, 11, 15] -> a:[]int64
 	target <- 9
-	n = ndarray.numel(a)  # = 等价于 <-
+	n = ndarray·numel(a)  # = 等价于 <-
 	0 -> l
 	r <- n - 1
 	while (l < r) {
diff --git a/tutorial/08-leetcode/169_majority.kv b/tutorial/08-leetcode/169_majority.kv
index f261da73..2f2a2574 100644
--- a/tutorial/08-leetcode/169_majority.kv
+++ b/tutorial/08-leetcode/169_majority.kv
@@ -5,7 +5,7 @@
 #   3
 rwfunc majority() -> () {
 	a:[]int64 = [3, 2, 3]  # = 等价于 <-
-	ndarray.numel(a) -> n
+	ndarray·numel(a) -> n
 	candidate <- a[0]
 	count = 1  # = 等价于 <-
 	1 -> i
diff --git a/tutorial/08-leetcode/171_excel_column.kv b/tutorial/08-leetcode/171_excel_column.kv
index 97651852..f8c896c2 100644
--- a/tutorial/08-leetcode/171_excel_column.kv
+++ b/tutorial/08-leetcode/171_excel_column.kv
@@ -3,14 +3,14 @@
 # 期望输出:
 #   28
 rwfunc title_to_num(s:[]char/utf32) -> () {
-	string.len(s) -> n
+	string·len(s) -> n
 	result <- 0
 	i = 0  # = 等价于 <-
 	while (i < n) {
 		result × 26 -> r26
 		result × 26 -> r26_m
-		c <- string.char(s, i)
-		v = string.ord(c) - 65  # = 等价于 <-
+		c <- string·char(s, i)
+		v = string·ord(c) - 65  # = 等价于 <-
 		v + 1 -> d
 		result <- r26 + d
 		i = i + 1  # = 等价于 <-
diff --git a/tutorial/08-leetcode/189_rotate_array.kv b/tutorial/08-leetcode/189_rotate_array.kv
index c7b9bf61..bc92eed0 100644
--- a/tutorial/08-leetcode/189_rotate_array.kv
+++ b/tutorial/08-leetcode/189_rotate_array.kv
@@ -25,7 +25,7 @@ rwfunc swap(a_len:int64, lo:int64, hi:int64) -> () {
 
 rwfunc rotate() -> () {
 	a:[]int64 <- [1, 2, 3, 4, 5, 6, 7]
-	n = ndarray.numel(a)  # = 等价于 <-
+	n = ndarray·numel(a)  # = 等价于 <-
 	3 -> k
 	k_eff <- k % n
 	# reverse all
diff --git a/tutorial/08-leetcode/198_house_robber.kv b/tutorial/08-leetcode/198_house_robber.kv
index 98a5b358..bc321ea5 100644
--- a/tutorial/08-leetcode/198_house_robber.kv
+++ b/tutorial/08-leetcode/198_house_robber.kv
@@ -4,7 +4,7 @@
 #   4
 rwfunc rob() -> () {
 	[1, 2, 3, 1] -> a:[]int64
-	n <- ndarray.numel(a)
+	n <- ndarray·numel(a)
 	one = n == 1  # = 等价于 <-
 	n == 2 -> two
 
diff --git a/tutorial/08-leetcode/203_remove_linked_elements.kv b/tutorial/08-leetcode/203_remove_linked_elements.kv
index aadb7c1c..a44b780a 100644
--- a/tutorial/08-leetcode/203_remove_linked_elements.kv
+++ b/tutorial/08-leetcode/203_remove_linked_elements.kv
@@ -19,7 +19,7 @@ rwfunc build_list() -> () {
 rwfunc remove(head:[]char/utf32, val:int64) -> () {
 	p <- "/n0"
 	while (p != "") {
-		v = p.val  # = 等价于 <-
+		v = p·val  # = 等价于 <-
 		v == val -> skip
 
 		if (skip) {
@@ -27,7 +27,7 @@ rwfunc remove(head:[]char/utf32, val:int64) -> () {
 			println(v)
 		}
 
-		p <- p.next
+		p <- p·next
 	}
 }
 
diff --git a/tutorial/08-leetcode/206_reverse_linked_list.kv b/tutorial/08-leetcode/206_reverse_linked_list.kv
index f7cffad0..83420f83 100644
--- a/tutorial/08-leetcode/206_reverse_linked_list.kv
+++ b/tutorial/08-leetcode/206_reverse_linked_list.kv
@@ -18,16 +18,16 @@ rwfunc reverse(head:[]char/utf32) -> () {
 	prev = ""  # = 等价于 <-
 	head -> cur
 	while (cur != "") {
-		nxt <- cur.next
-		cur.next = prev  # = 等价于 <-
+		nxt <- cur·next
+		cur·next = prev  # = 等价于 <-
 		cur -> prev
 		cur <- nxt
 	}
 	p = prev  # = 等价于 <-
 	while (p != "") {
-		p.val -> v
+		p·val -> v
 		println(v)
-		p <- p.next
+		p <- p·next
 	}
 }
 
diff --git a/tutorial/08-leetcode/217_contains_dup.kv b/tutorial/08-leetcode/217_contains_dup.kv
index 72fbded1..c08a97b0 100644
--- a/tutorial/08-leetcode/217_contains_dup.kv
+++ b/tutorial/08-leetcode/217_contains_dup.kv
@@ -6,7 +6,7 @@
 #   false
 rwfunc has_dup() -> () {
 	a:[]int64 = [1, 2, 3, 1]  # = 等价于 <-
-	ndarray.numel(a) -> n
+	ndarray·numel(a) -> n
 	found <- false
 	i = 0  # = 等价于 <-
 	while (i < n) {
@@ -37,7 +37,7 @@ rwfunc has_dup() -> () {
 
 rwfunc no_dup() -> () {
 	a:[]int64 <- [1, 2, 3, 4]
-	n = ndarray.numel(a)  # = 等价于 <-
+	n = ndarray·numel(a)  # = 等价于 <-
 	false -> found
 	i <- 0
 	while (i < n) {
diff --git a/tutorial/08-leetcode/217_contains_dup_hash.kv b/tutorial/08-leetcode/217_contains_dup_hash.kv
index 05e0204f..98c8bbd3 100644
--- a/tutorial/08-leetcode/217_contains_dup_hash.kv
+++ b/tutorial/08-leetcode/217_contains_dup_hash.kv
@@ -4,19 +4,19 @@
 #   true
 #   false
 rwfunc has_dup(a:[]int64) -> () {
-	ndarray.numel(a) -> n
+	ndarray·numel(a) -> n
 	seen = {}  # = 等价于 <-
 	found <- false
 	i = 0  # = 等价于 <-
 	while (i < n) {
 		a[i] -> x
-		kv.get(seen, x) != None -> exists
+		kv·get(seen, x) != None -> exists
 
 		if (exists) {
 			true -> found
 			i <- n
 		} else {
-			_ = kv.set(seen, x, 1)  # = 等价于 <-
+			_ = kv·set(seen, x, 1)  # = 等价于 <-
 			i + 1 -> i
 		}
 	}
@@ -31,19 +31,19 @@ rwfunc has_dup(a:[]int64) -> () {
 
 rwfunc no_dup() -> () {
 	a:[]int64 = [1, 2, 3, 4]  # = 等价于 <-
-	ndarray.numel(a) -> n
+	ndarray·numel(a) -> n
 	seen = {}  # = 等价于 <-
 	found <- false
 	i = 0  # = 等价于 <-
 	while (i < n) {
 		a[i] -> x
-		kv.get(seen, x) != None -> exists
+		kv·get(seen, x) != None -> exists
 
 		if (exists) {
 			true -> found
 			i <- n
 		} else {
-			_ = kv.set(seen, x, 1)  # = 等价于 <-
+			_ = kv·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 cd77c3cf..98c7b499 100644
--- a/tutorial/08-leetcode/219_contains_dup_ii.kv
+++ b/tutorial/08-leetcode/219_contains_dup_ii.kv
@@ -4,16 +4,16 @@
 #   true
 #   false
 rwfunc near_dup(nums:[]int64, k:int64) -> () {
-	n <- ndarray.numel(nums)
+	n <- ndarray·numel(nums)
 	h = {}  # = 等价于 <-
 	found = false  # = 等价于 <-
 	0 -> i
 	while (i < n) {
 		nums[i] -> x
-		kv.get(h, x) != None -> exists
+		kv·get(h, x) != None -> exists
 
 		if (exists) {
-			h.*x -> j
+			h·*x -> j
 			if (j > 0) {
 				d <- i - j + 1
 
@@ -24,7 +24,7 @@ rwfunc near_dup(nums:[]int64, k:int64) -> () {
 			}
 		}
 		if (found == false) {
-			kv.set(h, x, i + 1) -> _
+			kv·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 aa4a2ea8..db4790ef 100644
--- a/tutorial/08-leetcode/234_palindrome_list.kv
+++ b/tutorial/08-leetcode/234_palindrome_list.kv
@@ -8,10 +8,10 @@ rwfunc is_pal(head:[]char/utf32) -> () {
 	0 -> n
 	head -> p
 	while (p != "") {
-		p.val -> v
-		kv.set(arr, n, v) -> _
+		p·val -> v
+		kv·set(arr, n, v) -> _
 		n <- n + 1
-		p.next -> p
+		p·next -> p
 	}
 	ok = true  # = 等价于 <-
 	0 -> l
diff --git a/tutorial/08-leetcode/238_product_except_self.kv b/tutorial/08-leetcode/238_product_except_self.kv
index 4f474fe7..621249b3 100644
--- a/tutorial/08-leetcode/238_product_except_self.kv
+++ b/tutorial/08-leetcode/238_product_except_self.kv
@@ -8,7 +8,7 @@
 #   6
 rwfunc product() -> () {
 	a:[]int64 = [1, 2, 3, 4]  # = 等价于 <-
-	ndarray.numel(a) -> n
+	ndarray·numel(a) -> n
 	prefix <- 1
 	suffix = 1  # = 等价于 <-
 	# build prefix products into result
diff --git a/tutorial/08-leetcode/242_valid_anagram.kv b/tutorial/08-leetcode/242_valid_anagram.kv
index b0a520b5..cb734d84 100644
--- a/tutorial/08-leetcode/242_valid_anagram.kv
+++ b/tutorial/08-leetcode/242_valid_anagram.kv
@@ -1,11 +1,11 @@
-# 242: Valid Anagram — dict 字符计数（动态键读写 h.*c，用 has 检存在）
+# 242: Valid Anagram — dict 字符计数（动态键读写 h·*c，用 has 检存在）
 # 来源: LeetCode #242
 # 期望输出:
 #   true
 #   false
 rwfunc is_anagram(s:[]char/utf32, t:[]char/utf32) -> () {
-	ns = string.len(s)  # = 等价于 <-
-	nt <- string.len(t)
+	ns = string·len(s)  # = 等价于 <-
+	nt <- string·len(t)
 	ok = true  # = 等价于 <-
 
 	if (ns != nt) {
@@ -14,22 +14,22 @@ rwfunc is_anagram(s:[]char/utf32, t:[]char/utf32) -> () {
 		h = {}  # = 等价于 <-
 		0 -> i
 		while (i < ns) {
-			string.char(s, i) -> c
-			kv.get(h, c) != None -> exists
+			string·char(s, i) -> c
+			kv·get(h, c) != None -> exists
 			if (exists) {
-				h.*c + 1 -> h.*c
+				h·*c + 1 -> h·*c
 			} else {
-				1 -> h.*c
+				1 -> h·*c
 			}
 			i <- i + 1
 		}
 		0 -> i
 		while (i < nt) {
-			string.char(t, i) -> c
-			kv.get(h, c) != None -> exists
+			string·char(t, i) -> c
+			kv·get(h, c) != None -> exists
 			if (exists) {
-				h.*c -> v
-				v - 1 -> h.*c
+				h·*c -> v
+				v - 1 -> h·*c
 			} else {
 				false -> ok
 				nt -> i
@@ -38,8 +38,8 @@ rwfunc is_anagram(s:[]char/utf32, t:[]char/utf32) -> () {
 		}
 		0 -> i
 		while (i < ns) {
-			string.char(s, i) -> c
-			h.*c -> v
+			string·char(s, i) -> c
+			h·*c -> v
 
 			if (v != 0) {
 				false -> ok
diff --git a/tutorial/08-leetcode/268_missing_number.kv b/tutorial/08-leetcode/268_missing_number.kv
index b18e5dc7..a67d7336 100644
--- a/tutorial/08-leetcode/268_missing_number.kv
+++ b/tutorial/08-leetcode/268_missing_number.kv
@@ -5,7 +5,7 @@
 #   2
 rwfunc missing() -> () {
 	a:[]int64 <- [3, 0, 1]
-	n = ndarray.numel(a)  # = 等价于 <-
+	n = ndarray·numel(a)  # = 等价于 <-
 	0 -> s
 	i <- 0
 	while (i < n) {
diff --git a/tutorial/08-leetcode/283_move_zeroes.kv b/tutorial/08-leetcode/283_move_zeroes.kv
index 696a0492..07f3a86f 100644
--- a/tutorial/08-leetcode/283_move_zeroes.kv
+++ b/tutorial/08-leetcode/283_move_zeroes.kv
@@ -8,7 +8,7 @@
 #   0
 rwfunc move_zeroes() -> () {
 	a:[]int64 = [0, 1, 0, 3, 12]  # = 等价于 <-
-	n <- ndarray.numel(a)
+	n <- ndarray·numel(a)
 	0 -> w
 	0 -> i
 	while (i < n) {
diff --git a/tutorial/08-leetcode/303_range_sum.kv b/tutorial/08-leetcode/303_range_sum.kv
index 43c43db1..fa8b8781 100644
--- a/tutorial/08-leetcode/303_range_sum.kv
+++ b/tutorial/08-leetcode/303_range_sum.kv
@@ -5,7 +5,7 @@
 #   -1
 rwfunc range_sum() -> () {
 	a:[]int64 <- [-2, 0, 3, -5, 2, -1]
-	n = ndarray.numel(a)  # = 等价于 <-
+	n = ndarray·numel(a)  # = 等价于 <-
 	# build prefix sums
 	[0, 0, 0, 0, 0, 0] -> p:[]int64
 	s <- a[0]
diff --git a/tutorial/08-leetcode/344_reverse_string.kv b/tutorial/08-leetcode/344_reverse_string.kv
index 60c43898..f43593cf 100644
--- a/tutorial/08-leetcode/344_reverse_string.kv
+++ b/tutorial/08-leetcode/344_reverse_string.kv
@@ -9,7 +9,7 @@
 rwfunc reverse_str() -> () {
 	# char 值数组: "hello" → ASCII [104, 101, 108, 108, 111]
 	a:[]int64 = [104, 101, 108, 108, 111]
-	n <- ndarray.numel(a)
+	n <- ndarray·numel(a)
 	l = 0  # = 等价于 <-
 	n - 1 -> r
 	while (l < r) {
@@ -23,7 +23,7 @@ rwfunc reverse_str() -> () {
 	i = 0  # = 等价于 <-
 	while (i < n) {
 		a[i] -> c
-		string.char("abcdefghijklmnopqrstuvwxyz", c - 97) -> s
+		string·char("abcdefghijklmnopqrstuvwxyz", c - 97) -> s
 		println(s)
 		i <- i + 1
 	}
diff --git a/tutorial/08-leetcode/349_intersection.kv b/tutorial/08-leetcode/349_intersection.kv
index 9137fa04..e721d0bf 100644
--- a/tutorial/08-leetcode/349_intersection.kv
+++ b/tutorial/08-leetcode/349_intersection.kv
@@ -4,9 +4,9 @@
 #   2
 rwfunc intersection() -> () {
 	a:[]int64 = [1, 2, 2, 1]  # = 等价于 <-
-	ndarray.numel(a) -> na
+	ndarray·numel(a) -> na
 	b:[]int64 <- [2, 2]
-	nb = ndarray.numel(b)  # = 等价于 <-
+	nb = ndarray·numel(b)  # = 等价于 <-
 	[0, 0] -> r:[]int64
 	idx <- 0
 	count = 0  # = 等价于 <-
diff --git a/tutorial/08-leetcode/414_third_max.kv b/tutorial/08-leetcode/414_third_max.kv
index 0bfa9bd1..a5f325f3 100644
--- a/tutorial/08-leetcode/414_third_max.kv
+++ b/tutorial/08-leetcode/414_third_max.kv
@@ -4,7 +4,7 @@
 #   1
 rwfunc third_max() -> () {
 	a:[]int64 = [2, 2, 3, 1]  # = 等价于 <-
-	ndarray.numel(a) -> n
+	ndarray·numel(a) -> n
 	# track top 3
 	first <- 0
 	second = 0  # = 等价于 <-
diff --git a/tutorial/09-debugger/chain_array.kv b/tutorial/09-debugger/chain_array.kv
index feb32ebc..4db04dae 100644
--- a/tutorial/09-debugger/chain_array.kv
+++ b/tutorial/09-debugger/chain_array.kv
@@ -1,5 +1,5 @@
 # 深层数组参数链路：main → f1 → f2 → f3
-# 在 f3 最深处 debugger() 暂停，可 dump kvspace 观察 .rparam/.wparam 链
+# 在 f3 最深处 debugger() 暂停，可 dump kvspace 观察 ·rparam/·wparam 链
 rwfunc f3() -> (a:int64, s:int64) {
     println(a)
     debugger()          # 在此暂停
diff --git a/tutorial/11-string/01-basic.kv b/tutorial/11-string/01-basic.kv
index 57b61120..b6e37c79 100644
--- a/tutorial/11-string/01-basic.kv
+++ b/tutorial/11-string/01-basic.kv
@@ -7,7 +7,7 @@
 rwfunc main() -> () {
 	s = "hello"
 	println(s)
-	println(string.len(s))
+	println(string·len(s))
 	t <- "kv" + "lang"
 	println(t)
 }
diff --git a/tutorial/11-string/02-char-ord.kv b/tutorial/11-string/02-char-ord.kv
index eaeee616..a5792d7b 100644
--- a/tutorial/11-string/02-char-ord.kv
+++ b/tutorial/11-string/02-char-ord.kv
@@ -1,11 +1,11 @@
-# 码点操作：string.char（第 i 个码点）、string.ord（首码点值）
+# 码点操作：string·char（第 i 个码点）、string·ord（首码点值）
 # 定宽 utf32 下 O(1) 索引；多字节字符（é）也按码点计
 # 期望输出:
 #   é
 #   233
 rwfunc main() -> () {
 	s = "héllo"
-	println(string.char(s, 1))
-	println(string.ord("é"))
+	println(string·char(s, 1))
+	println(string·ord("é"))
 }
 main()
diff --git a/tutorial/11-string/03-slice-find.kv b/tutorial/11-string/03-slice-find.kv
index bd79feed..d4261436 100644
--- a/tutorial/11-string/03-slice-find.kv
+++ b/tutorial/11-string/03-slice-find.kv
@@ -1,12 +1,12 @@
-# 切片与查找：string.slice（码点区间 [lo,hi)）、string.find（码点下标，未找到 -1）
+# 切片与查找：string·slice（码点区间 [lo,hi)）、string·find（码点下标，未找到 -1）
 # 期望输出:
 #   6
 #   hello
 #   -1
 rwfunc main() -> () {
 	s = "hello world"
-	println(string.find(s, "world"))
-	println(string.slice(s, 0, 5))
-	println(string.find(s, "zz"))
+	println(string·find(s, "world"))
+	println(string·slice(s, 0, 5))
+	println(string·find(s, "zz"))
 }
 main()
diff --git a/tutorial/11-string/04-cmp-concat.kv b/tutorial/11-string/04-cmp-concat.kv
index 3917a342..0a9daa26 100644
--- a/tutorial/11-string/04-cmp-concat.kv
+++ b/tutorial/11-string/04-cmp-concat.kv
@@ -1,11 +1,11 @@
-# 比较与拼接：string.cmp（-1/0/1，按码点序）、string.concat
+# 比较与拼接：string·cmp（-1/0/1，按码点序）、string·concat
 # 期望输出:
 #   -1
 #   0
 #   foobar
 rwfunc main() -> () {
-	println(string.cmp("abc", "abd"))
-	println(string.cmp("x", "x"))
-	println(string.concat("foo", "bar"))
+	println(string·cmp("abc", "abd"))
+	println(string·cmp("x", "x"))
+	println(string·concat("foo", "bar"))
 }
 main()
diff --git a/tutorial/11-string/05-encodings.kv b/tutorial/11-string/05-encodings.kv
index 8c1ec5ce..05d95aa9 100644
--- a/tutorial/11-string/05-encodings.kv
+++ b/tutorial/11-string/05-encodings.kv
@@ -1,5 +1,5 @@
 # 字符串编码：char/utf32（默认定宽）、char/ascii（定宽）、char/utf8（变宽，仅存储/打印）
-# 写槽类型标注反推字面量编码；utf8 禁索引（string.char/slice/s[i] 报错）
+# 写槽类型标注反推字面量编码；utf8 禁索引（string·char/slice/s[i] 报错）
 # 期望输出:
 #   abc
 #   y
@@ -8,7 +8,7 @@ rwfunc main() -> () {
 	a = "abc"               # 默认 char/utf32
 	println(a)
 	b:[]char/ascii = "xyz"    # ASCII 定宽，可索引
-	println(string.char(b, 1))
+	println(string·char(b, 1))
 	c:[]char/utf8 = "héllo"   # UTF-8 变宽，打印 OK（索引会报错）
 	println(c)
 }
diff --git a/tutorial/11-string/06-convert.kv b/tutorial/11-string/06-convert.kv
index 537be537..b8546c95 100644
--- a/tutorial/11-string/06-convert.kv
+++ b/tutorial/11-string/06-convert.kv
@@ -9,7 +9,7 @@ rwfunc main() -> () {
 	s:[]char/utf8 = "hello"   # 变宽，禁索引
 	t <- char/utf32(s)      # 转 utf32 定宽，可索引
 	println(t)
-	println(string.char(t, 1))
+	println(string·char(t, 1))
 	u <- char/ascii("world")  # 转 ascii（非 ASCII 会报错）
 	println(u)
 }
diff --git a/tutorial/12-struct/01-linked-list.kv b/tutorial/12-struct/01-linked-list.kv
index 208e3584..a5c1660f 100644
--- a/tutorial/12-struct/01-linked-list.kv
+++ b/tutorial/12-struct/01-linked-list.kv
@@ -1,29 +1,29 @@
-# 链表：非表意指针（隐式 .hex 子 key）+ dict
-# 待实现：需隐式 .hex 子 key + ‥incr 计数（见 非表意指针key生成规则.md）
-# wip: 需要 .hex 隐式创建实现
-# 语义: l 是容器 dict；l.head = {} 隐式建节点 .1；指针 p 走链，p.next = {} 隐式建下一节点
+# 链表：非表意指针（隐式 ·hex 子 key）+ dict
+# 待实现：需隐式 ·hex 子 key + ‥incr 计数（见 非表意指针key生成规则·md）
+# wip: 需要 ·hex 隐式创建实现
+# 语义: l 是容器 dict；l·head = {} 隐式建节点 ·1；指针 p 走链，p·next = {} 隐式建下一节点
 # 期望输出:
 #   10
 #   20
 #   30
 
 l = {}
-l.head = {}
-l.head.val = 10
+l·head = {}
+l·head·val = 10
 
-p = l.head
-p.next = {}
-p = p.next
-p.val = 20
+p = l·head
+p·next = {}
+p = p·next
+p·val = 20
 
-p.next = {}
-p = p.next
-p.val = 30
+p·next = {}
+p = p·next
+p·val = 30
 
 # 遍历链表
-p = l.head
+p = l·head
 while (p != null) {
-    p.val -> v
+    p·val -> v
     println(v)
-    p.next -> p
+    p·next -> p
 }
diff --git a/tutorial/12-struct/02-tree.kv b/tutorial/12-struct/02-tree.kv
index 8cfd8901..8eb80449 100644
--- a/tutorial/12-struct/02-tree.kv
+++ b/tutorial/12-struct/02-tree.kv
@@ -1,21 +1,21 @@
 # 二叉树：非表意指针 + dict
-# 待实现：需隐式 .hex 子 key
-# wip: 需要 .hex 隐式创建实现
-# 语义: t 是容器；t.root = {} 隐式建根节点 .1，left/right 各隐式建子节点
+# 待实现：需隐式 ·hex 子 key
+# wip: 需要 ·hex 隐式创建实现
+# 语义: t 是容器；t·root = {} 隐式建根节点 ·1，left/right 各隐式建子节点
 # 期望输出:
 #   root=5 left=3 right=8
 
 t = {}
-t.root = {}
-t.root.val = 5
+t·root = {}
+t·root·val = 5
 
-t.root.left = {}
-t.root.left.val = 3
+t·root·left = {}
+t·root·left·val = 3
 
-t.root.right = {}
-t.root.right.val = 8
+t·root·right = {}
+t·root·right·val = 8
 
-t.root.val -> a
-t.root.left.val -> b
-t.root.right.val -> c
+t·root·val -> a
+t·root·left·val -> b
+t·root·right·val -> c
 println("root=", a, " left=", b, " right=", c)
diff --git a/tutorial/12-struct/03-graph.kv b/tutorial/12-struct/03-graph.kv
index 10fd400c..0fe2a4f1 100644
--- a/tutorial/12-struct/03-graph.kv
+++ b/tutorial/12-struct/03-graph.kv
@@ -1,21 +1,21 @@
 # 有向图（邻接表）：非表意指针 + dict
-# 待实现：需隐式 .hex 子 key
-# wip: 需要 .hex 隐式创建实现
-# 语义: g 是容器；g.a/g.b/g.c 隐式建节点，邻居存为成员引用。边 a→b, a→c
+# 待实现：需隐式 ·hex 子 key
+# wip: 需要 ·hex 隐式创建实现
+# 语义: g 是容器；g·a/g·b/g·c 隐式建节点，邻居存为成员引用。边 a→b, a→c
 # 期望输出:
-#   g.a -> 2 , 3
+#   g·a -> 2 , 3
 
 g = {}
-g.a = {}
-g.a.val = 1
-g.b = {}
-g.b.val = 2
-g.c = {}
-g.c.val = 3
+g·a = {}
+g·a·val = 1
+g·b = {}
+g·b·val = 2
+g·c = {}
+g·c·val = 3
 
-g.a.n0 = g.b
-g.a.n1 = g.c
+g·a·n0 = g·b
+g·a·n1 = g·c
 
-g.a.n0.val -> x
-g.a.n1.val -> y
-println("g.a ->", x, ",", y)
+g·a·n0·val -> x
+g·a·n1·val -> y
+println("g·a ->", x, ",", y)
diff --git a/tutorial/error_cases/array_param/mutate_correct.kv b/tutorial/error_cases/array_param/mutate_correct.kv
index e06e9c2d..7c170ecd 100644
--- a/tutorial/error_cases/array_param/mutate_correct.kv
+++ b/tutorial/error_cases/array_param/mutate_correct.kv
@@ -3,14 +3,14 @@
 #   has no type annotation
 rwfunc mutate() -> (a) {
     arr:[]int64 = [10, 20]
-    99 -> xv.set(arr, 0, 99)    # set 返回修改后的数组
-    1  -> xv.set(arr, 1, 1)
+    99 -> xv·set(arr, 0, 99)    # set 返回修改后的数组
+    1  -> xv·set(arr, 1, 1)
     arr -> a                 # 返回修改后的数组给调用方
 }
 
 rwfunc init() -> () {
     mutate() -> result
-    xv.at(result, 0) -> v0
-    xv.at(result, 1) -> v1
+    xv·at(result, 0) -> v0
+    xv·at(result, 1) -> v1
     println(v0, v1)   # 99 1
 }
diff --git a/tutorial/error_cases/array_param/mutate_literal.kv b/tutorial/error_cases/array_param/mutate_literal.kv
index b915d8ff..e7d16417 100644
--- a/tutorial/error_cases/array_param/mutate_literal.kv
+++ b/tutorial/error_cases/array_param/mutate_literal.kv
@@ -4,7 +4,7 @@
 # kvlang 铁律：读参只读。要修改数组，必须放写参位置。
 # 正确: rwfunc mutate() -> (a) { array(10,20) -> a; 99 -> a[0]; ... }
 rwfunc mutate(a) -> () {
-    99 -> a[0]   # ❌ a 是读参，a[0] 展开为 kv.set(a,0,99) -> a，写入读参槽被拒绝
+    99 -> a[0]   # ❌ a 是读参，a[0] 展开为 kv·set(a,0,99) -> a，写入读参槽被拒绝
 }
 
 a:[]int64 = [10, 20]
diff --git a/tutorial/error_cases/index_error/at_oob.kv b/tutorial/error_cases/index_error/at_oob.kv
index 7d2eaf42..3044d924 100644
--- a/tutorial/error_cases/index_error/at_oob.kv
+++ b/tutorial/error_cases/index_error/at_oob.kv
@@ -1,3 +1,3 @@
 # expected:
-#   error: KeyError: kv.at: key not found
-kv.get([1, 2], 5) -> _
+#   error: KeyError: kv·at: key not found
+kv·get([1, 2], 5) -> _
diff --git a/tutorial/error_cases/index_error/char_oob.kv b/tutorial/error_cases/index_error/char_oob.kv
index c79164b9..7f32cb18 100644
--- a/tutorial/error_cases/index_error/char_oob.kv
+++ b/tutorial/error_cases/index_error/char_oob.kv
@@ -1,3 +1,3 @@
 # expected:
 #   IndexError: at: index
-string.char("hello", 10)
+string·char("hello", 10)
diff --git a/tutorial/error_cases/index_error/slice_oob.kv b/tutorial/error_cases/index_error/slice_oob.kv
index b6d63db8..6a4c3179 100644
--- a/tutorial/error_cases/index_error/slice_oob.kv
+++ b/tutorial/error_cases/index_error/slice_oob.kv
@@ -1,3 +1,3 @@
 # expected:
 #   IndexError
-string.slice("hello", 0, 10)
+string·slice("hello", 0, 10)
diff --git a/tutorial/error_cases/index_error/typed_array_string_key.kv b/tutorial/error_cases/index_error/typed_array_string_key.kv
index d8754f97..8ba1e02b 100644
--- a/tutorial/error_cases/index_error/typed_array_string_key.kv
+++ b/tutorial/error_cases/index_error/typed_array_string_key.kv
@@ -1,4 +1,4 @@
 # expected:
-#   error: KeyError: kv.at: key not found
+#   error: KeyError: kv·at: key not found
 arr:[]int32 = [1, 2, 3]
-kv.get(arr, "key") -> _
+kv·get(arr, "key") -> _
diff --git a/tutorial/error_cases/key_error/kv_at_missing.kv b/tutorial/error_cases/key_error/kv_at_missing.kv
index 69267c56..3a546842 100644
--- a/tutorial/error_cases/key_error/kv_at_missing.kv
+++ b/tutorial/error_cases/key_error/kv_at_missing.kv
@@ -1,3 +1,3 @@
 # expected:
-#   error: KeyError: kv.at: key not found
-kv.get("/x", "y") -> _
+#   error: KeyError: kv·at: key not found
+kv·get("/x", "y") -> _
diff --git a/tutorial/error_cases/type_error/char_bad_args.kv b/tutorial/error_cases/type_error/char_bad_args.kv
index 9abbfc14..b9ae9f7b 100644
--- a/tutorial/error_cases/type_error/char_bad_args.kv
+++ b/tutorial/error_cases/type_error/char_bad_args.kv
@@ -1,3 +1,3 @@
 # expected:
-#   error: TypeError: string.char requires string and index
-string.char(1)
+#   error: TypeError: string·char requires string and index
+string·char(1)
diff --git a/tutorial/error_cases/type_error/concat_non_string.kv b/tutorial/error_cases/type_error/concat_non_string.kv
index eb1ebf9b..3d61803a 100644
--- a/tutorial/error_cases/type_error/concat_non_string.kv
+++ b/tutorial/error_cases/type_error/concat_non_string.kv
@@ -1,7 +1,7 @@
 # expected
-#   TypeError: string.concat requires strings, got int64 and bool
+#   TypeError: string·concat requires strings, got int64 and bool
 # 修复: todo-033 — concat 曾将 42→"42", true→"true" 静默拼接为 "42true"
 rwfunc main() -> () {
-	string.concat(int64(42), true) -> x
+	string·concat(int64(42), true) -> x
 }
 main()