effect 2.0.0-next.44 → 2.0.0-next.46

package/src/HashSet.ts

@@ -0,0 +1,300 @@
+/**
+ * @since 2.0.0
+ */
+
+import type { Equal } from "./Equal"
+import type { Inspectable } from "./Inspectable"
+import * as HS from "./internal/HashSet"
+import type { Pipeable } from "./Pipeable"
+import type { Predicate, Refinement } from "./Predicate"
+
+const TypeId: unique symbol = HS.HashSetTypeId as TypeId
+
+/**
+ * @since 2.0.0
+ * @category symbol
+ */
+export type TypeId = typeof TypeId
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface HashSet<A> extends Iterable<A>, Equal, Pipeable, Inspectable {
+  readonly [TypeId]: TypeId
+}
+
+/**
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isHashSet: {
+  <A>(u: Iterable<A>): u is HashSet<A>
+  (u: unknown): u is HashSet<unknown>
+} = HS.isHashSet
+
+/**
+ * Creates an empty `HashSet`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const empty: <A = never>() => HashSet<A> = HS.empty
+
+/**
+ * Construct a new `HashSet` from a `Collection` of values
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const fromIterable: <A>(elements: Iterable<A>) => HashSet<A> = HS.fromIterable
+
+/**
+ * Construct a new `HashSet` from a variable number of values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const make: <As extends ReadonlyArray<any>>(...elements: As) => HashSet<As[number]> = HS.make
+
+/**
+ * Checks if the specified value exists in the `HashSet`.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+export const has: {
+  <A>(value: A): (self: HashSet<A>) => boolean
+  <A>(self: HashSet<A>, value: A): boolean
+} = HS.has
+
+/**
+ * Check if a predicate holds true for some `HashSet` element.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+export const some: {
+  <A>(f: Predicate<A>): (self: HashSet<A>) => boolean
+  <A>(self: HashSet<A>, f: Predicate<A>): boolean
+} = HS.some
+
+/**
+ * Check if a predicate holds true for every `HashSet` element.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+export const every: {
+  <A, B extends A>(refinement: Refinement<A, B>): (self: HashSet<A>) => self is HashSet<B>
+  <A>(predicate: Predicate<A>): (self: HashSet<A>) => boolean
+  <A, B extends A>(self: HashSet<A>, refinement: Refinement<A, B>): self is HashSet<B>
+  <A>(self: HashSet<A>, predicate: Predicate<A>): boolean
+} = HS.every
+
+/**
+ * Returns `true` if and only if every element in the this `HashSet` is an
+ * element of the second set,
+ *
+ * **NOTE**: the hash and equal of both sets must be the same.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+export const isSubset: {
+  <A>(that: HashSet<A>): (self: HashSet<A>) => boolean
+  <A>(self: HashSet<A>, that: HashSet<A>): boolean
+} = HS.isSubset
+
+/**
+ * Returns an `IterableIterator` of the values in the `HashSet`.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const values: <A>(self: HashSet<A>) => IterableIterator<A> = HS.values
+
+/**
+ * Calculates the number of values in the `HashSet`.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const size: <A>(self: HashSet<A>) => number = HS.size
+
+/**
+ * Marks the `HashSet` as mutable.
+ *
+ * @since 2.0.0
+ */
+export const beginMutation: <A>(self: HashSet<A>) => HashSet<A> = HS.beginMutation
+
+/**
+ * Marks the `HashSet` as immutable.
+ *
+ * @since 2.0.0
+ */
+export const endMutation: <A>(self: HashSet<A>) => HashSet<A> = HS.endMutation
+
+/**
+ * Mutates the `HashSet` within the context of the provided function.
+ *
+ * @since 2.0.0
+ */
+export const mutate: {
+  <A>(f: (set: HashSet<A>) => void): (self: HashSet<A>) => HashSet<A>
+  <A>(self: HashSet<A>, f: (set: HashSet<A>) => void): HashSet<A>
+} = HS.mutate
+
+/**
+ * Adds a value to the `HashSet`.
+ *
+ * @since 2.0.0
+ */
+export const add: {
+  <A>(value: A): (self: HashSet<A>) => HashSet<A>
+  <A>(self: HashSet<A>, value: A): HashSet<A>
+} = HS.add
+
+/**
+ * Removes a value from the `HashSet`.
+ *
+ * @since 2.0.0
+ */
+export const remove: {
+  <A>(value: A): (self: HashSet<A>) => HashSet<A>
+  <A>(self: HashSet<A>, value: A): HashSet<A>
+} = HS.remove
+
+/**
+ * Computes the set difference between this `HashSet` and the specified
+ * `Iterable<A>`.
+ *
+ * **NOTE**: the hash and equal of the values in both the set and the iterable
+ * must be the same.
+ *
+ * @since 2.0.0
+ */
+export const difference: {
+  <A>(that: Iterable<A>): (self: HashSet<A>) => HashSet<A>
+  <A>(self: HashSet<A>, that: Iterable<A>): HashSet<A>
+} = HS.difference
+
+/**
+ * Returns a `HashSet` of values which are present in both this set and that
+ * `Iterable<A>`.
+ *
+ * **NOTE**: the hash and equal of the values in both the set and the iterable
+ * must be the same.
+ *
+ * @since 2.0.0
+ */
+export const intersection: {
+  <A>(that: Iterable<A>): (self: HashSet<A>) => HashSet<A>
+  <A>(self: HashSet<A>, that: Iterable<A>): HashSet<A>
+} = HS.intersection
+
+/**
+ * Computes the set union `(`self` + `that`)` between this `HashSet` and the
+ * specified `Iterable<A>`.
+ *
+ * **NOTE**: the hash and equal of the values in both the set and the iterable
+ * must be the same.
+ *
+ * @since 2.0.0
+ */
+export const union: {
+  <A>(that: Iterable<A>): (self: HashSet<A>) => HashSet<A>
+  <A>(self: HashSet<A>, that: Iterable<A>): HashSet<A>
+} = HS.union
+
+/**
+ * Checks if a value is present in the `HashSet`. If it is present, the value
+ * will be removed from the `HashSet`, otherwise the value will be added to the
+ * `HashSet`.
+ *
+ * @since 2.0.0
+ */
+export const toggle: {
+  <A>(value: A): (self: HashSet<A>) => HashSet<A>
+  <A>(self: HashSet<A>, value: A): HashSet<A>
+} = HS.toggle
+
+/**
+ * Maps over the values of the `HashSet` using the specified function.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+export const map: {
+  <A, B>(f: (a: A) => B): (self: HashSet<A>) => HashSet<B>
+  <A, B>(self: HashSet<A>, f: (a: A) => B): HashSet<B>
+} = HS.map
+
+/**
+ * Chains over the values of the `HashSet` using the specified function.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+export const flatMap: {
+  <A, B>(f: (a: A) => Iterable<B>): (self: HashSet<A>) => HashSet<B>
+  <A, B>(self: HashSet<A>, f: (a: A) => Iterable<B>): HashSet<B>
+} = HS.flatMap
+
+/**
+ * Applies the specified function to the values of the `HashSet`.
+ *
+ * @since 2.0.0
+ * @category traversing
+ */
+export const forEach: {
+  <A>(f: (value: A) => void): (self: HashSet<A>) => void
+  <A>(self: HashSet<A>, f: (value: A) => void): void
+} = HS.forEach
+
+/**
+ * Reduces the specified state over the values of the `HashSet`.
+ *
+ * @since 2.0.0
+ * @category folding
+ */
+export const reduce: {
+  <A, Z>(zero: Z, f: (accumulator: Z, value: A) => Z): (self: HashSet<A>) => Z
+  <A, Z>(self: HashSet<A>, zero: Z, f: (accumulator: Z, value: A) => Z): Z
+} = HS.reduce
+
+/**
+ * Filters values out of a `HashSet` using the specified predicate.
+ *
+ * @since 2.0.0
+ * @category filtering
+ */
+export const filter: {
+  <A, B extends A>(f: Refinement<A, B>): (self: HashSet<A>) => HashSet<B>
+  <A>(f: Predicate<A>): (self: HashSet<A>) => HashSet<A>
+  <A, B extends A>(self: HashSet<A>, f: Refinement<A, B>): HashSet<B>
+  <A>(self: HashSet<A>, f: Predicate<A>): HashSet<A>
+} = HS.filter
+
+/**
+ * Partition the values of a `HashSet` using the specified predicate.
+ *
+ * If a value matches the predicate, it will be placed into the `HashSet` on the
+ * right side of the resulting `Tuple`, otherwise the value will be placed into
+ * the left side.
+ *
+ * @since 2.0.0
+ * @category partitioning
+ */
+export const partition: {
+  <C extends A, B extends A, A = C>(
+    refinement: Refinement<A, B>
+  ): (self: HashSet<C>) => [HashSet<Exclude<C, B>>, HashSet<B>]
+  <B extends A, A = B>(predicate: (a: A) => boolean): (self: HashSet<B>) => [HashSet<B>, HashSet<B>]
+  <C extends A, B extends A, A = C>(
+    self: HashSet<C>,
+    refinement: Refinement<A, B>
+  ): [HashSet<Exclude<C, B>>, HashSet<B>]
+  <B extends A, A = B>(self: HashSet<B>, predicate: (a: A) => boolean): [HashSet<B>, HashSet<B>]
+} = HS.partition

package/src/Inspectable.ts

@@ -0,0 +1,45 @@
+/**
+ * @since 2.0.0
+ */
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const NodeInspectSymbol = Symbol.for("nodejs.util.inspect.custom")
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type NodeInspectSymbol = typeof NodeInspectSymbol
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface Inspectable {
+  readonly toString: () => string
+  readonly toJSON: () => unknown
+  readonly [NodeInspectSymbol]: () => unknown
+}
+
+/**
+ * @since 2.0.0
+ */
+export const toJSON = (x: unknown): unknown => {
+  if (
+    typeof x === "object" && x !== null && "toJSON" in x && typeof x["toJSON"] === "function" &&
+    x["toJSON"].length === 0
+  ) {
+    return x.toJSON()
+  } else if (Array.isArray(x)) {
+    return x.map(toJSON)
+  }
+  return x
+}
+
+/**
+ * @since 2.0.0
+ */
+export const toString = (x: unknown): string => JSON.stringify(x, null, 2)

package/src/KeyedPool.ts

@@ -0,0 +1,160 @@
+/**
+ * @since 2.0.0
+ */
+import type * as Duration from "./Duration"
+import type * as Effect from "./Effect"
+import * as internal from "./internal/keyedPool"
+import type { Pipeable } from "./Pipeable"
+import type * as Scope from "./Scope"
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const KeyedPoolTypeId: unique symbol = internal.KeyedPoolTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type KeyedPoolTypeId = typeof KeyedPoolTypeId
+
+/**
+ * A `KeyedPool<K, E, A>` is a pool of `Pool`s of items of type `A`. Each pool
+ * in the `KeyedPool` is associated with a key of type `K`.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export interface KeyedPool<K, E, A> extends KeyedPool.Variance<K, E, A>, Pipeable {
+  /**
+   * Retrieves an item from the pool belonging to the given key in a scoped
+   * effect. Note that if acquisition fails, then the returned effect will fail
+   * for that same reason. Retrying a failed acquisition attempt will repeat the
+   * acquisition attempt.
+   */
+  get(key: K): Effect.Effect<Scope.Scope, E, A>
+
+  /**
+   * Invalidates the specified item. This will cause the pool to eventually
+   * reallocate the item, although this reallocation may occur lazily rather
+   * than eagerly.
+   */
+  invalidate(item: A): Effect.Effect<never, never, void>
+}
+
+/**
+ * @since 2.0.0
+ */
+export declare namespace KeyedPool {
+  /**
+   * @since 2.0.0
+   * @category models
+   */
+  export interface Variance<K, E, A> {
+    readonly [KeyedPoolTypeId]: {
+      readonly _K: (_: K) => void
+      readonly _E: (_: never) => E
+      readonly _A: (_: never) => A
+    }
+  }
+}
+
+/**
+ * Makes a new pool of the specified fixed size. The pool is returned in a
+ * `Scope`, which governs the lifetime of the pool. When the pool is shutdown
+ * because the `Scope` is closed, the individual items allocated by the pool
+ * will be released in some unspecified order.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const make: <K, R, E, A>(
+  options: { readonly acquire: (key: K) => Effect.Effect<R, E, A>; readonly size: number }
+) => Effect.Effect<Scope.Scope | R, never, KeyedPool<K, E, A>> = internal.make
+
+/**
+ * Makes a new pool of the specified fixed size. The pool is returned in a
+ * `Scope`, which governs the lifetime of the pool. When the pool is shutdown
+ * because the `Scope` is closed, the individual items allocated by the pool
+ * will be released in some unspecified order.
+ *
+ * The size of the underlying pools can be configured per key.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const makeWith: <K, R, E, A>(
+  options: { readonly acquire: (key: K) => Effect.Effect<R, E, A>; readonly size: (key: K) => number }
+) => Effect.Effect<Scope.Scope | R, never, KeyedPool<K, E, A>> = internal.makeWith
+
+/**
+ * Makes a new pool with the specified minimum and maximum sizes and time to
+ * live before a pool whose excess items are not being used will be shrunk
+ * down to the minimum size. The pool is returned in a `Scope`, which governs
+ * the lifetime of the pool. When the pool is shutdown because the `Scope` is
+ * used, the individual items allocated by the pool will be released in some
+ * unspecified order.
+ *
+ * The size of the underlying pools can be configured per key.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const makeWithTTL: <K, R, E, A>(
+  options: {
+    readonly acquire: (key: K) => Effect.Effect<R, E, A>
+    readonly min: (key: K) => number
+    readonly max: (key: K) => number
+    readonly timeToLive: Duration.DurationInput
+  }
+) => Effect.Effect<Scope.Scope | R, never, KeyedPool<K, E, A>> = internal.makeWithTTL
+
+/**
+ * Makes a new pool with the specified minimum and maximum sizes and time to
+ * live before a pool whose excess items are not being used will be shrunk
+ * down to the minimum size. The pool is returned in a `Scope`, which governs
+ * the lifetime of the pool. When the pool is shutdown because the `Scope` is
+ * used, the individual items allocated by the pool will be released in some
+ * unspecified order.
+ *
+ * The size of the underlying pools can be configured per key.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const makeWithTTLBy: <K, R, E, A>(
+  options: {
+    readonly acquire: (key: K) => Effect.Effect<R, E, A>
+    readonly min: (key: K) => number
+    readonly max: (key: K) => number
+    readonly timeToLive: (key: K) => Duration.DurationInput
+  }
+) => Effect.Effect<Scope.Scope | R, never, KeyedPool<K, E, A>> = internal.makeWithTTLBy
+
+/**
+ * Retrieves an item from the pool belonging to the given key in a scoped
+ * effect. Note that if acquisition fails, then the returned effect will fail
+ * for that same reason. Retrying a failed acquisition attempt will repeat the
+ * acquisition attempt.
+ *
+ * @since 2.0.0
+ * @category combinators
+ */
+export const get: {
+  <K>(key: K): <E, A>(self: KeyedPool<K, E, A>) => Effect.Effect<Scope.Scope, E, A>
+  <K, E, A>(self: KeyedPool<K, E, A>, key: K): Effect.Effect<Scope.Scope, E, A>
+} = internal.get
+
+/**
+ * Invalidates the specified item. This will cause the pool to eventually
+ * reallocate the item, although this reallocation may occur lazily rather
+ * than eagerly.
+ *
+ * @since 2.0.0
+ * @category combinators
+ */
+export const invalidate: {
+  <A>(item: A): <K, E>(self: KeyedPool<K, E, A>) => Effect.Effect<never, never, void>
+  <K, E, A>(self: KeyedPool<K, E, A>, item: A): Effect.Effect<never, never, void>
+} = internal.invalidate