@soundscript/soundscript 0.1.13 → 0.1.15

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

@@ -0,0 +1,188 @@
+import type { Eq } from 'sts:compare';
+import { isErr, isNone, isOk, isSome, type Option, type Result } from 'sts:result';
+
+export type HashCode = number;
+
+export interface Hash<T> {
+  hash(value: T): HashCode;
+}
+
+export interface HashEq<T> extends Hash<T>, Eq<T> {}
+
+type HashEqValue<THashEq> = THashEq extends HashEq<infer TValue> ? TValue : never;
+
+export function fromHashEq<T>(
+  hash: (value: T) => HashCode,
+  equals: (left: T, right: T) => boolean,
+): HashEq<T> {
+  return {
+    hash(value) {
+      return normalizeHashCode(hash(value));
+    },
+    equals,
+  };
+}
+
+export function contramap<A, B>(
+  hashEq: HashEq<A>,
+  project: (value: B) => A,
+): HashEq<B> {
+  return fromHashEq(
+    (value) => hashEq.hash(project(value)),
+    (left, right) => hashEq.equals(project(left), project(right)),
+  );
+}
+
+export function lazyHashEq<T>(getHashEq: () => HashEq<T>): HashEq<T> {
+  return fromHashEq(
+    (value) => getHashEq().hash(value),
+    (left, right) => getHashEq().equals(left, right),
+  );
+}
+
+export function arrayHash<T>(itemHash: HashEq<T>): HashEq<readonly T[]> {
+  return fromHashEq(
+    (value) => combineHashes(...value.map((entry) => itemHash.hash(entry))),
+    (left, right) => {
+      if (left.length !== right.length) {
+        return false;
+      }
+
+      for (let index = 0; index < left.length; index += 1) {
+        if (!itemHash.equals(left[index]!, right[index]!)) {
+          return false;
+        }
+      }
+
+      return true;
+    },
+  );
+}
+
+export function tupleHash<const THashEqs extends readonly HashEq<unknown>[]>(
+  ...elements: THashEqs
+): HashEq<{ readonly [K in keyof THashEqs]: HashEqValue<THashEqs[K]> }> {
+  return fromHashEq(
+    (value) => {
+      const values = value as readonly unknown[];
+      if (values.length !== elements.length) {
+        return 0;
+      }
+      return combineHashes(
+        ...elements.map((elementHash, index) => elementHash.hash(values[index])),
+      );
+    },
+    (left, right) => {
+      const leftValues = left as readonly unknown[];
+      const rightValues = right as readonly unknown[];
+      if (leftValues.length !== elements.length || rightValues.length !== elements.length) {
+        return false;
+      }
+
+      for (let index = 0; index < elements.length; index += 1) {
+        const elementHash = elements[index];
+        if (!elementHash) {
+          continue;
+        }
+        if (!elementHash.equals(leftValues[index], rightValues[index])) {
+          return false;
+        }
+      }
+
+      return true;
+    },
+  );
+}
+
+export function optionHash<T>(itemHash: HashEq<T>): HashEq<Option<T>> {
+  return fromHashEq(
+    (value) =>
+      isSome(value)
+        ? combineHashes(stringHash.hash('some'), itemHash.hash(value.value))
+        : stringHash.hash('none'),
+    (left, right) => {
+      if (isSome(left) && isSome(right)) {
+        return itemHash.equals(left.value, right.value);
+      }
+
+      return isNone(left) && isNone(right);
+    },
+  );
+}
+
+export function resultHash<T, E>(okHash: HashEq<T>, errHash: HashEq<E>): HashEq<Result<T, E>> {
+  return fromHashEq(
+    (value) =>
+      isOk(value)
+        ? combineHashes(stringHash.hash('ok'), okHash.hash(value.value))
+        : combineHashes(stringHash.hash('err'), errHash.hash(value.error)),
+    (left, right) => {
+      if (isOk(left) && isOk(right)) {
+        return okHash.equals(left.value, right.value);
+      }
+
+      if (isErr(left) && isErr(right)) {
+        return errHash.equals(left.error, right.error);
+      }
+
+      return false;
+    },
+  );
+}
+
+export const stringHash: HashEq<string> = fromHashEq(
+  hashString,
+  (left, right) => left === right,
+);
+
+export const numberHash: HashEq<number> = fromHashEq(
+  (value) => hashString(normalizeNumberKey(value)),
+  (left, right) => left === right || (Number.isNaN(left) && Number.isNaN(right)),
+);
+
+export const booleanHash: HashEq<boolean> = fromHashEq(
+  (value) => value ? 1 : 0,
+  (left, right) => left === right,
+);
+
+export const bigintHash: HashEq<bigint> = fromHashEq(
+  (value) => hashString(value.toString()),
+  (left, right) => left === right,
+);
+
+export function combineHashes(...hashes: readonly HashCode[]): HashCode {
+  let hash = 0;
+  for (const value of hashes) {
+    hash = Math.imul(hash ^ normalizeHashCode(value), 0x01000193);
+  }
+  return normalizeHashCode(hash);
+}
+
+function normalizeHashCode(value: number): HashCode {
+  if (!Number.isFinite(value)) {
+    return 0;
+  }
+
+  return value | 0;
+}
+
+function normalizeNumberKey(value: number): string {
+  if (Number.isNaN(value)) {
+    return 'NaN';
+  }
+
+  if (value === 0) {
+    return '0';
+  }
+
+  return String(value);
+}
+
+function hashString(value: string): HashCode {
+  let hash = 0x811c9dc5;
+  for (let index = 0; index < value.length; index += 1) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 0x01000193);
+  }
+  return hash | 0;
+}

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

@@ -0,0 +1,40 @@
+export interface TypeLambda {
+  readonly Args: readonly unknown[];
+  readonly type: unknown;
+}
+
+export type Apply<F extends TypeLambda, Args extends readonly unknown[]> = F extends {
+  readonly __target: infer Target extends TypeLambda;
+  readonly __prefix: infer Prefix extends readonly unknown[];
+} ? Apply<Target, [...Prefix, ...Args]>
+  : (F & { readonly Args: Args })['type'];
+
+export type Bind<F extends TypeLambda, Prefix extends readonly unknown[]> = TypeLambda & {
+  readonly __target: F;
+  readonly __prefix: Prefix;
+};
+
+export type Kind<F extends TypeLambda, A> = Apply<F, [A]>;
+export type Kind2<F extends TypeLambda, A, B> = Apply<F, [A, B]>;
+export type Kind3<F extends TypeLambda, A, B, C> = Apply<F, [A, B, C]>;
+
+export type MonadTypeLambda<M extends { readonly __type_lambda?: TypeLambda }> = M extends {
+  readonly __type_lambda?: infer F extends TypeLambda;
+} ? F
+  : never;
+export type BoundEffect<F extends TypeLambda, A = unknown> = Kind<F, A>;
+export type BoundValue<F extends TypeLambda, Value> = Value extends BoundEffect<F, infer A> ? A
+  : never;
+export type Binder<F extends TypeLambda> = <A>(value: BoundEffect<F, A>) => A;
+
+export type {
+  Applicative,
+  AsyncMonad,
+  Contravariant,
+  Functor,
+  Invariant,
+  Monad,
+} from 'sts:typeclasses';
+export { Do, monadGen } from 'sts:typeclasses';
+
+export const hkt: unknown;

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

@@ -0,0 +1,3 @@
+export { Do, monadGen } from '@soundscript/soundscript/typeclasses';
+// Macro binding placeholder. The compiler-owned macro pipeline consumes this symbol.
+export const hkt = undefined;

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

@@ -0,0 +1,41 @@
+export interface TypeLambda {
+  readonly Args: readonly unknown[];
+  readonly type: unknown;
+}
+
+export type Apply<F extends TypeLambda, Args extends readonly unknown[]> = F extends {
+  readonly __target: infer Target extends TypeLambda;
+  readonly __prefix: infer Prefix extends readonly unknown[];
+} ? Apply<Target, [...Prefix, ...Args]>
+  : (F & { readonly Args: Args })['type'];
+
+export type Bind<F extends TypeLambda, Prefix extends readonly unknown[]> = TypeLambda & {
+  readonly __target: F;
+  readonly __prefix: Prefix;
+};
+
+export type Kind<F extends TypeLambda, A> = Apply<F, [A]>;
+export type Kind2<F extends TypeLambda, A, B> = Apply<F, [A, B]>;
+export type Kind3<F extends TypeLambda, A, B, C> = Apply<F, [A, B, C]>;
+
+export type MonadTypeLambda<M extends { readonly __type_lambda?: TypeLambda }> = M extends {
+  readonly __type_lambda?: infer F extends TypeLambda;
+} ? F
+  : never;
+export type BoundEffect<F extends TypeLambda, A = unknown> = Kind<F, A>;
+export type BoundValue<F extends TypeLambda, Value> = Value extends BoundEffect<F, infer A> ? A
+  : never;
+export type Binder<F extends TypeLambda> = <A>(value: BoundEffect<F, A>) => A;
+
+export type {
+  Applicative,
+  AsyncMonad,
+  Contravariant,
+  Functor,
+  Invariant,
+  Monad,
+} from 'sts:typeclasses';
+export { Do, monadGen } from 'sts:typeclasses';
+
+// Macro binding placeholder. The compiler-owned macro pipeline consumes this symbol.
+export const hkt: unknown = undefined;

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

@@ -0,0 +1,9 @@
+export type { Err, None, Ok, Option, Result, Some } from 'sts:result';
+
+export { err, isErr, isNone, isOk, isSome, none, ok, some, Try } from 'sts:result';
+export { Match, where } from 'sts:match';
+export { Failure } from 'sts:failures';
+
+export function Defer(cleanup: () => unknown): never;
+export function todo(message?: string): never;
+export function unreachable(message?: string): never;

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

@@ -0,0 +1,15 @@
+export { err, isErr, isNone, isOk, isSome, none, ok, some, Try } from '@soundscript/soundscript/result';
+export { Match, where } from '@soundscript/soundscript/match';
+export { Failure } from '@soundscript/soundscript/failures';
+function macroRuntimeError(name) {
+    throw new Error(`${name}(...) is a soundscript macro and should be removed during soundscript expansion.`);
+}
+export function Defer(_cleanup) {
+    return macroRuntimeError('Defer');
+}
+export function todo(message) {
+    throw new Error(message ? `TODO: ${message}` : 'TODO');
+}
+export function unreachable(message) {
+    throw new Error(message ? `Unreachable: ${message}` : 'Unreachable');
+}

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

@@ -0,0 +1,23 @@
+export type { Err, None, Ok, Option, Result, Some } from 'sts:result';
+
+export { err, isErr, isNone, isOk, isSome, none, ok, some, Try } from 'sts:result';
+export { Match, where } from 'sts:match';
+export { Failure } from 'sts:failures';
+
+function macroRuntimeError(name: string): never {
+  throw new Error(
+    `${name}(...) is a soundscript macro and should be removed during soundscript expansion.`,
+  );
+}
+
+export function Defer(_cleanup: () => unknown): never {
+  return macroRuntimeError('Defer');
+}
+
+export function todo(message?: string): never {
+  throw new Error(message ? `TODO: ${message}` : 'TODO');
+}
+
+export function unreachable(message?: string): never {
+  throw new Error(message ? `Unreachable: ${message}` : 'Unreachable');
+}

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

@@ -0,0 +1,125 @@
+import { Failure } from 'sts:failures';
+import type { Decoder } from 'sts:decode';
+import type { Encoder } from 'sts:encode';
+import type { Result } from 'sts:result';
+import type { Numeric } from 'sts:numerics';
+
+export type JsonArray = JsonValue[];
+export type JsonObject = {
+  [key: string]: JsonValue;
+};
+export type JsonValue = string | number | boolean | null | JsonObject | JsonArray;
+type LosslessJsonArray = LosslessJsonValue[];
+type LosslessJsonObject = {
+  [key: string]: LosslessJsonValue;
+};
+export type LosslessJsonValue =
+  | string
+  | number
+  | bigint
+  | boolean
+  | null
+  | LosslessJsonObject
+  | LosslessJsonArray;
+
+export type JsonLikeArray = JsonLikeValue[];
+export type JsonLikeObject = {
+  [key: string]: JsonLikeValue;
+};
+export type JsonLikeValue =
+  | string
+  | number
+  | boolean
+  | bigint
+  | null
+  | undefined
+  | JsonLikeObject
+  | JsonLikeArray;
+
+export type MachineJsonArray = MachineJsonLikeValue[];
+export type MachineJsonObject = {
+  [key: string]: MachineJsonLikeValue;
+};
+export type MachineJsonLikeValue =
+  | string
+  | number
+  | boolean
+  | bigint
+  | null
+  | undefined
+  | Numeric
+  | MachineJsonObject
+  | MachineJsonArray;
+
+export interface JsonParseOptions {
+  int64?: 'default' | 'lossless';
+  numerics?: 'tagged';
+}
+
+export type JsonStringifyBigintMode = 'number' | 'reject' | 'string';
+export type MachineJsonNumericMode = 'tagged' | 'decimal-string' | 'json-number';
+
+export interface JsonStringifyOptions {
+  int64?: 'default' | 'string' | 'lossless';
+  readonly bigint?: JsonStringifyBigintMode;
+  numerics?: MachineJsonNumericMode;
+}
+
+export class JsonParseFailure extends Failure {
+  constructor(cause?: unknown);
+}
+
+export class JsonStringifyFailure extends Failure {
+  constructor(cause?: unknown);
+}
+
+export function parseJson(text: string): Result<JsonValue, JsonParseFailure>;
+export function parseJson(
+  text: string,
+  options: JsonParseOptions & { int64: 'lossless' },
+): Result<LosslessJsonValue, JsonParseFailure>;
+export function parseJson(
+  text: string,
+  options: JsonParseOptions & { numerics: 'tagged' },
+): Result<MachineJsonLikeValue, JsonParseFailure>;
+export function parseJson(
+  text: string,
+  options?: JsonParseOptions,
+): Result<JsonValue | LosslessJsonValue | MachineJsonLikeValue, JsonParseFailure>;
+export function stringifyJson(value: JsonValue): Result<string, JsonStringifyFailure>;
+export function stringifyJson(
+  value: LosslessJsonValue,
+  options: JsonStringifyOptions & { int64: 'string' | 'lossless' },
+): Result<string, JsonStringifyFailure>;
+export function stringifyJson(
+  value: MachineJsonLikeValue,
+  options: JsonStringifyOptions & { numerics: MachineJsonNumericMode },
+): Result<string, JsonStringifyFailure>;
+export function stringifyJson(
+  value: JsonValue | LosslessJsonValue | MachineJsonLikeValue,
+  options?: JsonStringifyOptions,
+): Result<string, JsonStringifyFailure>;
+export function parseAndDecode<T, E>(
+  text: string,
+  decoder: Decoder<T, E>,
+): Result<T, JsonParseFailure | E>;
+export function encodeAndStringify<T, E>(
+  value: T,
+  encoder: Encoder<T, JsonValue, E>,
+): Result<string, E | JsonStringifyFailure>;
+export function isJsonValue(value: unknown): value is JsonValue;
+export function parseJsonLike(text: string): Result<JsonLikeValue, JsonParseFailure>;
+export function stringifyJsonLike(
+  value: JsonLikeValue,
+  options?: JsonStringifyOptions,
+): Result<string, JsonStringifyFailure>;
+export function decodeJson<T, E>(
+  text: string,
+  decoder: Decoder<T, E>,
+): Result<T, E | JsonParseFailure>;
+export function encodeJson<T, E>(
+  value: T,
+  encoder: Encoder<T, JsonLikeValue, E>,
+  options?: JsonStringifyOptions,
+): Result<string, E | JsonStringifyFailure>;
+export function isJsonLikeValue(value: unknown): value is JsonLikeValue;