effect 2.0.0-next.43 → 2.0.0-next.45

package/src/Encoding.ts

@@ -0,0 +1,130 @@
+/**
+ * This module provides encoding & decoding functionality for:
+ *
+ * - base64 (RFC4648)
+ * - base64 (URL)
+ * - hex
+ *
+ * @since 2.0.0
+ */
+import * as Either from "./Either"
+import * as Base64 from "./internal/Encoding/Base64"
+import * as Base64Url from "./internal/Encoding/Base64Url"
+import * as Common from "./internal/Encoding/Common"
+import * as Hex from "./internal/Encoding/Hex"
+
+/**
+ * Encodes the given value into a base64 (RFC4648) `string`.
+ *
+ * @category encoding
+ * @since 2.0.0
+ */
+export const encodeBase64: (input: Uint8Array | string) => string = (input) =>
+  typeof input === "string" ? Base64.encode(Common.encoder.encode(input)) : Base64.encode(input)
+
+/**
+ * Decodes a base64 (RFC4648) encoded `string` into a `Uint8Array`.
+ *
+ * @category decoding
+ * @since 2.0.0
+ */
+export const decodeBase64 = (str: string): Either.Either<DecodeException, Uint8Array> => Base64.decode(str)
+
+/**
+ * Decodes a base64 (RFC4648) encoded `string` into a UTF-8 `string`.
+ *
+ * @category decoding
+ * @since 2.0.0
+ */
+export const decodeBase64String = (str: string) => Either.map(decodeBase64(str), (_) => Common.decoder.decode(_))
+
+/**
+ * Encodes the given value into a base64 (URL) `string`.
+ *
+ * @category encoding
+ * @since 2.0.0
+ */
+export const encodeBase64Url: (input: Uint8Array | string) => string = (input) =>
+  typeof input === "string" ? Base64Url.encode(Common.encoder.encode(input)) : Base64Url.encode(input)
+
+/**
+ * Decodes a base64 (URL) encoded `string` into a `Uint8Array`.
+ *
+ * @category decoding
+ * @since 2.0.0
+ */
+export const decodeBase64Url = (str: string): Either.Either<DecodeException, Uint8Array> => Base64Url.decode(str)
+
+/**
+ * Decodes a base64 (URL) encoded `string` into a UTF-8 `string`.
+ *
+ * @category decoding
+ * @since 2.0.0
+ */
+export const decodeBase64UrlString = (str: string) => Either.map(decodeBase64Url(str), (_) => Common.decoder.decode(_))
+
+/**
+ * Encodes the given value into a hex `string`.
+ *
+ * @category encoding
+ * @since 2.0.0
+ */
+export const encodeHex: (input: Uint8Array | string) => string = (input) =>
+  typeof input === "string" ? Hex.encode(Common.encoder.encode(input)) : Hex.encode(input)
+
+/**
+ * Decodes a hex encoded `string` into a `Uint8Array`.
+ *
+ * @category decoding
+ * @since 2.0.0
+ */
+export const decodeHex = (str: string): Either.Either<DecodeException, Uint8Array> => Hex.decode(str)
+
+/**
+ * Decodes a hex encoded `string` into a UTF-8 `string`.
+ *
+ * @category decoding
+ * @since 2.0.0
+ */
+export const decodeHexString = (str: string) => Either.map(decodeHex(str), (_) => Common.decoder.decode(_))
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const DecodeExceptionTypeId: unique symbol = Common.DecodeExceptionTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type DecodeExceptionTypeId = typeof DecodeExceptionTypeId
+
+/**
+ * Represents a checked exception which occurs when decoding fails.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export interface DecodeException {
+  readonly _tag: "DecodeException"
+  readonly [DecodeExceptionTypeId]: DecodeExceptionTypeId
+  readonly input: string
+  readonly message?: string
+}
+
+/**
+ * Creates a checked exception which occurs when decoding fails.
+ *
+ * @since 2.0.0
+ * @category errors
+ */
+export const DecodeException: (input: string, message?: string) => DecodeException = Common.DecodeException
+
+/**
+ * Returns `true` if the specified value is an `DecodeException`, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isDecodeException: (u: unknown) => u is DecodeException = Common.isDecodeException

package/src/Equal.ts

@@ -0,0 +1,64 @@
+/**
+ * @since 2.0.0
+ */
+import type { Equivalence } from "./Equivalence"
+import * as Hash from "./Hash"
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const symbol: unique symbol = Symbol.for("effect/Equal")
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface Equal extends Hash.Hash {
+  [symbol](that: Equal): boolean
+}
+
+/**
+ * @since 2.0.0
+ * @category equality
+ */
+export function equals<B>(that: B): <A>(self: A) => boolean
+export function equals<A, B>(self: A, that: B): boolean
+export function equals(): any {
+  if (arguments.length === 1) {
+    return (self: unknown) => compareBoth(self, arguments[0])
+  }
+  return compareBoth(arguments[0], arguments[1])
+}
+
+function compareBoth(self: unknown, that: unknown) {
+  if (self === that) {
+    return true
+  }
+  const selfType = typeof self
+  if (selfType !== typeof that) {
+    return false
+  }
+  if (
+    (selfType === "object" || selfType === "function") &&
+    self !== null &&
+    that !== null
+  ) {
+    if (isEqual(self) && isEqual(that)) {
+      return Hash.hash(self) === Hash.hash(that) && self[symbol](that)
+    }
+  }
+  return false
+}
+
+/**
+ * @since 2.0.0
+ * @category guards
+ */
+export const isEqual = (u: unknown): u is Equal => typeof u === "object" && u !== null && symbol in u
+
+/**
+ * @since 2.0.0
+ * @category instances
+ */
+export const equivalence: <A>() => Equivalence<A> = () => (self, that) => equals(self, that)

package/src/Equivalence.ts

@@ -0,0 +1,235 @@
+/**
+ * This module provides an implementation of the `Equivalence` type class, which defines a binary relation
+ * that is reflexive, symmetric, and transitive. In other words, it defines a notion of equivalence between values of a certain type.
+ * These properties are also known in mathematics as an "equivalence relation".
+ *
+ * @since 2.0.0
+ */
+import { dual } from "./Function"
+import type { TypeLambda } from "./HKT"
+
+/**
+ * @category type class
+ * @since 2.0.0
+ */
+export interface Equivalence<A> {
+  (self: A, that: A): boolean
+}
+
+/**
+ * @category type lambdas
+ * @since 2.0.0
+ */
+export interface EquivalenceTypeLambda extends TypeLambda {
+  readonly type: Equivalence<this["Target"]>
+}
+
+/**
+ * @category constructors
+ * @since 2.0.0
+ */
+export const make = <A>(isEquivalent: (self: A, that: A) => boolean): Equivalence<A> => (self: A, that: A): boolean =>
+  self === that || isEquivalent(self, that)
+
+const isStrictEquivalent = (x: unknown, y: unknown) => x === y
+
+/**
+ * Return an `Equivalence` that uses strict equality (===) to compare values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const strict: <A>() => Equivalence<A> = () => isStrictEquivalent
+
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+export const string: Equivalence<string> = strict()
+
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+export const number: Equivalence<number> = strict()
+
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+export const boolean: Equivalence<boolean> = strict()
+
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+export const bigint: Equivalence<bigint> = strict()
+
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+export const symbol: Equivalence<symbol> = strict()
+
+/**
+ * @category combining
+ * @since 2.0.0
+ */
+export const combine: {
+  <A>(that: Equivalence<A>): (self: Equivalence<A>) => Equivalence<A>
+  <A>(self: Equivalence<A>, that: Equivalence<A>): Equivalence<A>
+} = dual(2, <A>(self: Equivalence<A>, that: Equivalence<A>): Equivalence<A> => make((x, y) => self(x, y) && that(x, y)))
+
+/**
+ * @category combining
+ * @since 2.0.0
+ */
+export const combineMany: {
+  <A>(collection: Iterable<Equivalence<A>>): (self: Equivalence<A>) => Equivalence<A>
+  <A>(self: Equivalence<A>, collection: Iterable<Equivalence<A>>): Equivalence<A>
+} = dual(2, <A>(self: Equivalence<A>, collection: Iterable<Equivalence<A>>): Equivalence<A> =>
+  make((x, y) => {
+    if (!self(x, y)) {
+      return false
+    }
+    for (const equivalence of collection) {
+      if (!equivalence(x, y)) {
+        return false
+      }
+    }
+    return true
+  }))
+
+const isAlwaysEquivalent: Equivalence<unknown> = (_x, _y) => true
+
+/**
+ * @category combining
+ * @since 2.0.0
+ */
+export const combineAll = <A>(collection: Iterable<Equivalence<A>>): Equivalence<A> =>
+  combineMany(isAlwaysEquivalent, collection)
+
+/**
+ * @category combinators
+ * @since 2.0.0
+ */
+export const mapInput: {
+  <B, A>(f: (b: B) => A): (self: Equivalence<A>) => Equivalence<B>
+  <A, B>(self: Equivalence<A>, f: (b: B) => A): Equivalence<B>
+} = dual(
+  2,
+  <A, B>(self: Equivalence<A>, f: (b: B) => A): Equivalence<B> => make((x, y) => self(f(x), f(y)))
+)
+
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+export const Date: Equivalence<Date> = mapInput(number, (date) => date.getTime())
+
+/**
+ * @category combining
+ * @since 2.0.0
+ */
+export const product: {
+  <B>(that: Equivalence<B>): <A>(self: Equivalence<A>) => Equivalence<readonly [A, B]>
+  <A, B>(self: Equivalence<A>, that: Equivalence<B>): Equivalence<readonly [A, B]>
+} = dual(
+  2,
+  <A, B>(self: Equivalence<A>, that: Equivalence<B>): Equivalence<readonly [A, B]> =>
+    make(([xa, xb], [ya, yb]) => self(xa, ya) && that(xb, yb))
+)
+
+/**
+ * @category combining
+ * @since 2.0.0
+ */
+export const all = <A>(collection: Iterable<Equivalence<A>>): Equivalence<ReadonlyArray<A>> => {
+  return make((x, y) => {
+    const len = Math.min(x.length, y.length)
+
+    let collectionLength = 0
+    for (const equivalence of collection) {
+      if (collectionLength >= len) {
+        break
+      }
+      if (!equivalence(x[collectionLength], y[collectionLength])) {
+        return false
+      }
+      collectionLength++
+    }
+    return true
+  })
+}
+
+/**
+ * @category combining
+ * @since 2.0.0
+ */
+export const productMany = <A>(
+  self: Equivalence<A>,
+  collection: Iterable<Equivalence<A>>
+): Equivalence<readonly [A, ...Array<A>]> => {
+  const equivalence = all(collection)
+  return make((x, y) => !self(x[0], y[0]) ? false : equivalence(x.slice(1), y.slice(1)))
+}
+
+/**
+ * Similar to `Promise.all` but operates on `Equivalence`s.
+ *
+ * ```
+ * [Equivalence<A>, Equivalence<B>, ...] -> Equivalence<[A, B, ...]>
+ * ```
+ *
+ * Given a tuple of `Equivalence`s returns a new `Equivalence` that compares values of a tuple
+ * by applying each `Equivalence` to the corresponding element of the tuple.
+ *
+ * @category combinators
+ * @since 2.0.0
+ */
+export const tuple = <T extends ReadonlyArray<Equivalence<any>>>(
+  ...elements: T
+): Equivalence<Readonly<{ [I in keyof T]: [T[I]] extends [Equivalence<infer A>] ? A : never }>> => all(elements) as any
+
+/**
+ * Creates a new `Equivalence` for an array of values based on a given `Equivalence` for the elements of the array.
+ *
+ * @category combinators
+ * @since 2.0.0
+ */
+export const array = <A>(item: Equivalence<A>): Equivalence<ReadonlyArray<A>> =>
+  make((self, that) => {
+    if (self.length !== that.length) {
+      return false
+    }
+
+    for (let i = 0; i < self.length; i++) {
+      const isEq = item(self[i], that[i])
+      if (!isEq) {
+        return false
+      }
+    }
+
+    return true
+  })
+
+/**
+ * Given a struct of `Equivalence`s returns a new `Equivalence` that compares values of a struct
+ * by applying each `Equivalence` to the corresponding property of the struct.
+ *
+ * @category combinators
+ * @since 2.0.0
+ */
+export const struct = <R extends Record<string, Equivalence<any>>>(
+  fields: R
+): Equivalence<{ readonly [K in keyof R]: [R[K]] extends [Equivalence<infer A>] ? A : never }> => {
+  const keys = Object.keys(fields)
+  return make((self, that) => {
+    for (const key of keys) {
+      if (!fields[key](self[key], that[key])) {
+        return false
+      }
+    }
+    return true
+  })
+}

package/src/Error.ts

@@ -0,0 +1,69 @@
+/**
+ * @since 2.0.0
+ */
+import type * as Channel from "./Channel"
+import type * as Data from "./Data"
+import * as Effect from "./Effect"
+import * as Effectable from "./Effectable"
+import type * as Equal from "./Equal"
+import type * as Inspectable from "./Inspectable"
+import { type Pipeable } from "./Pipeable"
+import type * as Sink from "./Sink"
+import type * as Types from "./Types"
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface YieldableError extends Data.Case, Pipeable, Inspectable.Inspectable {
+  readonly [Effectable.EffectTypeId]: Effect.Effect.VarianceStruct<never, this, never>
+  readonly [Effectable.StreamTypeId]: Effect.Effect.VarianceStruct<never, this, never>
+  readonly [Effectable.SinkTypeId]: Sink.Sink.VarianceStruct<never, this, unknown, never, never>
+  readonly [Effectable.ChannelTypeId]: Channel.Channel.VarianceStruct<
+    never,
+    unknown,
+    unknown,
+    unknown,
+    this,
+    never,
+    never
+  >
+}
+
+const YieldableErrorProto = {
+  ...Effectable.StructuralCommitPrototype,
+  commit() {
+    return Effect.fail(this)
+  }
+}
+
+/**
+ * Provides a constructor for a Case Class.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const Class: new<A extends Record<string, any>>(
+  args: Types.Equals<Omit<A, keyof Equal.Equal>, {}> extends true ? void : Omit<A, keyof Equal.Equal>
+) => YieldableError & A = (function() {
+  function Base(this: any, args: any) {
+    if (args) {
+      Object.assign(this, args)
+    }
+  }
+  Base.prototype = YieldableErrorProto
+  return Base as any
+})()
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const TaggedClass = <Tag extends string>(tag: Tag): new<A extends Record<string, any>>(
+  args: Types.Equals<Omit<A, keyof Equal.Equal>, {}> extends true ? void : Omit<A, keyof Equal.Equal>
+) => YieldableError & { readonly _tag: Tag } & A => {
+  class Base extends Class<any> {
+    readonly _tag = tag
+  }
+  return Base as any
+}

package/src/ExecutionStrategy.ts

@@ -0,0 +1,111 @@
+/**
+ * @since 2.0.0
+ */
+import type { LazyArg } from "./Function"
+import * as internal from "./internal/executionStrategy"
+
+/**
+ * Describes a strategy for evaluating multiple effects, potentially in
+ * parallel.
+ *
+ * There are 3 possible execution strategies: `Sequential`, `Parallel`,
+ * `ParallelN`.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export type ExecutionStrategy = Sequential | Parallel | ParallelN
+
+/**
+ * Execute effects sequentially.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export interface Sequential {
+  readonly _tag: "Sequential"
+}
+
+/**
+ * Execute effects in parallel.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export interface Parallel {
+  readonly _tag: "Parallel"
+}
+
+/**
+ * Execute effects in parallel, up to the specified number of concurrent fibers.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export interface ParallelN {
+  readonly _tag: "ParallelN"
+  readonly parallelism: number
+}
+
+/**
+ * Execute effects sequentially.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const sequential: ExecutionStrategy = internal.sequential
+
+/**
+ * Execute effects in parallel.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const parallel: ExecutionStrategy = internal.parallel
+
+/**
+ * Execute effects in parallel, up to the specified number of concurrent fibers.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const parallelN: (parallelism: number) => ExecutionStrategy = internal.parallelN
+
+/**
+ * Returns `true` if the specified `ExecutionStrategy` is an instance of
+ * `Sequential`, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isSequential: (self: ExecutionStrategy) => self is Sequential = internal.isSequential
+
+/**
+ * Returns `true` if the specified `ExecutionStrategy` is an instance of
+ * `Sequential`, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isParallel: (self: ExecutionStrategy) => self is Parallel = internal.isParallel
+
+/**
+ * Returns `true` if the specified `ExecutionStrategy` is an instance of
+ * `Sequential`, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isParallelN: (self: ExecutionStrategy) => self is ParallelN = internal.isParallelN
+
+/**
+ * Folds over the specified `ExecutionStrategy` using the provided case
+ * functions.
+ *
+ * @since 2.0.0
+ * @category folding
+ */
+export const match: {
+  <A>(onSequential: LazyArg<A>, onParallel: LazyArg<A>, onParallelN: (n: number) => A): (self: ExecutionStrategy) => A
+  <A>(self: ExecutionStrategy, onSequential: LazyArg<A>, onParallel: LazyArg<A>, onParallelN: (n: number) => A): A
+} = internal.match