@soundscript/soundscript 0.1.2 → 0.1.4

package/soundscript/result.sts

@@ -1,19 +1,91 @@
 import { normalizeThrown } from '@soundscript/soundscript/failures';
 import { type Bind, type Kind, type Kind2, type TypeLambda } from '@soundscript/soundscript/hkt';
 import { type Applicative, type Functor, type Monad } from '@soundscript/soundscript/typeclasses';
+import {
+  __valueFactory,
+  __valueKey,
+  __valueReadonly,
+  __valueShallowToken,
+} from '@soundscript/soundscript/value';
+
+const makeOk = __valueFactory<Ok<unknown>, [unknown]>(
+  (value) => __valueKey('ok', __valueShallowToken(value)),
+  () => Object.create(Ok.prototype) as Ok<unknown>,
+  (instance, value) => {
+    __valueReadonly(instance, 'tag', 'ok');
+    __valueReadonly(instance, 'value', value);
+  },
+);
+
+const makeErr = __valueFactory<Err<unknown>, [unknown]>(
+  (error) => __valueKey('err', __valueShallowToken(error)),
+  () => Object.create(Err.prototype) as Err<unknown>,
+  (instance, error) => {
+    __valueReadonly(instance, 'tag', 'err');
+    __valueReadonly(instance, 'error', error);
+  },
+);
+
+const makeSome = __valueFactory<Some<unknown>, [unknown]>(
+  (value) => __valueKey('some', __valueShallowToken(value)),
+  () => Object.create(Some.prototype) as Some<unknown>,
+  (instance, value) => {
+    __valueReadonly(instance, 'tag', 'some');
+    __valueReadonly(instance, 'value', value);
+  },
+);
+
+const makeNone = __valueFactory<None, []>(
+  () => __valueKey('none'),
+  () => Object.create(None.prototype) as None,
+  (instance) => {
+    __valueReadonly(instance, 'tag', 'none');
+  },
+);
 
 // #[variance(T: out)]
-export type Ok<T> = { readonly tag: 'ok'; readonly value: T };
+export class Ok<T> {
+  readonly tag!: 'ok';
+  readonly value!: T;
+
+  constructor(value: T) {
+    return makeOk(value) as Ok<T>;
+  }
+}
+
 // #[variance(E: out)]
-export type Err<E> = { readonly tag: 'err'; readonly error: E };
+export class Err<E> {
+  readonly tag!: 'err';
+  readonly error!: E;
+
+  constructor(error: E) {
+    return makeErr(error) as Err<E>;
+  }
+}
 
 // #[variance(T: out, E: out)]
 export type Result<T, E> = Ok<T> | Err<E>;
+
 // #[variance(T: out)]
-export type Some<T> = Ok<T>;
-export type None = Err<void>;
+export class Some<T> {
+  readonly tag!: 'some';
+  readonly value!: T;
+
+  constructor(value: T) {
+    return makeSome(value) as Some<T>;
+  }
+}
+
+export class None {
+  readonly tag!: 'none';
+
+  constructor() {
+    return makeNone();
+  }
+}
+
 // #[variance(T: out)]
-export type Option<T> = Result<T, void>;
+export type Option<T> = Some<T> | None;
 
 export interface OptionF extends TypeLambda {
   readonly type: Option<this['Args'][0]>;
@@ -27,44 +99,41 @@ export type OptionKind<T> = Kind<OptionF, T>;
 export type ResultKind<E, T> = Kind2<ResultF, E, T>;
 
 export function ok<T>(value: T): Result<T, never> {
-  return { tag: 'ok', value };
+  return new Ok(value);
 }
 
 export function err(): Result<never, void>;
 export function err<E>(error: E): Result<never, E>;
 export function err<E>(error?: E): Result<never, E | void> {
-  return { tag: 'err', error };
+  return new Err(error);
 }
 
 export function some<T>(value: T): Option<T> {
-  return ok(value);
+  return new Some(value);
 }
 
 export function none(): Option<never> {
-  return err();
+  return new None();
 }
 
 export function isOk<T, E>(value: Result<T, E>): value is Ok<T> {
-  return value.tag === 'ok';
+  return value instanceof Ok;
 }
 
 export function isErr<T, E>(value: Result<T, E>): value is Err<E> {
-  return value.tag === 'err';
+  return value instanceof Err;
 }
 
 export function isSome<T>(value: Option<T>): value is Some<T> {
-  return isOk(value);
+  return value instanceof Some;
 }
 
 export function isNone<T>(value: Option<T>): value is None {
-  return isErr(value);
+  return value instanceof None;
 }
 
-function isPromiseLike(value: unknown): value is PromiseLike<unknown> {
-  return (typeof value === 'object' || typeof value === 'function') &&
-    value !== null &&
-    'then' in value &&
-    typeof value.then === 'function';
+function isPromiseInstance<T>(value: unknown): value is Promise<T> {
+  return value instanceof Promise;
 }
 
 export function resultOf<T>(fn: () => Promise<T>): Promise<Result<T, Error>>;
@@ -80,8 +149,8 @@ export function resultOf<T, E>(
 ): Result<T, E | Error> | Promise<Result<T, E | Error>> {
   try {
     const value = fn();
-    if (isPromiseLike(value)) {
-      return Promise.resolve(value as PromiseLike<T>).then(
+    if (isPromiseInstance<T>(value)) {
+      return value.then(
         (resolved) => ok(resolved),
         (error) => {
           const normalized = normalizeThrown(error);
@@ -97,21 +166,21 @@ export function resultOf<T, E>(
 }
 
 function mapOption<A, B>(value: Option<A>, f: (value: A) => B): Option<B> {
-  return isOk(value) ? ok(f(value.value)) : value;
+  return isSome(value) ? some(f(value.value)) : value;
 }
 
 function apOption<A, B>(
   fn: Option<(value: A) => B>,
   value: Option<A>,
 ): Option<B> {
-  if (!isOk(fn)) {
+  if (!isSome(fn)) {
     return fn;
   }
-  return isOk(value) ? ok(fn.value(value.value)) : value;
+  return isSome(value) ? some(fn.value(value.value)) : value;
 }
 
 function flatMapOption<A, B>(value: Option<A>, f: (value: A) => Option<B>): Option<B> {
-  return isOk(value) ? f(value.value) : value;
+  return isSome(value) ? f(value.value) : value;
 }
 
 const optionMonadImpl: Monad<OptionF> = {

package/soundscript/typeclasses.sts

@@ -29,7 +29,7 @@ export interface Monad<F extends TypeLambda> extends Applicative<F> {
 }
 
 export interface AsyncMonad<F extends TypeLambda> extends Monad<F> {
-  fromPromise<A>(promise: PromiseLike<A>): Kind<F, A>;
+  fromPromise<A>(promise: Promise<A>): Kind<F, A>;
 }
 
 function runGenerator<F extends TypeLambda, T>(
@@ -53,7 +53,7 @@ export function monadGen<F extends TypeLambda, T>(
 }
 
 function bindValue<F extends TypeLambda>(_monad: Monad<F>) {
-  return function <A>(_effect: BoundEffect<F, A>, value: unknown): A {
+  return function bindRuntimeValue<A>(_effect: BoundEffect<F, A>, value: unknown): A {
     return value as A;
   };
 }
@@ -61,7 +61,11 @@ function bindValue<F extends TypeLambda>(_monad: Monad<F>) {
 export type DoBinder<M extends Monad<TypeLambda>> = Binder<MonadTypeLambda<M>>;
 
 class DoBindSignal<F extends TypeLambda> {
-  constructor(readonly effect: Kind<F, unknown>) {}
+  readonly effect: Kind<F, unknown>;
+
+  constructor(effect: Kind<F, unknown>) {
+    this.effect = effect;
+  }
 }
 
 function executeDoBody<F extends TypeLambda, T>(
@@ -69,12 +73,12 @@ function executeDoBody<F extends TypeLambda, T>(
   resolvedValues: readonly unknown[],
 ): { done: true; value: T } | { done: false; effect: Kind<F, unknown> } {
   let index = 0;
-  const bind: Binder<F> = <A>(effect: BoundEffect<F, A>): A => {
+  function bind<A>(effect: BoundEffect<F, A>): A {
     if (index < resolvedValues.length) {
       return resolvedValues[index++] as A;
     }
     throw new DoBindSignal(effect);
-  };
+  }
 
   try {
     return { done: true, value: body(bind) };
@@ -87,16 +91,16 @@ function executeDoBody<F extends TypeLambda, T>(
 }
 
 async function executeAsyncDoBody<F extends TypeLambda, T>(
-  body: (bind: Binder<F>) => T | PromiseLike<T>,
+  body: (bind: Binder<F>) => T | Promise<T>,
   resolvedValues: readonly unknown[],
 ): Promise<{ done: true; value: T } | { done: false; effect: Kind<F, unknown> }> {
   let index = 0;
-  const bind: Binder<F> = <A>(effect: BoundEffect<F, A>): A => {
+  function bind<A>(effect: BoundEffect<F, A>): A {
     if (index < resolvedValues.length) {
       return resolvedValues[index++] as A;
     }
     throw new DoBindSignal(effect);
-  };
+  }
 
   try {
     return { done: true, value: await body(bind) };
@@ -122,7 +126,7 @@ function runDo<F extends TypeLambda, T>(
 
 function runAsyncDo<F extends TypeLambda, T>(
   monad: AsyncMonad<F>,
-  body: (bind: Binder<F>) => T | PromiseLike<T>,
+  body: (bind: Binder<F>) => T | Promise<T>,
   resolvedValues: readonly unknown[] = [],
 ): Kind<F, T> {
   return monad.flatMap(
@@ -142,7 +146,7 @@ export interface DoRuntime {
   ): Kind<F, T>;
   <F extends TypeLambda, T>(
     monad: AsyncMonad<F>,
-    body: (bind: Binder<F>) => T | PromiseLike<T>,
+    body: (bind: Binder<F>) => T | Promise<T>,
   ): Kind<F, T>;
   readonly macroBind: <F extends TypeLambda>(
     monad: Monad<F>,
@@ -151,16 +155,18 @@ export interface DoRuntime {
 }
 
 function createDoRuntime(): DoRuntime {
-  const runtime = (<F extends TypeLambda, T>(
+  function runtime<F extends TypeLambda, T>(
     monad: Monad<F>,
-    body: (bind: Binder<F>) => T | PromiseLike<T>,
-  ): Kind<F, T> => {
+    body: (bind: Binder<F>) => T | Promise<T>,
+  ): Kind<F, T> {
     return 'fromPromise' in monad
       ? runAsyncDo(monad as AsyncMonad<F>, body, [])
       : runDo(monad, body as (bind: Binder<F>) => T, []);
-  }) as DoRuntime;
-  Object.assign(runtime, { macroBind: bindValue, macroGen: monadGen });
-  return runtime;
+  }
+
+  const doRuntime = runtime as DoRuntime;
+  Object.assign(doRuntime, { macroBind: bindValue, macroGen: monadGen });
+  return doRuntime;
 }
 
 // The compiler lowers `Do(...)` to `Do.macroGen(...)`, but keep a callable runtime bridge.

package/soundscript/value.sts

@@ -0,0 +1,133 @@
+type ValueFactoryArgs<TArgs extends readonly unknown[]> = TArgs;
+
+const REFERENCE_IDS = new WeakMap<object, number>();
+const SYMBOL_IDS = new Map<symbol, number>();
+const VALUE_IDS = new WeakMap<object, number>();
+
+let nextValueIdentity = 1;
+
+function nextIdentityId(): number {
+  const id = nextValueIdentity;
+  nextValueIdentity += 1;
+  return id;
+}
+
+function normalizeNumberToken(value: number): string {
+  if (Number.isNaN(value)) {
+    return 'NaN';
+  }
+  if (value === 0) {
+    return '0';
+  }
+  return String(value);
+}
+
+function referenceIdentity(value: object): number {
+  const existing = REFERENCE_IDS.get(value);
+  if (existing !== undefined) {
+    return existing;
+  }
+
+  const created = nextIdentityId();
+  REFERENCE_IDS.set(value, created);
+  return created;
+}
+
+function symbolIdentity(value: symbol): number {
+  const existing = SYMBOL_IDS.get(value);
+  if (existing !== undefined) {
+    return existing;
+  }
+
+  const created = nextIdentityId();
+  SYMBOL_IDS.set(value, created);
+  return created;
+}
+
+function tryValueIdentity(value: object): number | undefined {
+  return VALUE_IDS.get(value);
+}
+
+function tokenFor(value: unknown, deep: boolean): string {
+  switch (typeof value) {
+    case 'undefined':
+      return 'undefined';
+    case 'boolean':
+      return value ? 'boolean:true' : 'boolean:false';
+    case 'number':
+      return `number:${normalizeNumberToken(value)}`;
+    case 'bigint':
+      return `bigint:${value.toString()}`;
+    case 'string':
+      return `string:${JSON.stringify(value)}`;
+    case 'symbol':
+      return `symbol:${symbolIdentity(value)}`;
+    case 'function':
+      return `ref:${referenceIdentity(value)}`;
+    case 'object':
+      if (value === null) {
+        return 'null';
+      }
+
+      {
+        const identity = tryValueIdentity(value);
+        if (identity !== undefined) {
+          return `value:${identity}`;
+        }
+      }
+
+      if (deep) {
+        throw new TypeError('Deep value fields must be recursively deep-safe.');
+      }
+
+      return `ref:${referenceIdentity(value)}`;
+  }
+}
+
+export function __valueShallowToken(value: unknown): string {
+  return tokenFor(value, false);
+}
+
+export function __valueDeepToken(value: unknown): string {
+  return tokenFor(value, true);
+}
+
+export function __valueKey(...tokens: readonly string[]): string {
+  return JSON.stringify(tokens);
+}
+
+export function __valueReadonly(
+  target: object,
+  key: PropertyKey,
+  value: unknown,
+): void {
+  Object.defineProperty(target, key, {
+    value,
+    enumerable: true,
+    writable: false,
+    configurable: false,
+  });
+}
+
+export function __valueFactory<T extends object, TArgs extends readonly unknown[]>(
+  keyOf: (...args: ValueFactoryArgs<TArgs>) => string,
+  allocate: () => T,
+  init: (instance: T, ...args: ValueFactoryArgs<TArgs>) => void,
+): (...args: ValueFactoryArgs<TArgs>) => T {
+  const cache = new Map<string, T>();
+
+  return (...args: ValueFactoryArgs<TArgs>): T => {
+    const key = keyOf(...args);
+    const existing = cache.get(key);
+    if (existing !== undefined) {
+      return existing;
+    }
+
+    const instance = allocate();
+    init(instance, ...args);
+    VALUE_IDS.set(instance, nextIdentityId());
+    Object.freeze(instance);
+    cache.set(key, instance);
+    return instance;
+  };
+}

package/typeclasses.d.ts

@@ -29,7 +29,7 @@ export interface Monad<F extends TypeLambda> extends Applicative<F> {
 }
 
 export interface AsyncMonad<F extends TypeLambda> extends Monad<F> {
-  fromPromise<A>(promise: PromiseLike<A>): Kind<F, A>;
+  fromPromise<A>(promise: Promise<A>): Kind<F, A>;
 }
 
 export function monadGen<F extends TypeLambda, T>(
@@ -46,7 +46,7 @@ export interface DoRuntime {
   ): Kind<F, T>;
   <F extends TypeLambda, T>(
     monad: AsyncMonad<F>,
-    body: (bind: Binder<F>) => T | PromiseLike<T>,
+    body: (bind: Binder<F>) => T | Promise<T>,
   ): Kind<F, T>;
   readonly macroBind: <F extends TypeLambda>(
     monad: Monad<F>,

package/typeclasses.js

@@ -9,7 +9,7 @@ export function monadGen(monad, factory) {
     return runGenerator(monad, factory());
 }
 function bindValue(_monad) {
-    return function (_effect, value) {
+    return function bindRuntimeValue(_effect, value) {
         return value;
     };
 }
@@ -20,12 +20,12 @@ class DoBindSignal {
 }
 function executeDoBody(body, resolvedValues) {
     let index = 0;
-    const bind = (effect) => {
+    function bind(effect) {
         if (index < resolvedValues.length) {
             return resolvedValues[index++];
         }
         throw new DoBindSignal(effect);
-    };
+    }
     try {
         return { done: true, value: body(bind) };
     }
@@ -38,12 +38,12 @@ function executeDoBody(body, resolvedValues) {
 }
 async function executeAsyncDoBody(body, resolvedValues) {
     let index = 0;
-    const bind = (effect) => {
+    function bind(effect) {
         if (index < resolvedValues.length) {
             return resolvedValues[index++];
         }
         throw new DoBindSignal(effect);
-    };
+    }
     try {
         return { done: true, value: await body(bind) };
     }
@@ -65,13 +65,14 @@ function runAsyncDo(monad, body, resolvedValues = []) {
     return monad.flatMap(monad.fromPromise(executeAsyncDoBody(body, resolvedValues)), (step) => step.done ? monad.pure(step.value) : monad.flatMap(step.effect, (value) => runAsyncDo(monad, body, [...resolvedValues, value])));
 }
 function createDoRuntime() {
-    const runtime = ((monad, body) => {
+    function runtime(monad, body) {
         return 'fromPromise' in monad
             ? runAsyncDo(monad, body, [])
             : runDo(monad, body, []);
-    });
-    Object.assign(runtime, { macroBind: bindValue, macroGen: monadGen });
-    return runtime;
+    }
+    const doRuntime = runtime;
+    Object.assign(doRuntime, { macroBind: bindValue, macroGen: monadGen });
+    return doRuntime;
 }
 // The compiler lowers `Do(...)` to `Do.macroGen(...)`, but keep a callable runtime bridge.
 export const Do = createDoRuntime();

package/typeclasses.js.map

@@ -1 +1 @@
-{"version":3,"file":"typeclasses.js","sourceRoot":"","sources":["./soundscript/typeclasses.sts"],"names":[],"mappings":"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","sourcesContent":["import type { Binder, BoundEffect, Kind, MonadTypeLambda, TypeLambda } from '@soundscript/soundscript/hkt';\n\nexport interface Contravariant<F extends TypeLambda> {\n  readonly __type_lambda?: F;\n  contramap<A, B>(value: Kind<F, A>, project: (value: B) => A): Kind<F, B>;\n}\n\nexport interface Invariant<F extends TypeLambda> {\n  readonly __type_lambda?: F;\n  imap<A, B>(\n    value: Kind<F, A>,\n    decodeMap: (value: A) => B,\n    encodeMap: (value: B) => A,\n  ): Kind<F, B>;\n}\n\nexport interface Functor<F extends TypeLambda> {\n  readonly __type_lambda?: F;\n  map<A, B>(value: Kind<F, A>, f: (value: A) => B): Kind<F, B>;\n}\n\nexport interface Applicative<F extends TypeLambda> extends Functor<F> {\n  ap<A, B>(fn: Kind<F, (value: A) => B>, value: Kind<F, A>): Kind<F, B>;\n  pure<A>(value: A): Kind<F, A>;\n}\n\nexport interface Monad<F extends TypeLambda> extends Applicative<F> {\n  flatMap<A, B>(value: Kind<F, A>, f: (value: A) => Kind<F, B>): Kind<F, B>;\n}\n\nexport interface AsyncMonad<F extends TypeLambda> extends Monad<F> {\n  fromPromise<A>(promise: PromiseLike<A>): Kind<F, A>;\n}\n\nfunction runGenerator<F extends TypeLambda, T>(\n  monad: Monad<F>,\n  iterator: Generator<Kind<F, unknown>, T, unknown>,\n  input?: unknown,\n): Kind<F, T> {\n  const step = iterator.next(input as never);\n  if (step.done) {\n    return monad.pure(step.value);\n  }\n\n  return monad.flatMap(step.value, (nextInput) => runGenerator(monad, iterator, nextInput));\n}\n\nexport function monadGen<F extends TypeLambda, T>(\n  monad: Monad<F>,\n  factory: () => Generator<Kind<F, unknown>, T, unknown>,\n): Kind<F, T> {\n  return runGenerator(monad, factory());\n}\n\nfunction bindValue<F extends TypeLambda>(_monad: Monad<F>) {\n  return function <A>(_effect: BoundEffect<F, A>, value: unknown): A {\n    return value as A;\n  };\n}\n\nexport type DoBinder<M extends Monad<TypeLambda>> = Binder<MonadTypeLambda<M>>;\n\nclass DoBindSignal<F extends TypeLambda> {\n  constructor(readonly effect: Kind<F, unknown>) {}\n}\n\nfunction executeDoBody<F extends TypeLambda, T>(\n  body: (bind: Binder<F>) => T,\n  resolvedValues: readonly unknown[],\n): { done: true; value: T } | { done: false; effect: Kind<F, unknown> } {\n  let index = 0;\n  const bind: Binder<F> = <A>(effect: BoundEffect<F, A>): A => {\n    if (index < resolvedValues.length) {\n      return resolvedValues[index++] as A;\n    }\n    throw new DoBindSignal(effect);\n  };\n\n  try {\n    return { done: true, value: body(bind) };\n  } catch (error) {\n    if (error instanceof DoBindSignal) {\n      return { done: false, effect: error.effect };\n    }\n    throw error;\n  }\n}\n\nasync function executeAsyncDoBody<F extends TypeLambda, T>(\n  body: (bind: Binder<F>) => T | PromiseLike<T>,\n  resolvedValues: readonly unknown[],\n): Promise<{ done: true; value: T } | { done: false; effect: Kind<F, unknown> }> {\n  let index = 0;\n  const bind: Binder<F> = <A>(effect: BoundEffect<F, A>): A => {\n    if (index < resolvedValues.length) {\n      return resolvedValues[index++] as A;\n    }\n    throw new DoBindSignal(effect);\n  };\n\n  try {\n    return { done: true, value: await body(bind) };\n  } catch (error) {\n    if (error instanceof DoBindSignal) {\n      return { done: false, effect: error.effect };\n    }\n    throw error;\n  }\n}\n\nfunction runDo<F extends TypeLambda, T>(\n  monad: Monad<F>,\n  body: (bind: Binder<F>) => T,\n  resolvedValues: readonly unknown[] = [],\n): Kind<F, T> {\n  const step = executeDoBody(body, resolvedValues);\n  if (step.done) {\n    return monad.pure(step.value);\n  }\n  return monad.flatMap(step.effect, (value) => runDo(monad, body, [...resolvedValues, value]));\n}\n\nfunction runAsyncDo<F extends TypeLambda, T>(\n  monad: AsyncMonad<F>,\n  body: (bind: Binder<F>) => T | PromiseLike<T>,\n  resolvedValues: readonly unknown[] = [],\n): Kind<F, T> {\n  return monad.flatMap(\n    monad.fromPromise(executeAsyncDoBody(body, resolvedValues)),\n    (step) =>\n      step.done ? monad.pure(step.value) : monad.flatMap(\n        step.effect,\n        (value) => runAsyncDo(monad, body, [...resolvedValues, value]),\n      ),\n  );\n}\n\nexport interface DoRuntime {\n  <F extends TypeLambda, T>(\n    monad: Monad<F>,\n    body: (bind: Binder<F>) => T,\n  ): Kind<F, T>;\n  <F extends TypeLambda, T>(\n    monad: AsyncMonad<F>,\n    body: (bind: Binder<F>) => T | PromiseLike<T>,\n  ): Kind<F, T>;\n  readonly macroBind: <F extends TypeLambda>(\n    monad: Monad<F>,\n  ) => <A>(effect: BoundEffect<F, A>, value: unknown) => A;\n  readonly macroGen: typeof monadGen;\n}\n\nfunction createDoRuntime(): DoRuntime {\n  const runtime = (<F extends TypeLambda, T>(\n    monad: Monad<F>,\n    body: (bind: Binder<F>) => T | PromiseLike<T>,\n  ): Kind<F, T> => {\n    return 'fromPromise' in monad\n      ? runAsyncDo(monad as AsyncMonad<F>, body, [])\n      : runDo(monad, body as (bind: Binder<F>) => T, []);\n  }) as DoRuntime;\n  Object.assign(runtime, { macroBind: bindValue, macroGen: monadGen });\n  return runtime;\n}\n\n// The compiler lowers `Do(...)` to `Do.macroGen(...)`, but keep a callable runtime bridge.\nexport const Do = createDoRuntime();\n"]}
+{"version":3,"file":"typeclasses.js","sourceRoot":"","sources":["./soundscript/typeclasses.sts"],"names":[],"mappings":"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","sourcesContent":["import type { Binder, BoundEffect, Kind, MonadTypeLambda, TypeLambda } from '@soundscript/soundscript/hkt';\n\nexport interface Contravariant<F extends TypeLambda> {\n  readonly __type_lambda?: F;\n  contramap<A, B>(value: Kind<F, A>, project: (value: B) => A): Kind<F, B>;\n}\n\nexport interface Invariant<F extends TypeLambda> {\n  readonly __type_lambda?: F;\n  imap<A, B>(\n    value: Kind<F, A>,\n    decodeMap: (value: A) => B,\n    encodeMap: (value: B) => A,\n  ): Kind<F, B>;\n}\n\nexport interface Functor<F extends TypeLambda> {\n  readonly __type_lambda?: F;\n  map<A, B>(value: Kind<F, A>, f: (value: A) => B): Kind<F, B>;\n}\n\nexport interface Applicative<F extends TypeLambda> extends Functor<F> {\n  ap<A, B>(fn: Kind<F, (value: A) => B>, value: Kind<F, A>): Kind<F, B>;\n  pure<A>(value: A): Kind<F, A>;\n}\n\nexport interface Monad<F extends TypeLambda> extends Applicative<F> {\n  flatMap<A, B>(value: Kind<F, A>, f: (value: A) => Kind<F, B>): Kind<F, B>;\n}\n\nexport interface AsyncMonad<F extends TypeLambda> extends Monad<F> {\n  fromPromise<A>(promise: Promise<A>): Kind<F, A>;\n}\n\nfunction runGenerator<F extends TypeLambda, T>(\n  monad: Monad<F>,\n  iterator: Generator<Kind<F, unknown>, T, unknown>,\n  input?: unknown,\n): Kind<F, T> {\n  const step = iterator.next(input as never);\n  if (step.done) {\n    return monad.pure(step.value);\n  }\n\n  return monad.flatMap(step.value, (nextInput) => runGenerator(monad, iterator, nextInput));\n}\n\nexport function monadGen<F extends TypeLambda, T>(\n  monad: Monad<F>,\n  factory: () => Generator<Kind<F, unknown>, T, unknown>,\n): Kind<F, T> {\n  return runGenerator(monad, factory());\n}\n\nfunction bindValue<F extends TypeLambda>(_monad: Monad<F>) {\n  return function bindRuntimeValue<A>(_effect: BoundEffect<F, A>, value: unknown): A {\n    return value as A;\n  };\n}\n\nexport type DoBinder<M extends Monad<TypeLambda>> = Binder<MonadTypeLambda<M>>;\n\nclass DoBindSignal<F extends TypeLambda> {\n  readonly effect: Kind<F, unknown>;\n\n  constructor(effect: Kind<F, unknown>) {\n    this.effect = effect;\n  }\n}\n\nfunction executeDoBody<F extends TypeLambda, T>(\n  body: (bind: Binder<F>) => T,\n  resolvedValues: readonly unknown[],\n): { done: true; value: T } | { done: false; effect: Kind<F, unknown> } {\n  let index = 0;\n  function bind<A>(effect: BoundEffect<F, A>): A {\n    if (index < resolvedValues.length) {\n      return resolvedValues[index++] as A;\n    }\n    throw new DoBindSignal(effect);\n  }\n\n  try {\n    return { done: true, value: body(bind) };\n  } catch (error) {\n    if (error instanceof DoBindSignal) {\n      return { done: false, effect: error.effect };\n    }\n    throw error;\n  }\n}\n\nasync function executeAsyncDoBody<F extends TypeLambda, T>(\n  body: (bind: Binder<F>) => T | Promise<T>,\n  resolvedValues: readonly unknown[],\n): Promise<{ done: true; value: T } | { done: false; effect: Kind<F, unknown> }> {\n  let index = 0;\n  function bind<A>(effect: BoundEffect<F, A>): A {\n    if (index < resolvedValues.length) {\n      return resolvedValues[index++] as A;\n    }\n    throw new DoBindSignal(effect);\n  }\n\n  try {\n    return { done: true, value: await body(bind) };\n  } catch (error) {\n    if (error instanceof DoBindSignal) {\n      return { done: false, effect: error.effect };\n    }\n    throw error;\n  }\n}\n\nfunction runDo<F extends TypeLambda, T>(\n  monad: Monad<F>,\n  body: (bind: Binder<F>) => T,\n  resolvedValues: readonly unknown[] = [],\n): Kind<F, T> {\n  const step = executeDoBody(body, resolvedValues);\n  if (step.done) {\n    return monad.pure(step.value);\n  }\n  return monad.flatMap(step.effect, (value) => runDo(monad, body, [...resolvedValues, value]));\n}\n\nfunction runAsyncDo<F extends TypeLambda, T>(\n  monad: AsyncMonad<F>,\n  body: (bind: Binder<F>) => T | Promise<T>,\n  resolvedValues: readonly unknown[] = [],\n): Kind<F, T> {\n  return monad.flatMap(\n    monad.fromPromise(executeAsyncDoBody(body, resolvedValues)),\n    (step) =>\n      step.done ? monad.pure(step.value) : monad.flatMap(\n        step.effect,\n        (value) => runAsyncDo(monad, body, [...resolvedValues, value]),\n      ),\n  );\n}\n\nexport interface DoRuntime {\n  <F extends TypeLambda, T>(\n    monad: Monad<F>,\n    body: (bind: Binder<F>) => T,\n  ): Kind<F, T>;\n  <F extends TypeLambda, T>(\n    monad: AsyncMonad<F>,\n    body: (bind: Binder<F>) => T | Promise<T>,\n  ): Kind<F, T>;\n  readonly macroBind: <F extends TypeLambda>(\n    monad: Monad<F>,\n  ) => <A>(effect: BoundEffect<F, A>, value: unknown) => A;\n  readonly macroGen: typeof monadGen;\n}\n\nfunction createDoRuntime(): DoRuntime {\n  function runtime<F extends TypeLambda, T>(\n    monad: Monad<F>,\n    body: (bind: Binder<F>) => T | Promise<T>,\n  ): Kind<F, T> {\n    return 'fromPromise' in monad\n      ? runAsyncDo(monad as AsyncMonad<F>, body, [])\n      : runDo(monad, body as (bind: Binder<F>) => T, []);\n  }\n\n  const doRuntime = runtime as DoRuntime;\n  Object.assign(doRuntime, { macroBind: bindValue, macroGen: monadGen });\n  return doRuntime;\n}\n\n// The compiler lowers `Do(...)` to `Do.macroGen(...)`, but keep a callable runtime bridge.\nexport const Do = createDoRuntime();\n"]}

package/value.d.ts

@@ -0,0 +1,9 @@
+export function __valueShallowToken(value: unknown): string;
+export function __valueDeepToken(value: unknown): string;
+export function __valueKey(...tokens: readonly string[]): string;
+export function __valueReadonly(target: object, key: PropertyKey, value: unknown): void;
+export function __valueFactory<T extends object, TArgs extends readonly unknown[]>(
+  keyOf: (...args: TArgs) => string,
+  allocate: () => T,
+  init: (instance: T, ...args: TArgs) => void,
+): (...args: TArgs) => T;

package/value.js

@@ -0,0 +1,105 @@
+const REFERENCE_IDS = new WeakMap();
+const SYMBOL_IDS = new Map();
+const VALUE_IDS = new WeakMap();
+let nextValueIdentity = 1;
+function nextIdentityId() {
+    const id = nextValueIdentity;
+    nextValueIdentity += 1;
+    return id;
+}
+function normalizeNumberToken(value) {
+    if (Number.isNaN(value)) {
+        return 'NaN';
+    }
+    if (value === 0) {
+        return '0';
+    }
+    return String(value);
+}
+function referenceIdentity(value) {
+    const existing = REFERENCE_IDS.get(value);
+    if (existing !== undefined) {
+        return existing;
+    }
+    const created = nextIdentityId();
+    REFERENCE_IDS.set(value, created);
+    return created;
+}
+function symbolIdentity(value) {
+    const existing = SYMBOL_IDS.get(value);
+    if (existing !== undefined) {
+        return existing;
+    }
+    const created = nextIdentityId();
+    SYMBOL_IDS.set(value, created);
+    return created;
+}
+function tryValueIdentity(value) {
+    return VALUE_IDS.get(value);
+}
+function tokenFor(value, deep) {
+    switch (typeof value) {
+        case 'undefined':
+            return 'undefined';
+        case 'boolean':
+            return value ? 'boolean:true' : 'boolean:false';
+        case 'number':
+            return `number:${normalizeNumberToken(value)}`;
+        case 'bigint':
+            return `bigint:${value.toString()}`;
+        case 'string':
+            return `string:${JSON.stringify(value)}`;
+        case 'symbol':
+            return `symbol:${symbolIdentity(value)}`;
+        case 'function':
+            return `ref:${referenceIdentity(value)}`;
+        case 'object':
+            if (value === null) {
+                return 'null';
+            }
+            {
+                const identity = tryValueIdentity(value);
+                if (identity !== undefined) {
+                    return `value:${identity}`;
+                }
+            }
+            if (deep) {
+                throw new TypeError('Deep value fields must be recursively deep-safe.');
+            }
+            return `ref:${referenceIdentity(value)}`;
+    }
+}
+export function __valueShallowToken(value) {
+    return tokenFor(value, false);
+}
+export function __valueDeepToken(value) {
+    return tokenFor(value, true);
+}
+export function __valueKey(...tokens) {
+    return JSON.stringify(tokens);
+}
+export function __valueReadonly(target, key, value) {
+    Object.defineProperty(target, key, {
+        value,
+        enumerable: true,
+        writable: false,
+        configurable: false,
+    });
+}
+export function __valueFactory(keyOf, allocate, init) {
+    const cache = new Map();
+    return (...args) => {
+        const key = keyOf(...args);
+        const existing = cache.get(key);
+        if (existing !== undefined) {
+            return existing;
+        }
+        const instance = allocate();
+        init(instance, ...args);
+        VALUE_IDS.set(instance, nextIdentityId());
+        Object.freeze(instance);
+        cache.set(key, instance);
+        return instance;
+    };
+}
+//# sourceMappingURL=value.js.map