数据类型：字符串、数组与内建操作

// data.js —— 完整可运行：在 func.js 基础上增加 str / 数组 / 内建
const KEYWORDS = new Set(['var', 'if', 'else', 'while', 'func', 'return'])
function tokenize(src) {
  const tokens = []; let i = 0
  const isD = c => c >= '0' && c <= '9'
  const isA = c => (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c === '_'
  while (i < src.length) {
    const c = src[i]
    if (c === ' ' || c === '\n' || c === '\t' || c === '\r') { i++; continue }
    if (c === '"') { i++; let str = ''; while (i < src.length && src[i] !== '"') { str += src[i]; i++ } i++; tokens.push({ type: 'str', value: str }); continue }
    if (isD(c)) { const s = i; while (i < src.length && isD(src[i])) i++; tokens.push({ type: 'num', value: Number(src.slice(s, i)) }); continue }
    if (isA(c)) { const s = i; while (i < src.length && (isA(src[i]) || isD(src[i]))) i++; const w = src.slice(s, i); tokens.push(KEYWORDS.has(w) ? { type: 'kw', value: w } : { type: 'id', value: w }); continue }
    const one = { '+': 'plus', '-': 'minus', '*': 'star', '/': 'slash', '(': 'lparen', ')': 'rparen', ';': 'semi', '{': 'lbrace', '}': 'rbrace', ',': 'comma', '[': 'lbracket', ']': 'rbracket' }[c]
    if (one) { tokens.push({ type: one, value: c }); i++; continue }
    throw new Error('非法字符: ' + c)
  }
  tokens.push({ type: 'eof', value: null }); return tokens
}
function parse(src) {
  const tokens = tokenize(src); let pos = 0
  const peek = () => tokens[pos], next = () => tokens[pos++]
  const expect = t => { if (peek().type !== t) throw new Error('语法错误：期望 ' + t); return next() }
  function parseExpr() {
    let n = parseTerm()
    while (peek().type === 'plus' || peek().type === 'minus') { const op = next().value; n = { type: 'binary', op, left: n, right: parseTerm() } }
    return n
  }
  function parseTerm() {
    let n = parseFactor()
    while (peek().type === 'star' || peek().type === 'slash') { const op = next().value; n = { type: 'binary', op, left: n, right: parseFactor() } }
    return n
  }
  function parseFactor() {
    const t = peek()
    if (t.type === 'minus') { next(); return { type: 'unary', op: '-', operand: parseFactor() } }
    if (t.type === 'num') { next(); return { type: 'num', value: t.value } }
    if (t.type === 'str') { next(); return { type: 'str', value: t.value } }
    if (t.type === 'lbracket') {
      next(); const els = []
      if (peek().type !== 'rbracket') { els.push(parseExpr()); while (peek().type === 'comma') { next(); els.push(parseExpr()) } }
      expect('rbracket'); return { type: 'arr', elements: els }
    }
    if (t.type === 'id') {
      next()
      if (peek().type === 'lparen') {
        next(); const args = []
        if (peek().type !== 'rparen') { args.push(parseExpr()); while (peek().type === 'comma') { next(); args.push(parseExpr()) } }
        expect('rparen'); return { type: 'call', callee: { type: 'ident', name: t.value }, args }
      }
      if (peek().type === 'eq') { next(); return { type: 'assign', name: t.value, value: parseExpr() } }
      return { type: 'ident', name: t.value }
    }
    if (t.type === 'lparen') { next(); const e = parseExpr(); expect('rparen'); return e }
    throw new Error('无法解析表达式: ' + t.type)
  }
  function parseStmt() {
    const t = peek()
    if (t.type === 'kw' && t.value === 'var') {
      next(); const name = expect('id').value; expect('eq'); const init = parseExpr(); expect('semi'); return { type: 'var', name, init }
    }
    if (t.type === 'kw' && t.value === 'func') {
      next(); const name = expect('id').value; expect('lparen')
      const params = []
      if (peek().type !== 'rparen') { params.push(expect('id').value); while (peek().type === 'comma') { next(); params.push(expect('id').value) } }
      expect('rparen'); const body = parseStmt(); return { type: 'func', name, params, body }
    }
    if (t.type === 'lbrace') { next(); const stmts = []; while (peek().type !== 'rbrace') stmts.push(parseStmt()); expect('rbrace'); return { type: 'block', stmts } }
    const e = parseExpr(); expect('semi'); return { type: 'exprstmt', expr: e }
  }
  const prog = []; while (peek().type !== 'eof') prog.push(parseStmt()); return prog
}
class Environment {
  constructor(parent = null) { this.vars = new Map(); this.parent = parent }
  define(n, v) { this.vars.set(n, v) }
  get(n) { let e = this; while (e) { if (e.vars.has(n)) return e.vars.get(n); e = e.parent } throw new Error('未定义变量: ' + n) }
  assign(n, v) { let e = this; while (e) { if (e.vars.has(n)) { e.vars.set(n, v); return } e = e.parent } this.vars.set(n, v) }
}
function ev(node, env) {
  switch (node.type) {
    case 'num': return node.value
    case 'str': return node.value
    case 'arr': return node.elements.map(e => ev(e, env))
    case 'ident': return env.get(node.name)
    case 'unary': return -ev(node.operand, env)
    case 'binary': {
      const a = ev(node.left, env), b = ev(node.right, env)
      if (node.op === '+' && (typeof a === 'string' || typeof b === 'string')) return String(a) + String(b)
      switch (node.op) {
        case '+': return a + b; case '-': return a - b; case '*': return a * b; case '/': return a / b
      }
    }
    case 'assign': { const v = ev(node.value, env); env.assign(node.name, v); return v }
    case 'var': { const v = ev(node.init, env); env.define(node.name, v); return v }
    case 'exprstmt': return ev(node.expr, env)
    case 'block': { const b = new Environment(env); let r; for (const s of node.stmts) r = ev(s, b); return r }
    case 'func': { env.define(node.name, { type: 'UserFn', params: node.params, body: node.body, closure: env }); return node.name }
    case 'call': {
      const callee = ev(node.callee, env)
      const args = node.args.map(a => ev(a, env))
      if (typeof callee === 'function') return callee(...args)
      if (callee && callee.type === 'UserFn') {
        const fnEnv = new Environment(callee.closure)
        callee.params.forEach((p, i) => fnEnv.define(p, args[i]))
        try { ev(callee.body, fnEnv) } catch (e) { if (e && e.__ret) return e.value; throw e }
        return undefined
      }
      throw new Error('不是可调用的对象')
    }
  }
  throw new Error('未知节点: ' + node.type)
}
function run(src) {
  const env = new Environment()
  env.define('print', (...xs) => console.log(...xs))
  env.define('len', x => x.length)
  env.define('push', (a, x) => { a.push(x); return a })
  env.define('map', (a, fn) => a.map(e => fn(e)))
  for (const s of parse(src)) ev(s, env)
}

// ===== 调用示例 =====
run(`
print(len("hello"));
var a = [1, 2, 3];
print(map(a, func(x) { return x * 2; }));
print(push(a, 4));
`)

run(`
var a = [10, 20, 30];
var b = map(a, func(x) { return x + 1; });
print(len(b));  // 3
`)