The 10-Part LMScript Examples Book

Organized in progressive order from lmctl-mono/lmscript/examples/. Every example can be checked with lmscript --check, linted with lmscript --lint, and executed directly.

Part I — First Steps, Variables, Lists & Maps

Covers basic output (println), arithmetic, booleans, 0-based lists (xs[0], negative indexing xs[-1]), and key-value maps (m.key and m["key"]).

greeting = "Hello, LMScript!";
langs    = ["lmscript", "lmcode", "lmaws"];
release  = { version: "0.2.38", dslb: 6 };

println(greeting);
println("First: " + langs[0] + " | Last: " + langs[-1]);
println(f"Release {release.version} (DSLB v{release.dslb})");

Part II — Python-Style Strings, Regex Substrings, Stateful pos() Tokenizer & Path Literals

Demonstrates raw strings (r"..."), format strings (f"..."), triple-quoted blocks, regex containment & substring extraction (regex_test, regex_find, regex_matches, regex_match, regex_find_all, regex_replace), Perl-like stateful pos() tokenizers (pos, set_pos, regex_find_pos, regex_match_pos, regex_test_pos), and first-class paths.

# 1. Check if string matches (contains) pattern & extract 1 or more matched substrings
log = "2026-10-17 ERROR disk 91%\n2026-10-18 WARN cpu 72%\n2026-10-18 ERROR mem 88%";
println(regex_test(log, r"ERROR"));        # true
println(regex_find(log, r"\d+%"));         # "91%"
println(regex_matches(log, r"\d+%"));      # ["91%", "72%", "88%"]

# 2. Stateful Perl-like pos() tokenizer over a list of [kind, pattern] rules
const RULES = [
  ["WS",     r"\s+"],
  ["NUMBER", r"\d+(?:\.\d+)?"],
  ["IDENT",  r"[A-Za-z_][A-Za-z0-9_]*"],
  ["OP",     r"==|!=|<=|>=|[+\-*/=()<>]"],
  ["SEMI",   r";"]
];

fn tokenize(src) {
  pos(src, 0);
  let tokens = [];
  while (pos() < len(src)) {
    let start = pos();
    let matched = false;
    for (rule in RULES) {
      let text = regex_find_pos(src, rule[1]);
      if (text != null) {
        if (rule[0] != "WS") { push(tokens, { kind: rule[0], text: text, at: start }); }
        matched = true;
        break;
      }
    }
    if (!matched) {
      return { ok: false, error_pos: pos(), rest: slice(src, pos()) };
    }
  }
  return { ok: true, tokens: tokens, final_pos: pos() };
}

res = tokenize("total = 42 + tax_rate * 10.5;");
println(f"tokens={len(res.tokens)} final_pos={res.final_pos}");

Part III — Control Flow, Loops & Functions

Covers if (...) { ... } else if (...) { ... } else { ... }, for (v in xs) { ... }, for (k in map) { ... } (map keys), numeric for (i = 0; i < 10; i = i + 1), while, and higher-order functions (functions are declared at top level and passed as values; there are no nested closures).

# Part III — Functions, Recursion, Higher-Order Functions & Loops
fn double(x) {
  return x * 2;
}

fn apply_twice(f, val) {
  return f(f(val));
}

results = [];
for (i = 1; i <= 4; i = i + 1) {
  push(results, apply_twice(double, i));
}
println("Sequence: " + json_stringify(results));

Part IV — Embedded Data Blocks (_json_, _csv_, _toml_, _props_, _graphql_)

Data blocks are validated at parse/check time and produce opaque Data for JSON, CSV, and TOML (use .value() for native values); props produces a map and GraphQL produces text.

endpoints = _csv_ heading=true;
name,method,path
health,GET,/healthz
deploy,POST,/v1/deploy
end _csv_

for (ep in endpoints.value()) {
  println(f"{ep.method} {ep.path} ({ep.name})");
}

Part V — File System, _cmd_ Blocks & Process Execution

Safe command execution with _cmd_ argv blocks, system(...) status inspection, system(argv) output capture, and dry-run-aware file mutations.

ver_cmd = _cmd_;
lmscript --version
end _cmd_

res = system(ver_cmd);
println("Exit: " + str(res.code) + " | Output: " + trim(res.stdout));

Part VI — Forward Templates (expand) & Reverse Templates (template_extract)

Render config files and prompts with expand(tpl, map), and invert the same template to extract text fields back out of logs or command output with template_extract_text(tpl, text).

# Part VI — Forward expand() and Reverse template_extract_text() / template_extract()
tpl  = "site=${site};env=${env};end";
line = expand(tpl, {site: "lmscript.io", env: "prod"});
println("Rendered  : " + line);

rev = template_extract_text(tpl, line);
require(rev.matched, "expected reverse template text match");
println("Extracted : " + json_stringify(rev.value));

rows = template_extract([{kind: "host", name: "$name"}], [
  {kind: "host", name: "lmaws"},
  {kind: "skip", name: "none"},
  {kind: "host", name: "lmcad"}
]);
println("Projected : " + json_stringify(rows.value));

Part VII — SQLite Databases, HTTP Client & XML/HTML Parsing

Query local SQLite files with literal SQL and bound parameters, fetch text via http_get, and inspect _xml_ Data using xml_select.

# Part VII — SQLite with a temporary local database
db = temp_file();
sql_exec(db, "CREATE TABLE hosts (name TEXT, lang TEXT)");
sql_exec(db, "INSERT INTO hosts VALUES (?, ?), (?, ?)", ["lmaws", "java", "lmcad", "cpp"]);
rows = sql_read(db, "SELECT name, lang FROM hosts ORDER BY name");
delete_file(db);
println(json_stringify(rows));

Part VIII — Modules (import), Packages & CLI PROPS

Structure multi-file toolchains using import, and CLI PROPS / --pref definitions.

Part IX — Reliability: recover, resumepoint & parallel_map

Select explicit recover / resumepoint entries when rerunning a script, reload any needed application state explicitly (recovery saves no state and catches no errors), and fan out work across concurrent workers.

Part X — Embedded _lmcode_ Bytecode Hosts & Unified AI Agents

Compile statically typed _lmcode_ blocks to DSLB v6 bytecode, execute them via run_lmcode, and coordinate multi-turn AI coding agents with agent_open and agent_turn.

Catalog of 58 Core LMScript Example Scripts

The 58 scripts in the main reading sequence from lmctl-mono/lmscript/examples/index.md, in book order. The separate xml_tree.lms example is linked at the end of that repository book. The Part column follows the core sequence: 1 Basics, 2 Data, 3 Text, 4 Files, 5 Processes, 6 Agents, 7 Concurrency & recovery, 8 Checking & tracing, 9 Modules & data blocks (Part 10 is the reference and language comparisons).