@soundscript/cli-darwin-arm64 0.1.0

package/src/stdlib/result.d.ts

@@ -0,0 +1,52 @@
+import type { Bind, Kind, Kind2, TypeLambda } from 'sts:hkt';
+import type { Applicative, Functor, Monad } from 'sts:typeclasses';
+
+// #[variance(T: out)]
+export type Ok<T> = { readonly tag: 'ok'; readonly value: T };
+// #[variance(E: out)]
+export type Err<E> = { readonly tag: 'err'; readonly error: E };
+
+// #[variance(T: out, E: out)]
+export type Result<T, E> = Ok<T> | Err<E>;
+// #[variance(T: out)]
+export type Some<T> = Ok<T>;
+export type None = Err<void>;
+// #[variance(T: out)]
+export type Option<T> = Result<T, void>;
+
+export interface OptionF extends TypeLambda {
+  readonly type: Option<this['Args'][0]>;
+}
+
+export interface ResultF extends TypeLambda {
+  readonly type: Result<this['Args'][1], this['Args'][0]>;
+}
+
+export type OptionKind<T> = Kind<OptionF, T>;
+export type ResultKind<E, T> = Kind2<ResultF, E, T>;
+
+export function ok<T>(value: T): Result<T, never>;
+export function err(): Result<never, void>;
+export function err<E>(error: E): Result<never, E>;
+export function some<T>(value: T): Option<T>;
+export function none(): Option<never>;
+export function isOk<T, E>(value: Result<T, E>): value is Ok<T>;
+export function isErr<T, E>(value: Result<T, E>): value is Err<E>;
+export function isSome<T>(value: Option<T>): value is Some<T>;
+export function isNone<T>(value: Option<T>): value is None;
+export function resultOf<T>(fn: () => Promise<T>): Promise<Result<T, Error>>;
+export function resultOf<T, E>(
+  fn: () => Promise<T>,
+  mapError: (error: Error) => E,
+): Promise<Result<T, E>>;
+export function resultOf<T>(fn: () => T): Result<T, Error>;
+export function resultOf<T, E>(fn: () => T, mapError: (error: Error) => E): Result<T, E>;
+
+export const optionFunctor: Functor<OptionF>;
+export const optionApplicative: Applicative<OptionF>;
+export const optionMonad: Monad<OptionF>;
+export function resultFunctor<E>(): Functor<Bind<ResultF, [E]>>;
+export function resultApplicative<E>(): Applicative<Bind<ResultF, [E]>>;
+export function resultMonad<E>(): Monad<Bind<ResultF, [E]>>;
+
+export function Try<T, E>(value: Result<T, E>): T;

package/src/stdlib/sql.d.ts

@@ -0,0 +1,22 @@
+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;
+}
+
+export const sql: SqlTag;

package/src/stdlib/thunk.d.ts

@@ -0,0 +1,2 @@
+export function lazy<T>(value: T): () => T;
+export function memo<T>(value: T): () => T;

package/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: PromiseLike<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 | PromiseLike<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;