rivo/Result/core.d.ts

🤖 The ultimate library you need for composable type-level programming in TypeScript, powered by HKT.

import type { Result } from ".";
import type { Arg0, Args, Fn, GenericFn, GenericResolver } from "../HKT";
import type { AssertBool, IsNever, Lazied, Lazied$Get } from "../helpers";

export interface Ok<T> {
  readonly _tag: "Ok";
  readonly ok: T;
}
export interface OkL<L extends Lazied> extends Ok<Lazied$Get<L>> {}

export interface Err<E> {
  readonly _tag: "Err";
  readonly err: E;
}
export interface ErrL<L extends Lazied> extends Err<Lazied$Get<L>> {}

/**
 * Wrap a value in an {@link Ok}.
 *
 * Sig: `<T>(value: T) => Ok<T>`
 *
 * @example
 * ```typescript
 * type R = OfOk<42>;
 * //   ^?: Ok<42>
 * ```
 */
export type OfOk<T> = Ok<T>;

interface OfOkResolver extends GenericResolver<[unknown], Ok<unknown>> {
  on1: ([o]: Args<this>) => [[], Ok<typeof o>];
}
/**
 * [Fn] Wrap a value in an {@link Ok}.
 *
 * Sig: `<T>(value: T) => Ok<T>`
 */
export interface OfOkFn extends GenericFn<OfOkResolver> {
  def: () => OfOk<Arg0<this>>;
}

/**
 * Check if a {@link Result} is {@link Ok}.
 */
export type IsOk<R extends Result<unknown, unknown>> = AssertBool<
  IsNever<R> extends true ? never
  : R["_tag"] extends "Ok" ? true
  : R["_tag"] extends "Err" ? false
  : boolean
>;
/**
 * [Fn] Check if a {@link Result} is {@link Ok}.
 */
export interface IsOkFn extends Fn<[Result<unknown, unknown>], boolean> {
  def: ([value]: Args<this>) => IsOk<typeof value>;
}

/**
 * Wrap a value in an {@link Err}.
 *
 * Sig: `<E>(err: E) => Err<E>`
 *
 * @example
 * ```typescript
 * type R = OfErr<"Something went wrong">;
 * //   ^?: Err<"Something went wrong">
 * ```
 */
export type OfErr<T> = Err<T>;

interface OfErrResolver extends GenericResolver<[unknown], Err<unknown>> {
  on1: ([err]: Args<this>) => [[], Err<typeof err>];
}
/**
 * [Fn] Wrap a value in an {@link Err}.
 *
 * Sig: `<E>(err: E) => Err<E>`
 */
export interface OfErrFn extends GenericFn<OfErrResolver> {
  def: () => OfErr<Arg0<this>>;
}

/**
 * Check if a {@link Result} is {@link Err}.
 */
export type IsErr<R extends Result<unknown, unknown>> = AssertBool<
  IsNever<R> extends true ? never
  : R["_tag"] extends "Err" ? true
  : R["_tag"] extends "Ok" ? false
  : boolean
>;
/**
 * [Fn] Check if a {@link Result} is {@link Err}.
 */
export interface IsErrFn extends Fn<[Result<unknown, unknown>], boolean> {
  def: ([r]: Args<this>) => IsErr<typeof r>;
}