@clayroach/effect 3.19.14-source-capture.6 → 3.19.14-source-capture.8

package/src/Boolean.ts

@@ -1,287 +0,0 @@
-/**
- * This module provides utility functions and type class instances for working with the `boolean` type in TypeScript.
- * It includes functions for basic boolean operations, as well as type class instances for
- * `Equivalence` and `Order`.
- *
- * @since 2.0.0
- */
-import * as equivalence from "./Equivalence.js"
-import type { LazyArg } from "./Function.js"
-import { dual } from "./Function.js"
-import * as order from "./Order.js"
-import * as predicate from "./Predicate.js"
-
-/**
- * Tests if a value is a `boolean`.
- *
- * @example
- * ```ts
- * import * as assert from "node:assert"
- * import { isBoolean } from "effect/Boolean"
- *
- * assert.deepStrictEqual(isBoolean(true), true)
- * assert.deepStrictEqual(isBoolean("true"), false)
- * ```
- *
- * @category guards
- * @since 2.0.0
- */
-export const isBoolean: (input: unknown) => input is boolean = predicate.isBoolean
-
-/**
- * This function returns the result of either of the given functions depending on the value of the boolean parameter.
- * It is useful when you have to run one of two functions depending on the boolean value.
- *
- * @example
- * ```ts
- * import * as assert from "node:assert"
- * import { Boolean } from "effect"
- *
- * assert.deepStrictEqual(Boolean.match(true, { onFalse: () => "It's false!", onTrue: () => "It's true!" }), "It's true!")
- * ```
- *
- * @category pattern matching
- * @since 2.0.0
- */
-export const match: {
-  <A, B = A>(options: {
-    readonly onFalse: LazyArg<A>
-    readonly onTrue: LazyArg<B>
-  }): (value: boolean) => A | B
-  <A, B>(value: boolean, options: {
-    readonly onFalse: LazyArg<A>
-    readonly onTrue: LazyArg<B>
-  }): A | B
-} = dual(2, <A, B>(value: boolean, options: {
-  readonly onFalse: LazyArg<A>
-  readonly onTrue: LazyArg<B>
-}): A | B => value ? options.onTrue() : options.onFalse())
-
-/**
- * @category instances
- * @since 2.0.0
- */
-export const Equivalence: equivalence.Equivalence<boolean> = equivalence.boolean
-
-/**
- * @category instances
- * @since 2.0.0
- */
-export const Order: order.Order<boolean> = order.boolean
-
-/**
- * Negates the given boolean: `!self`
- *
- * @example
- * ```ts
- * import * as assert from "node:assert"
- * import { not } from "effect/Boolean"
- *
- * assert.deepStrictEqual(not(true), false)
- * assert.deepStrictEqual(not(false), true)
- * ```
- *
- * @category combinators
- * @since 2.0.0
- */
-export const not = (self: boolean): boolean => !self
-
-/**
- * Combines two boolean using AND: `self && that`.
- *
- * @example
- * ```ts
- * import * as assert from "node:assert"
- * import { and } from "effect/Boolean"
- *
- * assert.deepStrictEqual(and(true, true), true)
- * assert.deepStrictEqual(and(true, false), false)
- * assert.deepStrictEqual(and(false, true), false)
- * assert.deepStrictEqual(and(false, false), false)
- * ```
- *
- * @category combinators
- * @since 2.0.0
- */
-export const and: {
-  (that: boolean): (self: boolean) => boolean
-  (self: boolean, that: boolean): boolean
-} = dual(2, (self: boolean, that: boolean): boolean => self && that)
-
-/**
- * Combines two boolean using NAND: `!(self && that)`.
- *
- * @example
- * ```ts
- * import * as assert from "node:assert"
- * import { nand } from "effect/Boolean"
- *
- * assert.deepStrictEqual(nand(true, true), false)
- * assert.deepStrictEqual(nand(true, false), true)
- * assert.deepStrictEqual(nand(false, true), true)
- * assert.deepStrictEqual(nand(false, false), true)
- * ```
- *
- * @category combinators
- * @since 2.0.0
- */
-export const nand: {
-  (that: boolean): (self: boolean) => boolean
-  (self: boolean, that: boolean): boolean
-} = dual(2, (self: boolean, that: boolean): boolean => !(self && that))
-
-/**
- * Combines two boolean using OR: `self || that`.
- *
- * @example
- * ```ts
- * import * as assert from "node:assert"
- * import { or } from "effect/Boolean"
- *
- * assert.deepStrictEqual(or(true, true), true)
- * assert.deepStrictEqual(or(true, false), true)
- * assert.deepStrictEqual(or(false, true), true)
- * assert.deepStrictEqual(or(false, false), false)
- * ```
- *
- * @category combinators
- * @since 2.0.0
- */
-export const or: {
-  (that: boolean): (self: boolean) => boolean
-  (self: boolean, that: boolean): boolean
-} = dual(2, (self: boolean, that: boolean): boolean => self || that)
-
-/**
- * Combines two booleans using NOR: `!(self || that)`.
- *
- * @example
- * ```ts
- * import * as assert from "node:assert"
- * import { nor } from "effect/Boolean"
- *
- * assert.deepStrictEqual(nor(true, true), false)
- * assert.deepStrictEqual(nor(true, false), false)
- * assert.deepStrictEqual(nor(false, true), false)
- * assert.deepStrictEqual(nor(false, false), true)
- * ```
- *
- * @category combinators
- * @since 2.0.0
- */
-export const nor: {
-  (that: boolean): (self: boolean) => boolean
-  (self: boolean, that: boolean): boolean
-} = dual(2, (self: boolean, that: boolean): boolean => !(self || that))
-
-/**
- * Combines two booleans using XOR: `(!self && that) || (self && !that)`.
- *
- * @example
- * ```ts
- * import * as assert from "node:assert"
- * import { xor } from "effect/Boolean"
- *
- * assert.deepStrictEqual(xor(true, true), false)
- * assert.deepStrictEqual(xor(true, false), true)
- * assert.deepStrictEqual(xor(false, true), true)
- * assert.deepStrictEqual(xor(false, false), false)
- * ```
- *
- * @category combinators
- * @since 2.0.0
- */
-export const xor: {
-  (that: boolean): (self: boolean) => boolean
-  (self: boolean, that: boolean): boolean
-} = dual(2, (self: boolean, that: boolean): boolean => (!self && that) || (self && !that))
-
-/**
- * Combines two booleans using EQV (aka XNOR): `!xor(self, that)`.
- *
- * @example
- * ```ts
- * import * as assert from "node:assert"
- * import { eqv } from "effect/Boolean"
- *
- * assert.deepStrictEqual(eqv(true, true), true)
- * assert.deepStrictEqual(eqv(true, false), false)
- * assert.deepStrictEqual(eqv(false, true), false)
- * assert.deepStrictEqual(eqv(false, false), true)
- * ```
- *
- * @category combinators
- * @since 2.0.0
- */
-export const eqv: {
-  (that: boolean): (self: boolean) => boolean
-  (self: boolean, that: boolean): boolean
-} = dual(2, (self: boolean, that: boolean): boolean => !xor(self, that))
-
-/**
- * Combines two booleans using an implication: `(!self || that)`.
- *
- * @example
- * ```ts
- * import * as assert from "node:assert"
- * import { implies } from "effect/Boolean"
- *
- * assert.deepStrictEqual(implies(true, true), true)
- * assert.deepStrictEqual(implies(true, false), false)
- * assert.deepStrictEqual(implies(false, true), true)
- * assert.deepStrictEqual(implies(false, false), true)
- * ```
- *
- * @category combinators
- * @since 2.0.0
- */
-export const implies: {
-  (that: boolean): (self: boolean) => boolean
-  (self: boolean, that: boolean): boolean
-} = dual(2, (self, that) => self ? that : true)
-
-/**
- * This utility function is used to check if all the elements in a collection of boolean values are `true`.
- *
- * @example
- * ```ts
- * import * as assert from "node:assert"
- * import { every } from "effect/Boolean"
- *
- * assert.deepStrictEqual(every([true, true, true]), true)
- * assert.deepStrictEqual(every([true, false, true]), false)
- * ```
- *
- * @since 2.0.0
- */
-export const every = (collection: Iterable<boolean>): boolean => {
-  for (const b of collection) {
-    if (!b) {
-      return false
-    }
-  }
-  return true
-}
-
-/**
- * This utility function is used to check if at least one of the elements in a collection of boolean values is `true`.
- *
- * @example
- * ```ts
- * import * as assert from "node:assert"
- * import { some } from "effect/Boolean"
- *
- * assert.deepStrictEqual(some([true, false, true]), true)
- * assert.deepStrictEqual(some([false, false, false]), false)
- * ```
- *
- * @since 2.0.0
- */
-export const some = (collection: Iterable<boolean>): boolean => {
-  for (const b of collection) {
-    if (b) {
-      return true
-    }
-  }
-  return false
-}

package/src/Brand.ts

@@ -1,360 +0,0 @@
-/**
- * This module provides types and utility functions to create and work with branded types,
- * which are TypeScript types with an added type tag to prevent accidental usage of a value in the wrong context.
- *
- * The `refined` and `nominal` functions are both used to create branded types in TypeScript.
- * The main difference between them is that `refined` allows for validation of the data, while `nominal` does not.
- *
- * The `nominal` function is used to create a new branded type that has the same underlying type as the input, but with a different name.
- * This is useful when you want to distinguish between two values of the same type that have different meanings.
- * The `nominal` function does not perform any validation of the input data.
- *
- * On the other hand, the `refined` function is used to create a new branded type that has the same underlying type as the input,
- * but with a different name, and it also allows for validation of the input data.
- * The `refined` function takes a predicate that is used to validate the input data.
- * If the input data fails the validation, a `BrandErrors` is returned, which provides information about the specific validation failure.
- *
- * @since 2.0.0
- */
-import * as Arr from "./Array.js"
-import * as Either from "./Either.js"
-import { identity, unsafeCoerce } from "./Function.js"
-import * as Option from "./Option.js"
-import type { Predicate } from "./Predicate.js"
-import type * as Types from "./Types.js"
-
-/**
- * @since 2.0.0
- * @category symbols
- */
-export const BrandTypeId: unique symbol = Symbol.for("effect/Brand")
-
-/**
- * @since 2.0.0
- * @category symbols
- */
-export type BrandTypeId = typeof BrandTypeId
-
-/**
- * @since 2.0.0
- * @category symbols
- */
-export const RefinedConstructorsTypeId: unique symbol = Symbol.for("effect/Brand/Refined")
-
-/**
- * @since 2.0.0
- * @category symbols
- */
-export type RefinedConstructorsTypeId = typeof RefinedConstructorsTypeId
-
-/**
- * A generic interface that defines a branded type.
- *
- * @since 2.0.0
- * @category models
- */
-export interface Brand<in out K extends string | symbol> {
-  readonly [BrandTypeId]: {
-    readonly [k in K]: K
-  }
-}
-
-/**
- * @since 2.0.0
- */
-export declare namespace Brand {
-  /**
-   * Represents a list of refinement errors.
-   *
-   * @since 2.0.0
-   * @category models
-   */
-  export interface BrandErrors extends Array<RefinementError> {}
-
-  /**
-   * Represents an error that occurs when the provided value of the branded type does not pass the refinement predicate.
-   *
-   * @since 2.0.0
-   * @category models
-   */
-  export interface RefinementError {
-    readonly meta: unknown
-    readonly message: string
-  }
-
-  /**
-   * @since 2.0.0
-   * @category models
-   */
-  export interface Constructor<in out A extends Brand<any>> {
-    readonly [RefinedConstructorsTypeId]: RefinedConstructorsTypeId
-    /**
-     * Constructs a branded type from a value of type `A`, throwing an error if
-     * the provided `A` is not valid.
-     */
-    (args: Brand.Unbranded<A>): A
-    /**
-     * Constructs a branded type from a value of type `A`, returning `Some<A>`
-     * if the provided `A` is valid, `None` otherwise.
-     */
-    option(args: Brand.Unbranded<A>): Option.Option<A>
-    /**
-     * Constructs a branded type from a value of type `A`, returning `Right<A>`
-     * if the provided `A` is valid, `Left<BrandError>` otherwise.
-     */
-    either(args: Brand.Unbranded<A>): Either.Either<A, Brand.BrandErrors>
-    /**
-     * Attempts to refine the provided value of type `A`, returning `true` if
-     * the provided `A` is valid, `false` otherwise.
-     */
-    is(a: Brand.Unbranded<A>): a is Brand.Unbranded<A> & A
-  }
-
-  /**
-   * A utility type to extract a branded type from a `Brand.Constructor`.
-   *
-   * @since 2.0.0
-   * @category models
-   */
-  export type FromConstructor<A> = A extends Brand.Constructor<infer B> ? B : never
-
-  /**
-   * A utility type to extract the value type from a brand.
-   *
-   * @since 2.0.0
-   * @category models
-   */
-  export type Unbranded<P> = P extends infer Q & Brands<P> ? Q : P
-
-  /**
-   * A utility type to extract the brands from a branded type.
-   *
-   * @since 2.0.0
-   * @category models
-   */
-  export type Brands<P> = P extends Brand<any> ? Types.UnionToIntersection<
-      {
-        [k in keyof P[BrandTypeId]]: k extends string | symbol ? Brand<k>
-          : never
-      }[keyof P[BrandTypeId]]
-    >
-    : never
-
-  /**
-   * A utility type that checks that all brands have the same base type.
-   *
-   * @since 2.0.0
-   * @category models
-   */
-  export type EnsureCommonBase<
-    Brands extends readonly [Brand.Constructor<any>, ...Array<Brand.Constructor<any>>]
-  > = {
-    [B in keyof Brands]: Brand.Unbranded<Brand.FromConstructor<Brands[0]>> extends
-      Brand.Unbranded<Brand.FromConstructor<Brands[B]>>
-      ? Brand.Unbranded<Brand.FromConstructor<Brands[B]>> extends Brand.Unbranded<Brand.FromConstructor<Brands[0]>>
-        ? Brands[B]
-      : Brands[B]
-      : "ERROR: All brands should have the same base type"
-  }
-}
-
-/**
- * @category alias
- * @since 2.0.0
- */
-export type Branded<A, K extends string | symbol> = A & Brand<K>
-
-/**
- * Returns a `BrandErrors` that contains a single `RefinementError`.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const error = (message: string, meta?: unknown): Brand.BrandErrors => [{
-  message,
-  meta
-}]
-
-/**
- * Takes a variable number of `BrandErrors` and returns a single `BrandErrors` that contains all refinement errors.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const errors: (...errors: Array<Brand.BrandErrors>) => Brand.BrandErrors = (
-  ...errors: Array<Brand.BrandErrors>
-): Brand.BrandErrors => Arr.flatten(errors)
-
-/**
- * Returns a `Brand.Constructor` that can construct a branded type from an unbranded value using the provided `refinement`
- * predicate as validation of the input data.
- *
- * If you don't want to perform any validation but only distinguish between two values of the same type but with different meanings,
- * see {@link nominal}.
- *
- * **Example**
- *
- * ```ts
- * import * as assert from "node:assert"
- * import { Brand } from "effect"
- *
- * type Int = number & Brand.Brand<"Int">
- *
- * const Int = Brand.refined<Int>(
- *   (n) => Number.isInteger(n),
- *   (n) => Brand.error(`Expected ${n} to be an integer`)
- * )
- *
- * console.log(Int(1))
- * // 1
- *
- * assert.throws(() => Int(1.1))
- * ```
- *
- * @since 2.0.0
- * @category constructors
- */
-export function refined<A extends Brand<any>>(
-  f: (unbranded: Brand.Unbranded<A>) => Option.Option<Brand.BrandErrors>
-): Brand.Constructor<A>
-export function refined<A extends Brand<any>>(
-  refinement: Predicate<Brand.Unbranded<A>>,
-  onFailure: (unbranded: Brand.Unbranded<A>) => Brand.BrandErrors
-): Brand.Constructor<A>
-export function refined<A extends Brand<any>>(
-  ...args: [(unbranded: Brand.Unbranded<A>) => Option.Option<Brand.BrandErrors>] | [
-    Predicate<Brand.Unbranded<A>>,
-    (unbranded: Brand.Unbranded<A>) => Brand.BrandErrors
-  ]
-): Brand.Constructor<A> {
-  const either: (unbranded: Brand.Unbranded<A>) => Either.Either<A, Brand.BrandErrors> = args.length === 2 ?
-    (unbranded) => args[0](unbranded) ? Either.right(unbranded as A) : Either.left(args[1](unbranded)) :
-    (unbranded) => {
-      return Option.match(args[0](unbranded), {
-        onNone: () => Either.right(unbranded as A),
-        onSome: Either.left
-      })
-    }
-  return Object.assign((unbranded: Brand.Unbranded<A>) => Either.getOrThrowWith(either(unbranded), identity), {
-    [RefinedConstructorsTypeId]: RefinedConstructorsTypeId,
-    option: (args: any) => Option.getRight(either(args)),
-    either,
-    is: (args: any): args is Brand.Unbranded<A> & A => Either.isRight(either(args))
-  }) as any
-}
-
-/**
- * This function returns a `Brand.Constructor` that **does not apply any runtime checks**, it just returns the provided value.
- * It can be used to create nominal types that allow distinguishing between two values of the same type but with different meanings.
- *
- * If you also want to perform some validation, see {@link refined}.
- *
- * **Example**
- *
- * ```ts
- * import * as assert from "node:assert"
- * import { Brand } from "effect"
- *
- * type UserId = number & Brand.Brand<"UserId">
- *
- * const UserId = Brand.nominal<UserId>()
- *
- * console.log(UserId(1))
- * // 1
- * ```
- *
- * @since 2.0.0
- * @category constructors
- */
-export const nominal = <A extends Brand<any>>(): Brand.Constructor<
-  A
-> => {
-  // @ts-expect-error
-  return Object.assign((args) => args, {
-    [RefinedConstructorsTypeId]: RefinedConstructorsTypeId,
-    option: (args: any) => Option.some(args),
-    either: (args: any) => Either.right(args),
-    is: (_args: any): _args is Brand.Unbranded<A> & A => true
-  })
-}
-
-/**
- * Combines two or more brands together to form a single branded type.
- * This API is useful when you want to validate that the input data passes multiple brand validators.
- *
- * **Example**
- *
- * ```ts
- * import * as assert from "node:assert"
- * import { Brand } from "effect"
- *
- * type Int = number & Brand.Brand<"Int">
- * const Int = Brand.refined<Int>(
- *   (n) => Number.isInteger(n),
- *   (n) => Brand.error(`Expected ${n} to be an integer`)
- * )
- * type Positive = number & Brand.Brand<"Positive">
- * const Positive = Brand.refined<Positive>(
- *   (n) => n > 0,
- *   (n) => Brand.error(`Expected ${n} to be positive`)
- * )
- *
- * const PositiveInt = Brand.all(Int, Positive)
- *
- * console.log(PositiveInt(1))
- * // 1
- *
- * assert.throws(() => PositiveInt(1.1))
- * ```
- *
- * @since 2.0.0
- * @category combining
- */
-export const all: <Brands extends readonly [Brand.Constructor<any>, ...Array<Brand.Constructor<any>>]>(
-  ...brands: Brand.EnsureCommonBase<Brands>
-) => Brand.Constructor<
-  Types.UnionToIntersection<{ [B in keyof Brands]: Brand.FromConstructor<Brands[B]> }[number]> extends
-    infer X extends Brand<any> ? X : Brand<any>
-> = <
-  Brands extends readonly [Brand.Constructor<any>, ...Array<Brand.Constructor<any>>]
->(...brands: Brand.EnsureCommonBase<Brands>): Brand.Constructor<
-  Types.UnionToIntersection<
-    {
-      [B in keyof Brands]: Brand.FromConstructor<Brands[B]>
-    }[number]
-  > extends infer X extends Brand<any> ? X : Brand<any>
-> => {
-  const either = (args: any): Either.Either<any, Brand.BrandErrors> => {
-    let result: Either.Either<any, Brand.BrandErrors> = Either.right(args)
-    for (const brand of brands) {
-      const nextResult = brand.either(args)
-      if (Either.isLeft(result) && Either.isLeft(nextResult)) {
-        result = Either.left([...result.left, ...nextResult.left])
-      } else {
-        result = Either.isLeft(result) ? result : nextResult
-      }
-    }
-    return result
-  }
-  // @ts-expect-error
-  return Object.assign((args) =>
-    Either.match(either(args), {
-      onLeft: (e) => {
-        throw e
-      },
-      onRight: identity
-    }), {
-    [RefinedConstructorsTypeId]: RefinedConstructorsTypeId,
-    option: (args: any) => Option.getRight(either(args)),
-    either,
-    is: (args: any): args is any => Either.isRight(either(args))
-  })
-}
-
-/**
- * Retrieves the unbranded value from a `Brand` instance.
- *
- * @since 3.15.0
- * @category getters
- */
-export const unbranded: <A extends Brand<any>>(branded: A) => Brand.Unbranded<A> = unsafeCoerce