@soundscript/soundscript 0.1.13 → 0.1.15

package/project-transform/src/stdlib/typeclasses.d.ts

@@ -0,0 +1,57 @@
+import type { Binder, BoundEffect, Kind, MonadTypeLambda, TypeLambda } from 'sts:hkt';
+
+export interface Contravariant<F extends TypeLambda> {
+  readonly __type_lambda?: F;
+  contramap<A, B>(value: Kind<F, A>, project: (value: B) => A): Kind<F, B>;
+}
+
+export interface Invariant<F extends TypeLambda> {
+  readonly __type_lambda?: F;
+  imap<A, B>(
+    value: Kind<F, A>,
+    decodeMap: (value: A) => B,
+    encodeMap: (value: B) => A,
+  ): Kind<F, B>;
+}
+
+export interface Functor<F extends TypeLambda> {
+  readonly __type_lambda?: F;
+  map<A, B>(value: Kind<F, A>, f: (value: A) => B): Kind<F, B>;
+}
+
+export interface Applicative<F extends TypeLambda> extends Functor<F> {
+  ap<A, B>(fn: Kind<F, (value: A) => B>, value: Kind<F, A>): Kind<F, B>;
+  pure<A>(value: A): Kind<F, A>;
+}
+
+export interface Monad<F extends TypeLambda> extends Applicative<F> {
+  flatMap<A, B>(value: Kind<F, A>, f: (value: A) => Kind<F, B>): Kind<F, B>;
+}
+
+export interface AsyncMonad<F extends TypeLambda> extends Monad<F> {
+  fromPromise<A>(promise: Promise<A>): Kind<F, A>;
+}
+
+export function monadGen<F extends TypeLambda, T>(
+  monad: Monad<F>,
+  factory: () => Generator<Kind<F, unknown>, T, unknown>,
+): Kind<F, T>;
+
+export type DoBinder<M extends Monad<TypeLambda>> = Binder<MonadTypeLambda<M>>;
+
+export interface DoRuntime {
+  <F extends TypeLambda, T>(
+    monad: Monad<F>,
+    body: (bind: Binder<F>) => T,
+  ): Kind<F, T>;
+  <F extends TypeLambda, T>(
+    monad: AsyncMonad<F>,
+    body: (bind: Binder<F>) => T | Promise<T>,
+  ): Kind<F, T>;
+  readonly macroBind: <F extends TypeLambda>(
+    monad: Monad<F>,
+  ) => <A>(effect: BoundEffect<F, A>, value: unknown) => A;
+  readonly macroGen: typeof monadGen;
+}
+
+export const Do: DoRuntime;

package/project-transform/src/stdlib/typeclasses.js

@@ -0,0 +1,78 @@
+function runGenerator(monad, iterator, input) {
+    const step = iterator.next(input);
+    if (step.done) {
+        return monad.pure(step.value);
+    }
+    return monad.flatMap(step.value, (nextInput) => runGenerator(monad, iterator, nextInput));
+}
+export function monadGen(monad, factory) {
+    return runGenerator(monad, factory());
+}
+function bindValue(_monad) {
+    return function bindRuntimeValue(_effect, value) {
+        return value;
+    };
+}
+class DoBindSignal {
+    constructor(effect) {
+        this.effect = effect;
+    }
+}
+function executeDoBody(body, resolvedValues) {
+    let index = 0;
+    function bind(effect) {
+        if (index < resolvedValues.length) {
+            return resolvedValues[index++];
+        }
+        throw new DoBindSignal(effect);
+    }
+    try {
+        return { done: true, value: body(bind) };
+    }
+    catch (error) {
+        if (error instanceof DoBindSignal) {
+            return { done: false, effect: error.effect };
+        }
+        throw error;
+    }
+}
+async function executeAsyncDoBody(body, resolvedValues) {
+    let index = 0;
+    function bind(effect) {
+        if (index < resolvedValues.length) {
+            return resolvedValues[index++];
+        }
+        throw new DoBindSignal(effect);
+    }
+    try {
+        return { done: true, value: await body(bind) };
+    }
+    catch (error) {
+        if (error instanceof DoBindSignal) {
+            return { done: false, effect: error.effect };
+        }
+        throw error;
+    }
+}
+function runDo(monad, body, resolvedValues = []) {
+    const step = executeDoBody(body, resolvedValues);
+    if (step.done) {
+        return monad.pure(step.value);
+    }
+    return monad.flatMap(step.effect, (value) => runDo(monad, body, [...resolvedValues, value]));
+}
+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() {
+    function runtime(monad, body) {
+        return 'fromPromise' in monad
+            ? runAsyncDo(monad, body, [])
+            : runDo(monad, body, []);
+    }
+    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/project-transform/src/stdlib/typeclasses.ts

@@ -0,0 +1,173 @@
+import type { Binder, BoundEffect, Kind, MonadTypeLambda, TypeLambda } from 'sts:hkt';
+
+export interface Contravariant<F extends TypeLambda> {
+  readonly __type_lambda?: F;
+  contramap<A, B>(value: Kind<F, A>, project: (value: B) => A): Kind<F, B>;
+}
+
+export interface Invariant<F extends TypeLambda> {
+  readonly __type_lambda?: F;
+  imap<A, B>(
+    value: Kind<F, A>,
+    decodeMap: (value: A) => B,
+    encodeMap: (value: B) => A,
+  ): Kind<F, B>;
+}
+
+export interface Functor<F extends TypeLambda> {
+  readonly __type_lambda?: F;
+  map<A, B>(value: Kind<F, A>, f: (value: A) => B): Kind<F, B>;
+}
+
+export interface Applicative<F extends TypeLambda> extends Functor<F> {
+  ap<A, B>(fn: Kind<F, (value: A) => B>, value: Kind<F, A>): Kind<F, B>;
+  pure<A>(value: A): Kind<F, A>;
+}
+
+export interface Monad<F extends TypeLambda> extends Applicative<F> {
+  flatMap<A, B>(value: Kind<F, A>, f: (value: A) => Kind<F, B>): Kind<F, B>;
+}
+
+export interface AsyncMonad<F extends TypeLambda> extends Monad<F> {
+  fromPromise<A>(promise: Promise<A>): Kind<F, A>;
+}
+
+function runGenerator<F extends TypeLambda, T>(
+  monad: Monad<F>,
+  iterator: Generator<Kind<F, unknown>, T, unknown>,
+  input?: unknown,
+): Kind<F, T> {
+  const step = iterator.next(input as never);
+  if (step.done) {
+    return monad.pure(step.value);
+  }
+
+  return monad.flatMap(step.value, (nextInput) => runGenerator(monad, iterator, nextInput));
+}
+
+export function monadGen<F extends TypeLambda, T>(
+  monad: Monad<F>,
+  factory: () => Generator<Kind<F, unknown>, T, unknown>,
+): Kind<F, T> {
+  return runGenerator(monad, factory());
+}
+
+function bindValue<F extends TypeLambda>(_monad: Monad<F>) {
+  return function bindRuntimeValue<A>(_effect: BoundEffect<F, A>, value: unknown): A {
+    return value as A;
+  };
+}
+
+export type DoBinder<M extends Monad<TypeLambda>> = Binder<MonadTypeLambda<M>>;
+
+class DoBindSignal<F extends TypeLambda> {
+  readonly effect: Kind<F, unknown>;
+
+  constructor(effect: Kind<F, unknown>) {
+    this.effect = effect;
+  }
+}
+
+function executeDoBody<F extends TypeLambda, T>(
+  body: (bind: Binder<F>) => T,
+  resolvedValues: readonly unknown[],
+): { done: true; value: T } | { done: false; effect: Kind<F, unknown> } {
+  let index = 0;
+  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) };
+  } catch (error) {
+    if (error instanceof DoBindSignal) {
+      return { done: false, effect: error.effect };
+    }
+    throw error;
+  }
+}
+
+async function executeAsyncDoBody<F extends TypeLambda, 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;
+  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) };
+  } catch (error) {
+    if (error instanceof DoBindSignal) {
+      return { done: false, effect: error.effect };
+    }
+    throw error;
+  }
+}
+
+function runDo<F extends TypeLambda, T>(
+  monad: Monad<F>,
+  body: (bind: Binder<F>) => T,
+  resolvedValues: readonly unknown[] = [],
+): Kind<F, T> {
+  const step = executeDoBody(body, resolvedValues);
+  if (step.done) {
+    return monad.pure(step.value);
+  }
+  return monad.flatMap(step.effect, (value) => runDo(monad, body, [...resolvedValues, value]));
+}
+
+function runAsyncDo<F extends TypeLambda, T>(
+  monad: AsyncMonad<F>,
+  body: (bind: Binder<F>) => T | Promise<T>,
+  resolvedValues: readonly unknown[] = [],
+): Kind<F, T> {
+  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]),
+      ),
+  );
+}
+
+export interface DoRuntime {
+  <F extends TypeLambda, T>(
+    monad: Monad<F>,
+    body: (bind: Binder<F>) => T,
+  ): Kind<F, T>;
+  <F extends TypeLambda, T>(
+    monad: AsyncMonad<F>,
+    body: (bind: Binder<F>) => T | Promise<T>,
+  ): Kind<F, T>;
+  readonly macroBind: <F extends TypeLambda>(
+    monad: Monad<F>,
+  ) => <A>(effect: BoundEffect<F, A>, value: unknown) => A;
+  readonly macroGen: typeof monadGen;
+}
+
+function createDoRuntime(): DoRuntime {
+  function runtime<F extends TypeLambda, T>(
+    monad: Monad<F>,
+    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, []);
+  }
+
+  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.
+export const Do = createDoRuntime();

package/project-transform/src/stdlib/url.d.ts

@@ -0,0 +1,37 @@
+export declare class URLSearchParams {
+  constructor(
+    init?:
+      | Iterable<readonly [string, string]>
+      | Record<string, string>
+      | string
+      | URLSearchParams,
+  );
+  append(name: string, value: string): void;
+  delete(name: string): void;
+  entries(): IterableIterator<[string, string]>;
+  get(name: string): string | null;
+  has(name: string): boolean;
+  keys(): IterableIterator<string>;
+  set(name: string, value: string): void;
+  toString(): string;
+  values(): IterableIterator<string>;
+  [Symbol.iterator](): IterableIterator<[string, string]>;
+}
+
+export declare class URL {
+  constructor(url: string, base?: string | URL);
+  hash: string;
+  host: string;
+  hostname: string;
+  href: string;
+  readonly origin: string;
+  password: string;
+  pathname: string;
+  port: string;
+  protocol: string;
+  search: string;
+  readonly searchParams: URLSearchParams;
+  username: string;
+  toJSON(): string;
+  toString(): string;
+}

package/project-transform/src/stdlib/url.js

@@ -0,0 +1,3 @@
+const URLCtor = URL;
+const URLSearchParamsCtor = URLSearchParams;
+export { URLCtor as URL, URLSearchParamsCtor as URLSearchParams };

package/project-transform/src/stdlib/url.ts

@@ -0,0 +1,4 @@
+const URLCtor = URL;
+const URLSearchParamsCtor = URLSearchParams;
+
+export { URLCtor as URL, URLSearchParamsCtor as URLSearchParams };

package/project-transform/src/stdlib/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/project-transform/src/stdlib/value.js

@@ -0,0 +1,104 @@
+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;
+    };
+}

package/project-transform/src/stdlib/value.ts

@@ -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;
+  };
+}