.me가 어떻게 임의의 속성 체인을 연산자, 포인터, 프라이버시 및 파생을 포함하는 의미론적 트리로 변환하는가.

me.whatever.you.want("x")

대부분의 API는 당신에게 그 형태를 먼저 학습할 것을 요구합니다.

.me는 정반대의 방향에서 시작합니다:

me.whatever.you.want("x");

사전 정의된 whatever도, 사전 정의된 you도, 사전 정의된 want도 없습니다.

경로(Path)는 그것을 사용함으로써 생성됩니다.

이것이 .me의 기본 구조입니다: 호출 가능한 JavaScript 프록시(Proxy)를 통해 노출되는 자유 형식의 의미론적 트리(Semantic tree)입니다.

경로 (Paths)

.me 값은 객체(Object)와 함수(Function) 모두처럼 동작합니다.

속성 체이닝(Property chaining)을 통해 쓸 수 있습니다:

me.profile.name("Sui Gn");
me.profile.location.city("Cordoba");
me.project.kernel.language("TypeScript");

그리고 경로 문자열(Path string)을 통해 읽을 수 있습니다:

me("profile.name");
me("profile.location.city");
me("project.kernel.language");

속성 체인은 일반적인 JavaScript 객체 트리가 아닙니다. 그것은 경로 빌더(Path builder)입니다.

me.whatever.you.want("x");

은 다음을 의미합니다:

whatever.you.want = "x"

커널(Kernel)은 이것을 단순한 객체 변이(Mutation)가 아니라 메모리 이벤트(Memory event)로 기록합니다.

자유 형식이지만, 구조화되지 않은 것은 아님

.me는 의미론적 경로 계층(Semantic path layer)에서 자유 형식입니다.

다음과 같이 말할 수 있습니다:

me.any.path.you.need("value");

하지만 커널은 여전히 모든 쓰기에 구조를 부여합니다:

path
operator
value
...

이는 임의의 경로라도 여전히 재생(Replay), 검사(Inspect), 스냅샷(Snapshot), 암호화(Encrypt), 파생(Derive) 및 설명(Explain)이 가능하다는 것을 의미합니다.

따라서 .me는 "단순히 느슨한 객체"가 아닙니다.

그것은 의미론적 메모리 런타임(Semantic memory runtime)입니다.

연산자 (Operators)

트리는 자유롭지만, 일부 심볼은 연산자(Operators)로 예약되어 있습니다.

연산자는 .me가 경로에 동작(Behavior)을 부여하는 방식입니다.

예를 들어, 일반적인 호출은 값을 씁니다:

me.order.price(100);
me.order.quantity(5);

= 연산자는 파생(Derivation)을 생성합니다:

me.order["="]("total", "price * quantity");

me("order.total"); // 500

만약 의존성(Dependency)이 변경되면:

me.order.price(200);

me("order.total"); // 1000

파생된 경로(Derived path)는 의존성 그래프(Dependency graph)로부터 업데이트됩니다.

다른 연산자들은 트리에 더 많은 의미론 (semantics)을 부여합니다:

me.profile["_"]("secret-key");     // 비밀 범위 (secret scope)
me.profile["~"]("noise-key");      // 비밀 계보 경계 초기화 (reset secret lineage boundary)
me["@"]("sui-gn");                 // 신원 주장 (identity claim)
...

정확한 연산자는 작지만, 그 아이디어는 중요합니다:

일반적인 경로 (normal paths)는 의미를 기술합니다
연산자 (operators)는 의미가 저장, 연결, 파생 또는 보호되는 방식을 변경합니다

포인터 (Pointers)

포인터 (Pointers)를 사용하면 데이터를 복사하지 않고도 하나의 경로가 다른 경로를 참조할 수 있습니다.

예를 들어:

me.users.ana.name("Ana");
me.users.ana.city("Cordoba");

...

이제 친구 (friend) 항목이 사용자 (user) 항목을 가리킵니다:

me("friends.ana.name"); // "Ana"
me("friends.ana.city"); // "Cordoba"

포인터는 구조적입니다. 이는 단일 진실 공급원 (single source of truth)을 보존합니다.

만약 원본 경로가 변경된다면:

me.users.ana.city("Veracruz");

me("friends.ana.city"); // "Veracruz"

이는 복사 (copying)와는 다릅니다:

me.friends.ana.name("Ana");
me.friends.ana.city("Cordoba");

복사는 중복된 사실을 생성하지만, 포인터는 관계를 생성합니다.

비밀 범위 (Secret Scopes)

_ 연산자는 비밀 브랜치 (secret branch)를 생성합니다:

me.wallet["_"]("wallet-key");
me.wallet.balance(12480);

루트 (root)는 은닉 (stealth) 상태가 됩니다:

me("wallet"); // undefined

하지만 리프 (leaf)는 권한이 있는 로컬 커널 컨텍스트 (local kernel context)에 의해 여전히 읽힐 수 있습니다:

me("wallet.balance"); // 12480

따라서 비밀 유지 (secrecy)는 전역 모드가 아닙니다.

그것은 경로에 결합되어 있습니다.

wallet = 은닉된 루트 (stealth root)
wallet.balance = 암호화된 브랜치 리프 (encrypted branch leaf)

런타임 평면 (The Runtime Plane)

경계가 하나 더 있습니다: 커널 제어 (kernel controls)입니다.

대부분의 경로는 자유 형식입니다:

me.whatever.you.want("x");

하지만 런타임 검사 (runtime inspection) 및 제어는 예약된 이스케이프 평면 (reserved escape plane) 아래에 존재합니다:

me["!"]

예를 들어:

me["!"].inspect();
me["!"].explain("order.total");
me["!"].runtime.setRecomputeMode("lazy");

이는 사용자 의미론 (user semantics)을 커널 메커니즘 (kernel mechanics)과 분리합니다.

따라서:

me.whatever.you.want("x");

이는 의미론적 데이터 (semantic data)입니다.

그리고:

me["!"] .runtime.setRecomputeMode("lazy");

은 런타임 설정 (runtime configuration)입니다.

멘탈 모델 (The Mental Model)

가장 단순한 모델은 다음과 같습니다:

속성 접근 (property access)은 경로를 구축하고
함수 호출 (function call)은 해당 경로에 작용하며
연산자 (operators)는 특별한 동작을 부여합니다
...

따라서 이것은:

me.people.ana.likes.coffee(true);

의미론적 주장 (semantic claim)입니다:

people.ana.likes.coffee = true

이것은:

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

구조적 관계 (structural relationship)입니다.

이것은:

me.order["="]("total", "price * quantity");

파생된 사실 (derived fact)입니다.

그리고 이것은:

me.wallet["_"]("key");

프라이빗 브랜치 (private branch)입니다.

이것이 중요한 이유

대부분의 시스템은 먼저 스키마 (schema)를 정의한 다음, 데이터를 그에 맞게 끼워 넣도록 만듭니다.

.me는 의미가 경로로서 나타나게 합니다:

me.whatever.you.want("x");

그런 다음 연산자 (operators), 포인터 (pointers), 파생 (derivations), 프라이버시 범위 (privacy scopes), 리플레이 (replay), 스냅샷 (snapshots), 그리고 설명 가능성 (explainability)을 통해 해당 경로에 런타임 동작을 부여합니다.

이것이 설계 원칙입니다:

외부에는 자유로운 형식의 의미론 (free-form semantics)
내부에는 결정론적 커널 구조 (deterministic kernel structure)