@soundscript/soundscript 0.1.13 → 0.1.15

package/project-transform/src/soundscript_runtime_specifiers.js

@@ -0,0 +1,88 @@
+export const STS_PRELUDE_MODULE_SPECIFIER = 'sts:prelude';
+export const STS_HKT_MODULE_SPECIFIER = 'sts:hkt';
+export const STS_TYPECLASSES_MODULE_SPECIFIER = 'sts:typeclasses';
+export const STS_RESULT_MODULE_SPECIFIER = 'sts:result';
+export const STS_VALUE_MODULE_SPECIFIER = 'sts:value';
+export const STS_MATCH_MODULE_SPECIFIER = 'sts:match';
+export const STS_FAILURES_MODULE_SPECIFIER = 'sts:failures';
+export const STS_URL_MODULE_SPECIFIER = 'sts:url';
+export const STS_FETCH_MODULE_SPECIFIER = 'sts:fetch';
+export const STS_TEXT_MODULE_SPECIFIER = 'sts:text';
+export const STS_RANDOM_MODULE_SPECIFIER = 'sts:random';
+export const STS_JSON_MODULE_SPECIFIER = 'sts:json';
+export const STS_COMPARE_MODULE_SPECIFIER = 'sts:compare';
+export const STS_HASH_MODULE_SPECIFIER = 'sts:hash';
+export const STS_DERIVE_MODULE_SPECIFIER = 'sts:derive';
+export const STS_DECODE_MODULE_SPECIFIER = 'sts:decode';
+export const STS_ENCODE_MODULE_SPECIFIER = 'sts:encode';
+export const STS_CODEC_MODULE_SPECIFIER = 'sts:codec';
+export const STS_ASYNC_MODULE_SPECIFIER = 'sts:async';
+export const STS_EXPERIMENTAL_THUNK_MODULE_SPECIFIER = 'sts:experimental/thunk';
+export const STS_THUNK_MODULE_SPECIFIER = STS_EXPERIMENTAL_THUNK_MODULE_SPECIFIER;
+export const STS_NUMERICS_MODULE_SPECIFIER = 'sts:numerics';
+export const STS_MACROS_MODULE_SPECIFIER = 'sts:macros';
+export const STS_EXPERIMENTAL_SQL_MODULE_SPECIFIER = 'sts:experimental/sql';
+export const STS_EXPERIMENTAL_CSS_MODULE_SPECIFIER = 'sts:experimental/css';
+export const STS_EXPERIMENTAL_GRAPHQL_MODULE_SPECIFIER = 'sts:experimental/graphql';
+export const STS_EXPERIMENTAL_COMPONENT_MODULE_SPECIFIER = 'sts:experimental/component';
+export const STS_EXPERIMENTAL_DEBUG_MODULE_SPECIFIER = 'sts:experimental/debug';
+export const SOUNDSCRIPT_CORE_MODULE_SPECIFIER = STS_PRELUDE_MODULE_SPECIFIER;
+export const SOUNDSCRIPT_HKT_MODULE_SPECIFIER = STS_HKT_MODULE_SPECIFIER;
+export const SOUNDSCRIPT_RESULT_MODULE_SPECIFIER = STS_RESULT_MODULE_SPECIFIER;
+export const SOUNDSCRIPT_VALUE_MODULE_SPECIFIER = STS_VALUE_MODULE_SPECIFIER;
+export const SOUNDSCRIPT_MATCH_MODULE_SPECIFIER = STS_MATCH_MODULE_SPECIFIER;
+export const SOUNDSCRIPT_ERRORS_MODULE_SPECIFIER = STS_FAILURES_MODULE_SPECIFIER;
+export const SOUNDSCRIPT_URL_MODULE_SPECIFIER = STS_URL_MODULE_SPECIFIER;
+export const SOUNDSCRIPT_FETCH_MODULE_SPECIFIER = STS_FETCH_MODULE_SPECIFIER;
+export const SOUNDSCRIPT_TEXT_MODULE_SPECIFIER = STS_TEXT_MODULE_SPECIFIER;
+export const SOUNDSCRIPT_RANDOM_MODULE_SPECIFIER = STS_RANDOM_MODULE_SPECIFIER;
+export const SOUNDSCRIPT_JSON_MODULE_SPECIFIER = STS_JSON_MODULE_SPECIFIER;
+export const SOUNDSCRIPT_COMPARE_MODULE_SPECIFIER = STS_COMPARE_MODULE_SPECIFIER;
+export const SOUNDSCRIPT_HASH_MODULE_SPECIFIER = STS_HASH_MODULE_SPECIFIER;
+export const SOUNDSCRIPT_DERIVE_MODULE_SPECIFIER = STS_DERIVE_MODULE_SPECIFIER;
+export const SOUNDSCRIPT_DECODE_MODULE_SPECIFIER = STS_DECODE_MODULE_SPECIFIER;
+export const SOUNDSCRIPT_CODEC_MODULE_SPECIFIER = STS_CODEC_MODULE_SPECIFIER;
+export const SOUNDSCRIPT_ASYNC_MODULE_SPECIFIER = STS_ASYNC_MODULE_SPECIFIER;
+export const SOUNDSCRIPT_SQL_MODULE_SPECIFIER = STS_EXPERIMENTAL_SQL_MODULE_SPECIFIER;
+export const SOUNDSCRIPT_NUMERICS_MODULE_SPECIFIER = STS_NUMERICS_MODULE_SPECIFIER;
+export const SOUNDSCRIPT_RUNTIME_PACKAGE_NAME = '@soundscript/soundscript';
+export const SOUNDSCRIPT_EXPERIMENTAL_RUNTIME_PREFIX = '@soundscript/soundscript/experimental';
+const BUILTIN_RUNTIME_MODULE_SPECIFIERS = new Map([
+    [STS_PRELUDE_MODULE_SPECIFIER, SOUNDSCRIPT_RUNTIME_PACKAGE_NAME],
+    [STS_HKT_MODULE_SPECIFIER, `${SOUNDSCRIPT_RUNTIME_PACKAGE_NAME}/hkt`],
+    [STS_TYPECLASSES_MODULE_SPECIFIER, `${SOUNDSCRIPT_RUNTIME_PACKAGE_NAME}/typeclasses`],
+    [STS_RESULT_MODULE_SPECIFIER, `${SOUNDSCRIPT_RUNTIME_PACKAGE_NAME}/result`],
+    [STS_VALUE_MODULE_SPECIFIER, `${SOUNDSCRIPT_RUNTIME_PACKAGE_NAME}/value`],
+    [STS_MATCH_MODULE_SPECIFIER, `${SOUNDSCRIPT_RUNTIME_PACKAGE_NAME}/match`],
+    [STS_FAILURES_MODULE_SPECIFIER, `${SOUNDSCRIPT_RUNTIME_PACKAGE_NAME}/failures`],
+    [STS_URL_MODULE_SPECIFIER, `${SOUNDSCRIPT_RUNTIME_PACKAGE_NAME}/url`],
+    [STS_FETCH_MODULE_SPECIFIER, `${SOUNDSCRIPT_RUNTIME_PACKAGE_NAME}/fetch`],
+    [STS_TEXT_MODULE_SPECIFIER, `${SOUNDSCRIPT_RUNTIME_PACKAGE_NAME}/text`],
+    [STS_RANDOM_MODULE_SPECIFIER, `${SOUNDSCRIPT_RUNTIME_PACKAGE_NAME}/random`],
+    [STS_JSON_MODULE_SPECIFIER, `${SOUNDSCRIPT_RUNTIME_PACKAGE_NAME}/json`],
+    [STS_COMPARE_MODULE_SPECIFIER, `${SOUNDSCRIPT_RUNTIME_PACKAGE_NAME}/compare`],
+    [STS_HASH_MODULE_SPECIFIER, `${SOUNDSCRIPT_RUNTIME_PACKAGE_NAME}/hash`],
+    [STS_DERIVE_MODULE_SPECIFIER, `${SOUNDSCRIPT_RUNTIME_PACKAGE_NAME}/derive`],
+    [STS_DECODE_MODULE_SPECIFIER, `${SOUNDSCRIPT_RUNTIME_PACKAGE_NAME}/decode`],
+    [STS_ENCODE_MODULE_SPECIFIER, `${SOUNDSCRIPT_RUNTIME_PACKAGE_NAME}/encode`],
+    [STS_CODEC_MODULE_SPECIFIER, `${SOUNDSCRIPT_RUNTIME_PACKAGE_NAME}/codec`],
+    [STS_ASYNC_MODULE_SPECIFIER, `${SOUNDSCRIPT_RUNTIME_PACKAGE_NAME}/async`],
+    [STS_EXPERIMENTAL_THUNK_MODULE_SPECIFIER, `${SOUNDSCRIPT_EXPERIMENTAL_RUNTIME_PREFIX}/thunk`],
+    [STS_NUMERICS_MODULE_SPECIFIER, `${SOUNDSCRIPT_RUNTIME_PACKAGE_NAME}/numerics`],
+    [STS_EXPERIMENTAL_SQL_MODULE_SPECIFIER, `${SOUNDSCRIPT_EXPERIMENTAL_RUNTIME_PREFIX}/sql`],
+    [STS_EXPERIMENTAL_CSS_MODULE_SPECIFIER, `${SOUNDSCRIPT_EXPERIMENTAL_RUNTIME_PREFIX}/css`],
+    [
+        STS_EXPERIMENTAL_GRAPHQL_MODULE_SPECIFIER,
+        `${SOUNDSCRIPT_EXPERIMENTAL_RUNTIME_PREFIX}/graphql`,
+    ],
+    [STS_EXPERIMENTAL_DEBUG_MODULE_SPECIFIER, `${SOUNDSCRIPT_EXPERIMENTAL_RUNTIME_PREFIX}/debug`],
+]);
+export function isSoundscriptProtocolSpecifier(moduleSpecifier) {
+    return moduleSpecifier.startsWith('sts:');
+}
+export function isBuiltinRuntimeModuleSpecifier(moduleSpecifier) {
+    return BUILTIN_RUNTIME_MODULE_SPECIFIERS.has(moduleSpecifier);
+}
+export function builtinRuntimeImportSpecifier(moduleSpecifier) {
+    return BUILTIN_RUNTIME_MODULE_SPECIFIERS.get(moduleSpecifier);
+}

package/project-transform/src/soundscript_runtime_specifiers.ts

@@ -0,0 +1,96 @@
+export const STS_PRELUDE_MODULE_SPECIFIER = 'sts:prelude';
+export const STS_HKT_MODULE_SPECIFIER = 'sts:hkt';
+export const STS_TYPECLASSES_MODULE_SPECIFIER = 'sts:typeclasses';
+export const STS_RESULT_MODULE_SPECIFIER = 'sts:result';
+export const STS_VALUE_MODULE_SPECIFIER = 'sts:value';
+export const STS_MATCH_MODULE_SPECIFIER = 'sts:match';
+export const STS_FAILURES_MODULE_SPECIFIER = 'sts:failures';
+export const STS_URL_MODULE_SPECIFIER = 'sts:url';
+export const STS_FETCH_MODULE_SPECIFIER = 'sts:fetch';
+export const STS_TEXT_MODULE_SPECIFIER = 'sts:text';
+export const STS_RANDOM_MODULE_SPECIFIER = 'sts:random';
+export const STS_JSON_MODULE_SPECIFIER = 'sts:json';
+export const STS_COMPARE_MODULE_SPECIFIER = 'sts:compare';
+export const STS_HASH_MODULE_SPECIFIER = 'sts:hash';
+export const STS_DERIVE_MODULE_SPECIFIER = 'sts:derive';
+export const STS_DECODE_MODULE_SPECIFIER = 'sts:decode';
+export const STS_ENCODE_MODULE_SPECIFIER = 'sts:encode';
+export const STS_CODEC_MODULE_SPECIFIER = 'sts:codec';
+export const STS_ASYNC_MODULE_SPECIFIER = 'sts:async';
+export const STS_EXPERIMENTAL_THUNK_MODULE_SPECIFIER = 'sts:experimental/thunk';
+export const STS_THUNK_MODULE_SPECIFIER = STS_EXPERIMENTAL_THUNK_MODULE_SPECIFIER;
+export const STS_NUMERICS_MODULE_SPECIFIER = 'sts:numerics';
+export const STS_MACROS_MODULE_SPECIFIER = 'sts:macros';
+
+export const STS_EXPERIMENTAL_SQL_MODULE_SPECIFIER = 'sts:experimental/sql';
+export const STS_EXPERIMENTAL_CSS_MODULE_SPECIFIER = 'sts:experimental/css';
+export const STS_EXPERIMENTAL_GRAPHQL_MODULE_SPECIFIER = 'sts:experimental/graphql';
+export const STS_EXPERIMENTAL_COMPONENT_MODULE_SPECIFIER = 'sts:experimental/component';
+export const STS_EXPERIMENTAL_DEBUG_MODULE_SPECIFIER = 'sts:experimental/debug';
+
+export const SOUNDSCRIPT_CORE_MODULE_SPECIFIER = STS_PRELUDE_MODULE_SPECIFIER;
+export const SOUNDSCRIPT_HKT_MODULE_SPECIFIER = STS_HKT_MODULE_SPECIFIER;
+export const SOUNDSCRIPT_RESULT_MODULE_SPECIFIER = STS_RESULT_MODULE_SPECIFIER;
+export const SOUNDSCRIPT_VALUE_MODULE_SPECIFIER = STS_VALUE_MODULE_SPECIFIER;
+export const SOUNDSCRIPT_MATCH_MODULE_SPECIFIER = STS_MATCH_MODULE_SPECIFIER;
+export const SOUNDSCRIPT_ERRORS_MODULE_SPECIFIER = STS_FAILURES_MODULE_SPECIFIER;
+export const SOUNDSCRIPT_URL_MODULE_SPECIFIER = STS_URL_MODULE_SPECIFIER;
+export const SOUNDSCRIPT_FETCH_MODULE_SPECIFIER = STS_FETCH_MODULE_SPECIFIER;
+export const SOUNDSCRIPT_TEXT_MODULE_SPECIFIER = STS_TEXT_MODULE_SPECIFIER;
+export const SOUNDSCRIPT_RANDOM_MODULE_SPECIFIER = STS_RANDOM_MODULE_SPECIFIER;
+export const SOUNDSCRIPT_JSON_MODULE_SPECIFIER = STS_JSON_MODULE_SPECIFIER;
+export const SOUNDSCRIPT_COMPARE_MODULE_SPECIFIER = STS_COMPARE_MODULE_SPECIFIER;
+export const SOUNDSCRIPT_HASH_MODULE_SPECIFIER = STS_HASH_MODULE_SPECIFIER;
+export const SOUNDSCRIPT_DERIVE_MODULE_SPECIFIER = STS_DERIVE_MODULE_SPECIFIER;
+export const SOUNDSCRIPT_DECODE_MODULE_SPECIFIER = STS_DECODE_MODULE_SPECIFIER;
+export const SOUNDSCRIPT_CODEC_MODULE_SPECIFIER = STS_CODEC_MODULE_SPECIFIER;
+export const SOUNDSCRIPT_ASYNC_MODULE_SPECIFIER = STS_ASYNC_MODULE_SPECIFIER;
+export const SOUNDSCRIPT_SQL_MODULE_SPECIFIER = STS_EXPERIMENTAL_SQL_MODULE_SPECIFIER;
+export const SOUNDSCRIPT_NUMERICS_MODULE_SPECIFIER = STS_NUMERICS_MODULE_SPECIFIER;
+
+export const SOUNDSCRIPT_RUNTIME_PACKAGE_NAME = '@soundscript/soundscript';
+export const SOUNDSCRIPT_EXPERIMENTAL_RUNTIME_PREFIX = '@soundscript/soundscript/experimental';
+const BUILTIN_RUNTIME_MODULE_SPECIFIERS = new Map<string, string>([
+  [STS_PRELUDE_MODULE_SPECIFIER, SOUNDSCRIPT_RUNTIME_PACKAGE_NAME],
+  [STS_HKT_MODULE_SPECIFIER, `${SOUNDSCRIPT_RUNTIME_PACKAGE_NAME}/hkt`],
+  [STS_TYPECLASSES_MODULE_SPECIFIER, `${SOUNDSCRIPT_RUNTIME_PACKAGE_NAME}/typeclasses`],
+  [STS_RESULT_MODULE_SPECIFIER, `${SOUNDSCRIPT_RUNTIME_PACKAGE_NAME}/result`],
+  [STS_VALUE_MODULE_SPECIFIER, `${SOUNDSCRIPT_RUNTIME_PACKAGE_NAME}/value`],
+  [STS_MATCH_MODULE_SPECIFIER, `${SOUNDSCRIPT_RUNTIME_PACKAGE_NAME}/match`],
+  [STS_FAILURES_MODULE_SPECIFIER, `${SOUNDSCRIPT_RUNTIME_PACKAGE_NAME}/failures`],
+  [STS_URL_MODULE_SPECIFIER, `${SOUNDSCRIPT_RUNTIME_PACKAGE_NAME}/url`],
+  [STS_FETCH_MODULE_SPECIFIER, `${SOUNDSCRIPT_RUNTIME_PACKAGE_NAME}/fetch`],
+  [STS_TEXT_MODULE_SPECIFIER, `${SOUNDSCRIPT_RUNTIME_PACKAGE_NAME}/text`],
+  [STS_RANDOM_MODULE_SPECIFIER, `${SOUNDSCRIPT_RUNTIME_PACKAGE_NAME}/random`],
+  [STS_JSON_MODULE_SPECIFIER, `${SOUNDSCRIPT_RUNTIME_PACKAGE_NAME}/json`],
+  [STS_COMPARE_MODULE_SPECIFIER, `${SOUNDSCRIPT_RUNTIME_PACKAGE_NAME}/compare`],
+  [STS_HASH_MODULE_SPECIFIER, `${SOUNDSCRIPT_RUNTIME_PACKAGE_NAME}/hash`],
+  [STS_DERIVE_MODULE_SPECIFIER, `${SOUNDSCRIPT_RUNTIME_PACKAGE_NAME}/derive`],
+  [STS_DECODE_MODULE_SPECIFIER, `${SOUNDSCRIPT_RUNTIME_PACKAGE_NAME}/decode`],
+  [STS_ENCODE_MODULE_SPECIFIER, `${SOUNDSCRIPT_RUNTIME_PACKAGE_NAME}/encode`],
+  [STS_CODEC_MODULE_SPECIFIER, `${SOUNDSCRIPT_RUNTIME_PACKAGE_NAME}/codec`],
+  [STS_ASYNC_MODULE_SPECIFIER, `${SOUNDSCRIPT_RUNTIME_PACKAGE_NAME}/async`],
+  [STS_EXPERIMENTAL_THUNK_MODULE_SPECIFIER, `${SOUNDSCRIPT_EXPERIMENTAL_RUNTIME_PREFIX}/thunk`],
+  [STS_NUMERICS_MODULE_SPECIFIER, `${SOUNDSCRIPT_RUNTIME_PACKAGE_NAME}/numerics`],
+  [STS_EXPERIMENTAL_SQL_MODULE_SPECIFIER, `${SOUNDSCRIPT_EXPERIMENTAL_RUNTIME_PREFIX}/sql`],
+  [STS_EXPERIMENTAL_CSS_MODULE_SPECIFIER, `${SOUNDSCRIPT_EXPERIMENTAL_RUNTIME_PREFIX}/css`],
+  [
+    STS_EXPERIMENTAL_GRAPHQL_MODULE_SPECIFIER,
+    `${SOUNDSCRIPT_EXPERIMENTAL_RUNTIME_PREFIX}/graphql`,
+  ],
+  [STS_EXPERIMENTAL_DEBUG_MODULE_SPECIFIER, `${SOUNDSCRIPT_EXPERIMENTAL_RUNTIME_PREFIX}/debug`],
+]);
+
+export function isSoundscriptProtocolSpecifier(moduleSpecifier: string): boolean {
+  return moduleSpecifier.startsWith('sts:');
+}
+
+export function isBuiltinRuntimeModuleSpecifier(moduleSpecifier: string): boolean {
+  return BUILTIN_RUNTIME_MODULE_SPECIFIERS.has(moduleSpecifier);
+}
+
+export function builtinRuntimeImportSpecifier(
+  moduleSpecifier: string,
+): string | undefined {
+  return BUILTIN_RUNTIME_MODULE_SPECIFIERS.get(moduleSpecifier);
+}

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

@@ -0,0 +1,81 @@
+import type { Bind, Kind2, TypeLambda } from 'sts:hkt';
+import { Failure } from 'sts:failures';
+import type { Result } from 'sts:result';
+import type { Applicative, AsyncMonad, Functor, 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);
+}
+
+export function succeed<T>(value: T): Task<T, never>;
+export function fail<E>(error: E): Task<never, E>;
+export function fromResult<T, E>(result: Result<T, E>): Task<T, E>;
+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 map<A, B, E>(
+  task: Task<A, E>,
+  project: (value: A) => B,
+): Task<B, E>;
+export function mapError<A, E1, E2>(
+  task: Task<A, E1>,
+  project: (error: E1) => E2,
+): Task<A, E2 | Error>;
+export function flatMap<A, B, E1, E2>(
+  task: Task<A, E1>,
+  project: (value: A) => Task<B, E2>,
+): Task<B, E1 | E2>;
+export function recover<A, B, E>(
+  task: Task<A, E>,
+  project: (error: E) => B | Promise<B>,
+): Task<A | B, Error>;
+export function tap<A, E>(
+  task: Task<A, E>,
+  effect: (value: A) => unknown | Promise<unknown>,
+): Task<A, E | Error>;
+export function tapError<A, E>(
+  task: Task<A, E>,
+  effect: (error: E) => unknown | Promise<unknown>,
+): Task<A, E | Error>;
+export function parallel<T, E>(tasks: readonly Task<T, E>[]): Task<readonly T[], E>;
+export function race<T, E>(
+  tasks: readonly [Task<T, E>, ...Task<T, E>[]],
+): Task<T, E>;
+export function timeout<T, E>(task: Task<T, E>, ms: number): Task<T, E | TimeoutFailure>;
+
+export function taskFunctor<E>(): Functor<Bind<TaskF, [E]>>;
+export function taskApplicative<E>(): Applicative<Bind<TaskF, [E]>>;
+export function taskMonad<E>(): Monad<Bind<TaskF, [E]>>;
+export function taskAsyncMonad<E>(): AsyncMonad<Bind<TaskF, [E]>>;
+
+export const promiseFunctor: Functor<PromiseF>;
+export const promiseApplicative: Applicative<PromiseF>;
+export const promiseMonad: Monad<PromiseF>;
+export const promiseAsyncMonad: AsyncMonad<PromiseF>;

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

@@ -0,0 +1,213 @@
+import { Failure, normalizeThrown } from '@soundscript/soundscript/failures';
+import { err, isErr, ok, resultOf } from '@soundscript/soundscript/result';
+export class TimeoutFailure extends Failure {
+    constructor(ms, cause) {
+        super(`Task timed out after ${ms}ms.`, { cause });
+        this.ms = ms;
+    }
+}
+export function succeed(value) {
+    return () => Promise.resolve(ok(value));
+}
+export function fail(error) {
+    return () => Promise.resolve(err(error));
+}
+export function fromResult(result) {
+    return () => Promise.resolve(result);
+}
+export function fromPromise(fn, mapError) {
+    return async (signal) => {
+        if (mapError) {
+            return await resultOf(() => fn(signal), mapError);
+        }
+        return await resultOf(() => fn(signal));
+    };
+}
+export function map(task, project) {
+    return async (signal) => {
+        const result = await task(signal);
+        return isErr(result) ? result : ok(project(result.value));
+    };
+}
+export function mapError(task, project) {
+    return async (signal) => {
+        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(task, project) {
+    return async (signal) => {
+        const result = await task(signal);
+        if (isErr(result)) {
+            return result;
+        }
+        return await project(result.value)(signal);
+    };
+}
+export function recover(task, project) {
+    return async (signal) => {
+        const result = await task(signal);
+        if (!isErr(result)) {
+            return result;
+        }
+        return await resultOf(async () => await project(result.error));
+    };
+}
+export function tap(task, effect) {
+    return async (signal) => {
+        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(task, effect) {
+    return async (signal) => {
+        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(tasks) {
+    return async (signal) => {
+        const results = await Promise.all(tasks.map((task) => task(signal)));
+        const values = [];
+        for (const result of results) {
+            if (isErr(result)) {
+                return result;
+            }
+            values.push(result.value);
+        }
+        return ok(values);
+    };
+}
+export function race(tasks) {
+    return async (signal) => {
+        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(task, ms) {
+    return async (signal) => {
+        const controller = new AbortController();
+        const cleanup = forwardAbort(signal, controller);
+        let timeoutId;
+        try {
+            const timeoutPromise = new Promise((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, controller) {
+    if (!signal) {
+        return () => { };
+    }
+    if (signal.aborted) {
+        controller.abort(signal.reason);
+        return () => { };
+    }
+    const onAbort = () => {
+        controller.abort(signal.reason);
+    };
+    signal.addEventListener('abort', onAbort, { once: true });
+    return () => signal.removeEventListener('abort', onAbort);
+}
+function mapTask(task, project) {
+    return map(task, project);
+}
+function apTask(fn, value) {
+    return flatMap(fn, (resolvedFn) => map(value, resolvedFn));
+}
+function flatMapTask(task, project) {
+    return flatMap(task, project);
+}
+function createTaskMonad() {
+    return {
+        ap: apTask,
+        flatMap: flatMapTask,
+        map: mapTask,
+        pure: succeed,
+    };
+}
+export function taskFunctor() {
+    return createTaskMonad();
+}
+export function taskApplicative() {
+    return createTaskMonad();
+}
+export function taskMonad() {
+    return createTaskMonad();
+}
+export function taskAsyncMonad() {
+    const monad = createTaskMonad();
+    return {
+        ...monad,
+        fromPromise(promise) {
+            return fromPromise(() => promise);
+        },
+    };
+}
+export const promiseFunctor = {
+    map(value, f) {
+        return value.then(f);
+    },
+};
+export const promiseApplicative = {
+    ...promiseFunctor,
+    ap(fn, value) {
+        return Promise.all([fn, value]).then(([resolvedFn, resolvedValue]) => resolvedFn(resolvedValue));
+    },
+    pure(value) {
+        return Promise.resolve(value);
+    },
+};
+export const promiseMonad = {
+    ...promiseApplicative,
+    flatMap(value, f) {
+        return value.then(f);
+    },
+};
+export const promiseAsyncMonad = {
+    ...promiseMonad,
+    fromPromise(promise) {
+        return promise;
+    },
+};