@soundscript/soundscript 0.1.0

package/soundscript/experimental/css.sts

@@ -0,0 +1,28 @@
+export interface CssRawFragment {
+  readonly __cssKind: 'raw';
+  readonly text: string;
+}
+
+export interface CssTemplate {
+  readonly text: string;
+  readonly values: readonly unknown[];
+}
+
+export interface CssTag {
+  (strings: TemplateStringsArray, ...values: readonly unknown[]): CssTemplate;
+  raw(text: string): CssRawFragment;
+}
+
+const cssTag: CssTag = Object.assign(
+  (strings: TemplateStringsArray, ...values: readonly unknown[]): CssTemplate => ({
+    text: String.raw({ raw: strings }, ...values.map(String)),
+    values: [...values],
+  }),
+  {
+    raw(text: string): CssRawFragment {
+      return { __cssKind: 'raw', text };
+    },
+  },
+);
+
+export const css = cssTag;

package/soundscript/experimental/debug.sts

@@ -0,0 +1,10 @@
+export function assert(condition: unknown, message = 'Assertion failed.'): asserts condition {
+  if (!condition) {
+    throw new Error(message);
+  }
+}
+
+export function log<T>(value: T): T {
+  console.log(value);
+  return value;
+}

package/soundscript/experimental/graphql.sts

@@ -0,0 +1,28 @@
+export interface GraphqlRawFragment {
+  readonly __graphqlKind: 'raw';
+  readonly text: string;
+}
+
+export interface GraphqlQuery {
+  readonly query: string;
+  readonly values: readonly unknown[];
+}
+
+export interface GraphqlTag {
+  (strings: TemplateStringsArray, ...values: readonly unknown[]): GraphqlQuery;
+  raw(text: string): GraphqlRawFragment;
+}
+
+const graphqlTag: GraphqlTag = Object.assign(
+  (strings: TemplateStringsArray, ...values: readonly unknown[]): GraphqlQuery => ({
+    query: String.raw({ raw: strings }, ...values.map(String)),
+    values: [...values],
+  }),
+  {
+    raw(text: string): GraphqlRawFragment {
+      return { __graphqlKind: 'raw', text };
+    },
+  },
+);
+
+export const graphql = graphqlTag;

package/soundscript/experimental/sql.sts

@@ -0,0 +1,53 @@
+export interface SqlQuery {
+  readonly text: string;
+  readonly params: readonly unknown[];
+}
+
+export interface SqlIdentifier {
+  readonly __sqlKind: 'identifier';
+  readonly name: string;
+}
+
+export interface SqlRawFragment {
+  readonly __sqlKind: 'raw';
+  readonly text: string;
+}
+
+export interface SqlTag {
+  (strings: TemplateStringsArray, ...values: readonly unknown[]): SqlQuery;
+  ident(name: string): SqlIdentifier;
+  raw(text: string): SqlRawFragment;
+}
+
+function buildSqlQuery(
+  strings: TemplateStringsArray,
+  values: readonly unknown[],
+): SqlQuery {
+  let text = '';
+  for (let index = 0; index < strings.length; index += 1) {
+    text += strings[index] ?? '';
+    if (index < values.length) {
+      text += `$${index + 1}`;
+    }
+  }
+
+  return {
+    text,
+    params: [...values],
+  };
+}
+
+const sqlTag = ((strings: TemplateStringsArray, ...values: readonly unknown[]) =>
+  buildSqlQuery(strings, values)) as SqlTag;
+
+sqlTag.ident = (name: string): SqlIdentifier => ({
+  __sqlKind: 'identifier',
+  name,
+});
+
+sqlTag.raw = (text: string): SqlRawFragment => ({
+  __sqlKind: 'raw',
+  text,
+});
+
+export const sql = sqlTag;

package/soundscript/failures.sts

@@ -0,0 +1,64 @@
+export type ErrorFrame = {
+  readonly column: number;
+  readonly file: string;
+  readonly fn?: string;
+  readonly line: number;
+};
+
+export class Failure {
+  readonly cause?: unknown;
+  readonly message: string;
+  readonly name: string;
+  readonly trace: readonly ErrorFrame[];
+
+  constructor(
+    message = '',
+    options: {
+      cause?: unknown;
+      trace?: readonly ErrorFrame[];
+    } = {},
+  ) {
+    this.name = new.target.name;
+    this.message = message;
+    if ('cause' in options) {
+      this.cause = options.cause;
+    }
+    this.trace = options.trace ?? [];
+  }
+
+  withFrame(frame: ErrorFrame): this {
+    const prototype = Object.getPrototypeOf(this as object);
+    const clone = (prototype === null ? Object.create(null) : Object.create(prototype)) as this;
+    Object.defineProperties(clone, Object.getOwnPropertyDescriptors(this));
+    Object.defineProperty(clone, 'trace', {
+      configurable: true,
+      enumerable: true,
+      writable: false,
+      value: [...this.trace, frame],
+    });
+    return clone;
+  }
+}
+
+export function normalizeThrown(value: unknown): Error {
+  if (value instanceof Error) {
+    return value;
+  }
+
+  const details = typeof value === 'object' && value !== null
+    ? value as { message?: unknown; name?: unknown; stack?: unknown }
+    : undefined;
+  const message = typeof details?.message === 'string'
+    ? details.message
+    : 'Non-Error thrown value.';
+  const error = new Error(message, { cause: value });
+
+  if (typeof details?.name === 'string') {
+    error.name = details.name;
+  }
+  if (typeof details?.stack === 'string') {
+    error.stack = details.stack;
+  }
+
+  return error;
+}

package/soundscript/hash.sts

@@ -0,0 +1,196 @@
+import type { Eq } from '@soundscript/soundscript/compare';
+import type { Option, Result } from '@soundscript/soundscript/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) =>
+      value.tag === 'ok'
+        ? combineHashes(stringHash.hash('ok'), itemHash.hash(value.value))
+        : stringHash.hash('err'),
+    (left, right) => {
+      if (left.tag !== right.tag) {
+        return false;
+      }
+
+      if (left.tag === 'ok' && right.tag === 'ok') {
+        return itemHash.equals(left.value, right.value);
+      }
+
+      return true;
+    },
+  );
+}
+
+export function resultHash<T, E>(okHash: HashEq<T>, errHash: HashEq<E>): HashEq<Result<T, E>> {
+  return fromHashEq(
+    (value) =>
+      value.tag === 'ok'
+        ? combineHashes(stringHash.hash('ok'), okHash.hash(value.value))
+        : combineHashes(stringHash.hash('err'), errHash.hash(value.error)),
+    (left, right) => {
+      if (left.tag !== right.tag) {
+        return false;
+      }
+
+      if (left.tag === 'ok' && right.tag === 'ok') {
+        return okHash.equals(left.value, right.value);
+      }
+
+      if (left.tag === 'err' && right.tag === 'err') {
+        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/soundscript/hkt.sts

@@ -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 '@soundscript/soundscript/typeclasses';
+export { Do, monadGen } from '@soundscript/soundscript/typeclasses';
+
+// Macro binding placeholder. The compiler-owned macro pipeline consumes this symbol.
+export const hkt: unknown = undefined;

package/soundscript/index.sts

@@ -0,0 +1,23 @@
+export type { Err, None, Ok, Option, Result, Some } from '@soundscript/soundscript/result';
+
+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: 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');
+}