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

package/src/Brand.ts

@@ -0,0 +1,336 @@
+/**
+ * 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 Either from "./Either"
+import { identity } from "./Function"
+import * as Option from "./Option"
+import type { Predicate, Refinement } from "./Predicate"
+import * as ReadonlyArray from "./ReadonlyArray"
+import type * as Types from "./Types"
+
+/**
+ * @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 ReadonlyArray<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<Brand.BrandErrors, A>
+    /**
+     * Attempts to refine the provided value of type `A`, returning `true` if
+     * the provided `A` is valid, `false` otherwise.
+     */
+    is: Refinement<Brand.Unbranded<A>, 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: 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 => ReadonlyArray.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}.
+ *
+ * @param refinement - The refinement predicate to apply to the unbranded value.
+ * @param onFailure - Takes the unbranded value that did not pass the `refinement` predicate and returns a `BrandErrors`.
+ *
+ * @example
+ * import * as Brand from "effect/Brand"
+ *
+ * type Int = number & Brand.Brand<"Int">
+ *
+ * const Int = Brand.refined<Int>(
+ *   (n) => Number.isInteger(n),
+ *   (n) => Brand.error(`Expected ${n} to be an integer`)
+ * )
+ *
+ * assert.strictEqual(Int(1), 1)
+ * assert.throws(() => Int(1.1))
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const refined: <A extends Brand<any>>(
+  refinement: Predicate<Brand.Unbranded<A>>,
+  onFailure: (a: Brand.Unbranded<A>) => Brand.BrandErrors
+) => Brand.Constructor<A> = <A extends Brand<any>>(
+  refinement: Predicate<Brand.Unbranded<A>>,
+  onFailure: (a: Brand.Unbranded<A>) => Brand.BrandErrors
+): Brand.Constructor<A> => {
+  const either = (args: Brand.Unbranded<A>): Either.Either<Brand.BrandErrors, A> =>
+    refinement(args) ? Either.right(args as A) : Either.left(onFailure(args))
+  // @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 Brand.Unbranded<A> & A => Either.isRight(either(args))
+  })
+}
+
+/**
+ * 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
+ * import * as Brand from "effect/Brand"
+ *
+ * type UserId = number & Brand.Brand<"UserId">
+ *
+ * const UserId = Brand.nominal<UserId>()
+ *
+ * assert.strictEqual(UserId(1), 1)
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const nominal: <A extends Brand<any>>() => Brand.Constructor<A> = <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
+ * import * as Brand from "effect/Brand"
+ *
+ * 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)
+ *
+ * assert.strictEqual(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<Brand.BrandErrors, any> => {
+    let result: Either.Either<Brand.BrandErrors, any> = 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))
+  })
+}

package/src/Cache.ts

@@ -0,0 +1,250 @@
+/**
+ * @since 2.0.0
+ */
+import type * as Duration from "./Duration"
+import type * as Effect from "./Effect"
+import type { Either } from "./Either"
+import type * as Exit from "./Exit"
+import * as internal from "./internal/cache"
+import type * as Option from "./Option"
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const CacheTypeId: unique symbol = internal.CacheTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type CacheTypeId = typeof CacheTypeId
+
+/**
+ * A `Cache` is defined in terms of a lookup function that, given a key of
+ * type `Key`, can either fail with an error of type `Error` or succeed with a
+ * value of type `Value`. Getting a value from the cache will either return
+ * the previous result of the lookup function if it is available or else
+ * compute a new result with the lookup function, put it in the cache, and
+ * return it.
+ *
+ * A cache also has a specified capacity and time to live. When the cache is
+ * at capacity the least recently accessed values in the cache will be
+ * removed to make room for new values. Getting a value with a life older than
+ * the specified time to live will result in a new value being computed with
+ * the lookup function and returned when available.
+ *
+ * The cache is safe for concurrent access. If multiple fibers attempt to get
+ * the same key the lookup function will only be computed once and the result
+ * will be returned to all fibers.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export interface Cache<Key, Error, Value> extends ConsumerCache<Key, Error, Value> {
+  /**
+   * Retrieves the value associated with the specified key if it exists.
+   * Otherwise computes the value with the lookup function, puts it in the
+   * cache, and returns it.
+   */
+  get(key: Key): Effect.Effect<never, Error, Value>
+
+  /**
+   * Retrieves the value associated with the specified key if it exists as a left.
+   * Otherwise computes the value with the lookup function, puts it in the
+   * cache, and returns it as a right.
+   */
+  getEither(key: Key): Effect.Effect<never, Error, Either<Value, Value>>
+
+  /**
+   * Computes the value associated with the specified key, with the lookup
+   * function, and puts it in the cache. The difference between this and
+   * `get` method is that `refresh` triggers (re)computation of the value
+   * without invalidating it in the cache, so any request to the associated
+   * key can still be served while the value is being re-computed/retrieved
+   * by the lookup function. Additionally, `refresh` always triggers the
+   * lookup function, disregarding the last `Error`.
+   */
+  refresh(key: Key): Effect.Effect<never, Error, void>
+
+  /**
+   * Associates the specified value with the specified key in the cache.
+   */
+  set<Key, Error, Value>(this: Cache<Key, Error, Value>, key: Key, value: Value): Effect.Effect<never, never, void>
+}
+
+/**
+ * A ConsumerCache models a portion of a cache which is safe to share without allowing to create new values or access existing ones.
+ *
+ * It can be used safely to give over control for request management without leaking writer side details.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export interface ConsumerCache<Key, Error, Value> extends Cache.Variance<Key, Error, Value> {
+  /**
+   * Retrieves the value associated with the specified key if it exists.
+   * Otherwise returns `Option.none`.
+   */
+  getOption(key: Key): Effect.Effect<never, Error, Option.Option<Value>>
+
+  /**
+   * Retrieves the value associated with the specified key if it exists and the
+   * lookup function has completed. Otherwise returns `Option.none`.
+   */
+  getOptionComplete(key: Key): Effect.Effect<never, never, Option.Option<Value>>
+
+  /**
+   * Returns statistics for this cache.
+   */
+  cacheStats(): Effect.Effect<never, never, CacheStats>
+
+  /**
+   * Returns whether a value associated with the specified key exists in the
+   * cache.
+   */
+  contains(key: Key): Effect.Effect<never, never, boolean>
+
+  /**
+   * Returns statistics for the specified entry.
+   */
+  entryStats(key: Key): Effect.Effect<never, never, Option.Option<EntryStats>>
+
+  /**
+   * Invalidates the value associated with the specified key.
+   */
+  invalidate(key: Key): Effect.Effect<never, never, void>
+
+  /**
+   * Invalidates the value associated with the specified key if the predicate holds.
+   */
+  invalidateWhen(key: Key, when: (value: Value) => boolean): Effect.Effect<never, never, void>
+
+  /**
+   * Invalidates all values in the cache.
+   */
+  invalidateAll(): Effect.Effect<never, never, void>
+
+  /**
+   * Returns the approximate number of values in the cache.
+   */
+  size(): Effect.Effect<never, never, number>
+
+  /**
+   * Returns an approximation of the values in the cache.
+   */
+  keys<Key, Error, Value>(this: ConsumerCache<Key, Error, Value>): Effect.Effect<never, never, Array<Key>>
+
+  /**
+   * Returns an approximation of the values in the cache.
+   */
+  values(): Effect.Effect<never, never, Array<Value>>
+
+  /**
+   * Returns an approximation of the values in the cache.
+   */
+  entries<Key, Error, Value>(this: ConsumerCache<Key, Error, Value>): Effect.Effect<never, never, Array<[Key, Value]>>
+}
+
+/**
+ * @since 2.0.0
+ */
+export declare namespace Cache {
+  /**
+   * @since 2.0.0
+   * @category models
+   */
+  export interface Variance<Key, Error, Value> {
+    readonly [CacheTypeId]: {
+      readonly _Key: (_: Key) => void
+      readonly _Error: (_: never) => Error
+      readonly _Value: (_: never) => Value
+    }
+  }
+}
+
+/**
+ * Constructs a new cache with the specified capacity, time to live, and
+ * lookup function.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const make: <Key, Environment, Error, Value>(
+  options: {
+    readonly capacity: number
+    readonly timeToLive: Duration.DurationInput
+    readonly lookup: Lookup<Key, Environment, Error, Value>
+  }
+) => Effect.Effect<Environment, never, Cache<Key, Error, Value>> = internal.make
+
+/**
+ * Constructs a new cache with the specified capacity, time to live, and
+ * lookup function, where the time to live can depend on the `Exit` value
+ * returned by the lookup function.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const makeWith: <Key, Environment, Error, Value>(
+  options: {
+    readonly capacity: number
+    readonly lookup: Lookup<Key, Environment, Error, Value>
+    readonly timeToLive: (exit: Exit.Exit<Error, Value>) => Duration.DurationInput
+  }
+) => Effect.Effect<Environment, never, Cache<Key, Error, Value>> = internal.makeWith
+
+/**
+ * `CacheStats` represents a snapshot of statistics for the cache as of a
+ * point in time.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export interface CacheStats {
+  readonly hits: number
+  readonly misses: number
+  readonly size: number
+}
+
+/**
+ * Constructs a new `CacheStats` from the specified values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const makeCacheStats: (
+  options: {
+    readonly hits: number
+    readonly misses: number
+    readonly size: number
+  }
+) => CacheStats = internal.makeCacheStats
+
+/**
+ * Represents a snapshot of statistics for an entry in the cache.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export interface EntryStats {
+  readonly loadedMillis: number
+}
+
+/**
+ * Constructs a new `EntryStats` from the specified values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const makeEntryStats: (loadedMillis: number) => EntryStats = internal.makeEntryStats
+
+/**
+ * A `Lookup` represents a lookup function that, given a key of type `Key`, can
+ * return an effect that will either produce a value of type `Value` or fail
+ * with an error of type `Error` using an environment of type `Environment`.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export type Lookup<Key, Environment, Error, Value> = (key: Key) => Effect.Effect<Environment, Error, Value>