@soundscript/soundscript 0.1.13 → 0.1.15

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

@@ -0,0 +1,315 @@
+import { type Bind, type Kind2, type TypeLambda } from 'sts:hkt';
+import { Failure, normalizeThrown } from 'sts:failures';
+import { err, isErr, ok, type Result, resultOf } from 'sts:result';
+import { type Applicative, type AsyncMonad, type Functor, type Monad } from 'sts:typeclasses';
+
+export interface AbortSignalLike {
+  readonly aborted: boolean;
+  readonly reason?: unknown;
+  addEventListener(
+    type: 'abort',
+    listener: () => void,
+    options?: boolean | { once?: boolean },
+  ): void;
+  removeEventListener(type: 'abort', listener: () => void, options?: boolean): void;
+}
+
+export type Task<T, E = Error> = (signal?: AbortSignalLike) => Promise<Result<T, E>>;
+
+export interface TaskF extends TypeLambda {
+  readonly type: Task<this['Args'][1], this['Args'][0]>;
+}
+
+export interface PromiseF extends TypeLambda {
+  readonly type: Promise<this['Args'][0]>;
+}
+
+export type TaskKind<E, T> = Kind2<TaskF, E, T>;
+export type PromiseKind<T> = Promise<T>;
+
+export class TimeoutFailure extends Failure {
+  readonly ms: number;
+
+  constructor(ms: number, cause?: unknown) {
+    super(`Task timed out after ${ms}ms.`, { cause });
+    this.ms = ms;
+  }
+}
+
+export function succeed<T>(value: T): Task<T, never> {
+  return () => Promise.resolve(ok(value));
+}
+
+export function fail<E>(error: E): Task<never, E> {
+  return () => Promise.resolve(err(error));
+}
+
+export function fromResult<T, E>(result: Result<T, E>): Task<T, E> {
+  return () => Promise.resolve(result);
+}
+
+export function fromPromise<T>(fn: (signal?: AbortSignalLike) => Promise<T>): Task<T, Error>;
+export function fromPromise<T, E>(
+  fn: (signal?: AbortSignalLike) => Promise<T>,
+  mapError: (error: Error) => E,
+): Task<T, E>;
+export function fromPromise<T, E>(
+  fn: (signal?: AbortSignalLike) => Promise<T>,
+  mapError?: (error: Error) => E,
+): Task<T, E | Error> {
+  return async (signal?: AbortSignalLike) => {
+    if (mapError) {
+      return await resultOf(() => fn(signal), mapError);
+    }
+
+    return await resultOf(() => fn(signal));
+  };
+}
+
+export function map<A, B, E>(
+  task: Task<A, E>,
+  project: (value: A) => B,
+): Task<B, E> {
+  return async (signal?: AbortSignalLike) => {
+    const result = await task(signal);
+    return isErr(result) ? result : ok(project(result.value));
+  };
+}
+
+export function mapError<A, E1, E2>(
+  task: Task<A, E1>,
+  project: (error: E1) => E2,
+): Task<A, E2 | Error> {
+  return async (signal?: AbortSignalLike) => {
+    const result = await task(signal);
+    if (!isErr(result)) {
+      return result;
+    }
+
+    try {
+      return err(project(result.error));
+    } catch (error) {
+      return err(normalizeThrown(error));
+    }
+  };
+}
+
+export function flatMap<A, B, E1, E2>(
+  task: Task<A, E1>,
+  project: (value: A) => Task<B, E2>,
+): Task<B, E1 | E2> {
+  return async (signal?: AbortSignalLike) => {
+    const result = await task(signal);
+    if (isErr(result)) {
+      return result;
+    }
+    return await project(result.value)(signal);
+  };
+}
+
+export function recover<A, B, E>(
+  task: Task<A, E>,
+  project: (error: E) => B | Promise<B>,
+): Task<A | B, Error> {
+  return async (signal?: AbortSignalLike) => {
+    const result = await task(signal);
+    if (!isErr(result)) {
+      return result;
+    }
+
+    return await resultOf(async () => await project(result.error));
+  };
+}
+
+export function tap<A, E>(
+  task: Task<A, E>,
+  effect: (value: A) => unknown | Promise<unknown>,
+): Task<A, E | Error> {
+  return async (signal?: AbortSignalLike) => {
+    const result = await task(signal);
+    if (isErr(result)) {
+      return result;
+    }
+
+    const observed = await resultOf(async () => await effect(result.value));
+    return isErr(observed) ? observed : result;
+  };
+}
+
+export function tapError<A, E>(
+  task: Task<A, E>,
+  effect: (error: E) => unknown | Promise<unknown>,
+): Task<A, E | Error> {
+  return async (signal?: AbortSignalLike) => {
+    const result = await task(signal);
+    if (!isErr(result)) {
+      return result;
+    }
+
+    const observed = await resultOf(async () => await effect(result.error));
+    return isErr(observed) ? observed : result;
+  };
+}
+
+export function parallel<T, E>(tasks: readonly Task<T, E>[]): Task<readonly T[], E> {
+  return async (signal?: AbortSignalLike) => {
+    const results = await Promise.all(tasks.map((task) => task(signal)));
+    const values: T[] = [];
+    for (const result of results) {
+      if (isErr(result)) {
+        return result;
+      }
+      values.push(result.value);
+    }
+    return ok(values);
+  };
+}
+
+export function race<T, E>(
+  tasks: readonly [Task<T, E>, ...Task<T, E>[]],
+): Task<T, E> {
+  return async (signal?: AbortSignalLike) => {
+    const controller = new AbortController();
+    const cleanup = forwardAbort(signal, controller);
+
+    try {
+      return await Promise.race(tasks.map(async (task) => {
+        const result = await task(controller.signal);
+        controller.abort(result);
+        return result;
+      }));
+    } finally {
+      cleanup();
+    }
+  };
+}
+
+export function timeout<T, E>(task: Task<T, E>, ms: number): Task<T, E | TimeoutFailure> {
+  return async (signal?: AbortSignalLike) => {
+    const controller = new AbortController();
+    const cleanup = forwardAbort(signal, controller);
+    let timeoutId: number | undefined;
+
+    try {
+      const timeoutPromise = new Promise<Result<T, E | TimeoutFailure>>((resolve) => {
+        timeoutId = setTimeout(() => {
+          const failure = new TimeoutFailure(ms);
+          resolve(err(failure));
+          controller.abort(failure);
+        }, ms);
+      });
+
+      return await Promise.race([
+        task(controller.signal),
+        timeoutPromise,
+      ]);
+    } finally {
+      cleanup();
+      if (timeoutId !== undefined) {
+        clearTimeout(timeoutId);
+      }
+    }
+  };
+}
+
+function forwardAbort(
+  signal: AbortSignalLike | undefined,
+  controller: AbortController,
+): () => void {
+  if (!signal) {
+    return () => {};
+  }
+
+  if (signal.aborted) {
+    controller.abort(signal.reason);
+    return () => {};
+  }
+
+  const onAbort = (): void => {
+    controller.abort(signal.reason);
+  };
+
+  signal.addEventListener('abort', onAbort, { once: true });
+  return () => signal.removeEventListener('abort', onAbort);
+}
+
+function mapTask<E, A, B>(task: Task<A, E>, project: (value: A) => B): Task<B, E> {
+  return map(task, project);
+}
+
+function apTask<E, A, B>(
+  fn: Task<(value: A) => B, E>,
+  value: Task<A, E>,
+): Task<B, E> {
+  return flatMap(fn, (resolvedFn) => map(value, resolvedFn));
+}
+
+function flatMapTask<E, A, B>(
+  task: Task<A, E>,
+  project: (value: A) => Task<B, E>,
+): Task<B, E> {
+  return flatMap(task, project);
+}
+
+function createTaskMonad<E>(): Monad<Bind<TaskF, [E]>> {
+  return {
+    ap: apTask,
+    flatMap: flatMapTask,
+    map: mapTask,
+    pure: succeed,
+  };
+}
+
+export function taskFunctor<E>(): Functor<Bind<TaskF, [E]>> {
+  return createTaskMonad<E>();
+}
+
+export function taskApplicative<E>(): Applicative<Bind<TaskF, [E]>> {
+  return createTaskMonad<E>();
+}
+
+export function taskMonad<E>(): Monad<Bind<TaskF, [E]>> {
+  return createTaskMonad<E>();
+}
+
+export function taskAsyncMonad<E>(): AsyncMonad<Bind<TaskF, [E]>> {
+  const monad = createTaskMonad<E>();
+  return {
+    ...monad,
+    fromPromise<A>(promise: Promise<A>): Task<A, E> {
+      return fromPromise(() => promise) as Task<A, E>;
+    },
+  };
+}
+
+export const promiseFunctor: Functor<PromiseF> = {
+  map<A, B>(value: Promise<A>, f: (value: A) => B): Promise<B> {
+    return value.then(f);
+  },
+};
+
+export const promiseApplicative: Applicative<PromiseF> = {
+  ...promiseFunctor,
+  ap<A, B>(fn: Promise<(value: A) => B>, value: Promise<A>): Promise<B> {
+    return Promise.all([fn, value]).then(([resolvedFn, resolvedValue]) =>
+      resolvedFn(resolvedValue)
+    );
+  },
+  pure<A>(value: A): Promise<A> {
+    return Promise.resolve(value);
+  },
+};
+
+export const promiseMonad: Monad<PromiseF> = {
+  ...promiseApplicative,
+  flatMap<A, B>(value: Promise<A>, f: (value: A) => Promise<B>): Promise<B> {
+    return value.then(f);
+  },
+};
+
+export const promiseAsyncMonad: AsyncMonad<PromiseF> = {
+  ...promiseMonad,
+  fromPromise<A>(promise: Promise<A>): Promise<A> {
+    return promise;
+  },
+};

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

@@ -0,0 +1,32 @@
+import type { Bind, TypeLambda } from 'sts:hkt';
+import { type DecodeFailure, type Decoder } from 'sts:decode';
+import { contramap, type EncodeFailure, type Encoder } from 'sts:encode';
+import type { Invariant } from 'sts:typeclasses';
+
+export { booleanEncoder, contramap, numberEncoder, stringEncoder } from 'sts:encode';
+export type { EncodeFailure, Encoder } from 'sts:encode';
+
+// #[variance(T: inout, TEncoded: out, DE: out, EE: out)]
+export type Codec<T, TEncoded = unknown, DE = DecodeFailure, EE = EncodeFailure> =
+  Decoder<T, DE> & Encoder<T, TEncoded, EE>;
+
+export interface CodecF extends TypeLambda {
+  readonly type: Codec<this['Args'][3], this['Args'][2], this['Args'][1], this['Args'][0]>;
+}
+
+export function codec<T, TEncoded, DE, EE>(
+  decoder: Decoder<T, DE>,
+  encoder: Encoder<T, TEncoded, EE>,
+): Codec<T, TEncoded, DE, EE>;
+export function imap<A, B, TEncoded, DE, EE>(
+  base: Codec<A, TEncoded, DE, EE>,
+  decodeMap: (value: A) => B,
+  encodeMap: (value: B) => A,
+): Codec<B, TEncoded, DE, EE>;
+export function codecInvariant<TEncoded, DE = DecodeFailure, EE = EncodeFailure>(): Invariant<
+  Bind<Bind<Bind<CodecF, [EE]>, [DE]>, [TEncoded]>
+>;
+
+export const stringCodec: Codec<string, string>;
+export const numberCodec: Codec<number, number>;
+export const booleanCodec: Codec<boolean, boolean>;

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

@@ -0,0 +1,30 @@
+import { boolean as booleanDecoder, number as numberDecoder, string as stringDecoder, } from '@soundscript/soundscript/decode';
+import { booleanEncoder as booleanEncoderValue, contramap as contramapEncoder, numberEncoder as numberEncoderValue, stringEncoder as stringEncoderValue, } from '@soundscript/soundscript/encode';
+import { isErr, ok } from '@soundscript/soundscript/result';
+export { booleanEncoderValue as booleanEncoder, contramapEncoder as contramap, numberEncoderValue as numberEncoder, stringEncoderValue as stringEncoder, };
+export function codec(decoder, encoder) {
+    return {
+        decode(value) {
+            return decoder.decode(value);
+        },
+        encode(value) {
+            return encoder.encode(value);
+        },
+    };
+}
+export function imap(base, decodeMap, encodeMap) {
+    return codec({
+        decode(value) {
+            const decoded = base.decode(value);
+            return isErr(decoded) ? decoded : ok(decodeMap(decoded.value));
+        },
+    }, contramapEncoder(base, encodeMap));
+}
+export function codecInvariant() {
+    return {
+        imap,
+    };
+}
+export const stringCodec = codec(stringDecoder, stringEncoderValue);
+export const numberCodec = codec(numberDecoder, numberEncoderValue);
+export const booleanCodec = codec(booleanDecoder, booleanEncoderValue);

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

@@ -0,0 +1,76 @@
+import { type Bind, type TypeLambda } from 'sts:hkt';
+import {
+  boolean as booleanDecoder,
+  DecodeFailure,
+  type Decoder,
+  number as numberDecoder,
+  string as stringDecoder,
+} from 'sts:decode';
+import {
+  booleanEncoder as booleanEncoderValue,
+  contramap as contramapEncoder,
+  type EncodeFailure,
+  type Encoder,
+  numberEncoder as numberEncoderValue,
+  stringEncoder as stringEncoderValue,
+} from 'sts:encode';
+import type { Invariant } from 'sts:typeclasses';
+import { isErr, ok, type Result } from 'sts:result';
+
+export type { EncodeFailure, Encoder } from 'sts:encode';
+export {
+  booleanEncoderValue as booleanEncoder,
+  contramapEncoder as contramap,
+  numberEncoderValue as numberEncoder,
+  stringEncoderValue as stringEncoder,
+};
+
+// #[variance(T: inout, TEncoded: out, DE: out, EE: out)]
+export type Codec<T, TEncoded = unknown, DE = DecodeFailure, EE = EncodeFailure> =
+  Decoder<T, DE> & Encoder<T, TEncoded, EE>;
+
+export interface CodecF extends TypeLambda {
+  readonly type: Codec<this['Args'][3], this['Args'][2], this['Args'][1], this['Args'][0]>;
+}
+
+export function codec<T, TEncoded, DE, EE>(
+  decoder: Decoder<T, DE>,
+  encoder: Encoder<T, TEncoded, EE>,
+): Codec<T, TEncoded, DE, EE> {
+  return {
+    decode(value): Result<T, DE> {
+      return decoder.decode(value);
+    },
+    encode(value): Result<TEncoded, EE> {
+      return encoder.encode(value);
+    },
+  };
+}
+
+export function imap<A, B, TEncoded, DE, EE>(
+  base: Codec<A, TEncoded, DE, EE>,
+  decodeMap: (value: A) => B,
+  encodeMap: (value: B) => A,
+): Codec<B, TEncoded, DE, EE> {
+  return codec(
+    {
+      decode(value): Result<B, DE> {
+        const decoded = base.decode(value);
+        return isErr(decoded) ? decoded : ok(decodeMap(decoded.value));
+      },
+    },
+    contramapEncoder(base, encodeMap),
+  );
+}
+
+export function codecInvariant<TEncoded, DE = DecodeFailure, EE = EncodeFailure>(): Invariant<
+  Bind<Bind<Bind<CodecF, [EE]>, [DE]>, [TEncoded]>
+> {
+  return {
+    imap,
+  };
+}
+
+export const stringCodec: Codec<string, string> = codec(stringDecoder, stringEncoderValue);
+export const numberCodec: Codec<number, number> = codec(numberDecoder, numberEncoderValue);
+export const booleanCodec: Codec<boolean, boolean> = codec(booleanDecoder, booleanEncoderValue);

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

@@ -0,0 +1,28 @@
+import type { Option, Result } from 'sts:result';
+
+export type Ordering = -1 | 0 | 1;
+
+export interface Eq<T> {
+  equals(left: T, right: T): boolean;
+}
+
+export interface Order<T> extends Eq<T> {
+  compare(left: T, right: T): Ordering;
+}
+
+type EqValue<TEq> = TEq extends Eq<infer TValue> ? TValue : never;
+
+export const stringEq: Eq<string>;
+export const numberEq: Eq<number>;
+export const booleanEq: Eq<boolean>;
+export const bigintEq: Eq<bigint>;
+export function lazyEq<T>(getEq: () => Eq<T>): Eq<T>;
+export function arrayEq<T>(itemEq: Eq<T>): Eq<readonly T[]>;
+export function tupleEq<const TEqs extends readonly Eq<unknown>[]>(
+  ...elements: TEqs
+): Eq<{ readonly [K in keyof TEqs]: EqValue<TEqs[K]> }>;
+export function optionEq<T>(itemEq: Eq<T>): Eq<Option<T>>;
+export function resultEq<T, E>(okEq: Eq<T>, errEq: Eq<E>): Eq<Result<T, E>>;
+export function fromCompare<T>(compare: (left: T, right: T) => number): Order<T>;
+export function reverse<T>(order: Order<T>): Order<T>;
+export function thenBy<T>(primary: Order<T>, secondary: Order<T>): Order<T>;

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

@@ -0,0 +1,115 @@
+import { isErr, isNone, isOk, isSome } from '@soundscript/soundscript/result';
+export const stringEq = {
+    equals(left, right) {
+        return left === right;
+    },
+};
+export const numberEq = {
+    equals(left, right) {
+        return left === right || (Number.isNaN(left) && Number.isNaN(right));
+    },
+};
+export const booleanEq = {
+    equals(left, right) {
+        return left === right;
+    },
+};
+export const bigintEq = {
+    equals(left, right) {
+        return left === right;
+    },
+};
+export function lazyEq(getEq) {
+    return {
+        equals(left, right) {
+            return getEq().equals(left, right);
+        },
+    };
+}
+export function arrayEq(itemEq) {
+    return {
+        equals(left, right) {
+            if (left.length !== right.length) {
+                return false;
+            }
+            for (let index = 0; index < left.length; index += 1) {
+                if (!itemEq.equals(left[index], right[index])) {
+                    return false;
+                }
+            }
+            return true;
+        },
+    };
+}
+export function tupleEq(...elements) {
+    return {
+        equals(left, right) {
+            const leftValues = left;
+            const rightValues = right;
+            if (leftValues.length !== elements.length || rightValues.length !== elements.length) {
+                return false;
+            }
+            for (let index = 0; index < elements.length; index += 1) {
+                const elementEq = elements[index];
+                if (!elementEq) {
+                    continue;
+                }
+                if (!elementEq.equals(leftValues[index], rightValues[index])) {
+                    return false;
+                }
+            }
+            return true;
+        },
+    };
+}
+export function optionEq(itemEq) {
+    return {
+        equals(left, right) {
+            if (isSome(left) && isSome(right)) {
+                return itemEq.equals(left.value, right.value);
+            }
+            return isNone(left) && isNone(right);
+        },
+    };
+}
+export function resultEq(okEq, errEq) {
+    return {
+        equals(left, right) {
+            if (isOk(left) && isOk(right)) {
+                return okEq.equals(left.value, right.value);
+            }
+            if (isErr(left) && isErr(right)) {
+                return errEq.equals(left.error, right.error);
+            }
+            return false;
+        },
+    };
+}
+export function fromCompare(compare) {
+    return {
+        equals(left, right) {
+            return normalizeOrdering(compare(left, right)) === 0;
+        },
+        compare(left, right) {
+            return normalizeOrdering(compare(left, right));
+        },
+    };
+}
+export function reverse(order) {
+    return fromCompare((left, right) => order.compare(right, left));
+}
+export function thenBy(primary, secondary) {
+    return fromCompare((left, right) => {
+        const primaryOrdering = primary.compare(left, right);
+        return primaryOrdering !== 0 ? primaryOrdering : secondary.compare(left, right);
+    });
+}
+function normalizeOrdering(value) {
+    if (value < 0) {
+        return -1;
+    }
+    if (value > 0) {
+        return 1;
+    }
+    return 0;
+}