ME.WHATEVER(WHAT)

Statement

Core Pattern

me.path.to.node(value)   // write
me("path.to.node")       // read

Path-based, not method-based in the traditional sense — the same syntax addresses any depth of hierarchy, in any declared vocabulary.

Basic Usage

import Me from "this.me";
const me = new Me();

me["@"]("jabellae");

me.profile.name("Abella");
me.profile.bio("Building the semantic web.");

me.users.ana.name("Ana");
me.users.ana.age(22);

me.friends.ana["->"]("users.ana");

// Automatic logic
me.friends["[i]"]["="]("is_adult", "age >= 18");

console.log(me("friends.ana.is_adult"));        // → true
console.log(me("friends[age > 18].name"));      // → { ana: "Ana" }

One call chain: declare identity, write two profiles, point one path at another, broadcast a derivation across every friend, then read either the direct result or a filtered family. No separate query language — the same me(...) call does both.

Language-Agnostic

Meaning comes from structure, not from specific words — the same logic holds under any vocabulary:

// English
me.shop.items[1].price(100);
me.shop.items[1]["="]("total", "price * 1.16");

// Spanish
me.tienda.articulos[1].precio(100);
me.tienda.articulos[1]["="]("total", "precio * 1.16");

// Japanese
me.店舗.商品[1].価格(100);
me.店舗.商品[1]["="]("合計", "価格 * 1.16");

Operators

_, ~, and = are independently source-verified against the kernel elsewhere on this site: The Algebra of Encrypted Audiences and Inverted Dependency Indexing. The full table's primary source: official Syntax reference.

Selector Syntax

me.fleet.trucks[2].km()                                    // fixed index
me.fleet["trucks[i]"]["="]("cost", "fuel * price_per_liter") // broadcast
me("fleet.trucks[fuel >= 200].fuel")                         // logical filter
me("fleet.trucks[1..2].fuel")                                // range
me("fleet.trucks[[1,3]].fuel")                                // multi-select
me("fleet.trucks[x => x.fuel * 0.5]")                          // transform

A bracket selector turns one position into an indexed family — the same mechanism formalized as R*(p[φ], o) in SpaceStructure.

Run at two different extremes in the published docs: Robots That Understand Context uses me.robots["[i]"]["="](...) to write one rule across four heterogeneous agents at once; the Extreme Fan-Out benchmark uses the same pattern across 100,000 dependents from a single write — me.explain("dep[100000].out") returns the full recomputed list, k: 100000, and the exact upstream sourcePath. Same operator, four agents or a hundred thousand.

Why This Shape

• Semantic clarity — the call reads as a sentence, which is what makes it auditable rather than merely executable.
• State encapsulation — everything hangs off me; there is no external object separate from the subject invoking it.
• Deterministic logic — a result depends strictly on current state and input, not on hidden global state, making calls repeatable.