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

package/src/TSet.ts

@@ -0,0 +1,349 @@
+/**
+ * @since 2.0.0
+ */
+import type * as HashSet from "./HashSet"
+import * as internal from "./internal/stm/tSet"
+import type * as Option from "./Option"
+import type { Predicate } from "./Predicate"
+import type * as STM from "./STM"
+import type * as TMap from "./TMap"
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const TSetTypeId: unique symbol = internal.TSetTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type TSetTypeId = typeof TSetTypeId
+
+/**
+ * Transactional set implemented on top of `TMap`.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export interface TSet<A> extends TSet.Variance<A> {}
+/**
+ * @internal
+ * @since 2.0.0
+ */
+export interface TSet<A> {
+  /** @internal */
+  readonly tMap: TMap.TMap<A, void>
+}
+
+/**
+ * @since 2.0.0
+ */
+export declare namespace TSet {
+  /**
+   * @since 2.0.0
+   * @category models
+   */
+  export interface Variance<A> {
+    readonly [TSetTypeId]: {
+      readonly _A: (_: never) => A
+    }
+  }
+}
+
+/**
+ * Stores new element in the set.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const add: {
+  <A>(value: A): (self: TSet<A>) => STM.STM<never, never, void>
+  <A>(self: TSet<A>, value: A): STM.STM<never, never, void>
+} = internal.add
+
+/**
+ * Atomically transforms the set into the difference of itself and the
+ * provided set.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const difference: {
+  <A>(other: TSet<A>): (self: TSet<A>) => STM.STM<never, never, void>
+  <A>(self: TSet<A>, other: TSet<A>): STM.STM<never, never, void>
+} = internal.difference
+
+/**
+ * Makes an empty `TSet`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const empty: <A>() => STM.STM<never, never, TSet<A>> = internal.empty
+
+/**
+ * Atomically performs transactional-effect for each element in set.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+export const forEach: {
+  <A, R, E>(f: (value: A) => STM.STM<R, E, void>): (self: TSet<A>) => STM.STM<R, E, void>
+  <A, R, E>(self: TSet<A>, f: (value: A) => STM.STM<R, E, void>): STM.STM<R, E, void>
+} = internal.forEach
+
+/**
+ * Makes a new `TSet` initialized with provided iterable.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const fromIterable: <A>(iterable: Iterable<A>) => STM.STM<never, never, TSet<A>> = internal.fromIterable
+
+/**
+ * Tests whether or not set contains an element.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+export const has: {
+  <A>(value: A): (self: TSet<A>) => STM.STM<never, never, boolean>
+  <A>(self: TSet<A>, value: A): STM.STM<never, never, boolean>
+} = internal.has
+
+/**
+ * Atomically transforms the set into the intersection of itself and the
+ * provided set.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const intersection: {
+  <A>(other: TSet<A>): (self: TSet<A>) => STM.STM<never, never, void>
+  <A>(self: TSet<A>, other: TSet<A>): STM.STM<never, never, void>
+} = internal.intersection
+
+/**
+ * Tests if the set is empty or not
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const isEmpty: <A>(self: TSet<A>) => STM.STM<never, never, boolean> = internal.isEmpty
+
+/**
+ * Makes a new `TSet` that is initialized with specified values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const make: <Elements extends Array<any>>(
+  ...elements: Elements
+) => STM.STM<never, never, TSet<Elements[number]>> = internal.make
+
+/**
+ * Atomically folds using a pure function.
+ *
+ * @since 2.0.0
+ * @category folding
+ */
+export const reduce: {
+  <Z, A>(zero: Z, f: (accumulator: Z, value: A) => Z): (self: TSet<A>) => STM.STM<never, never, Z>
+  <Z, A>(self: TSet<A>, zero: Z, f: (accumulator: Z, value: A) => Z): STM.STM<never, never, Z>
+} = internal.reduce
+
+/**
+ * Atomically folds using a transactional function.
+ *
+ * @since 2.0.0
+ * @category folding
+ */
+export const reduceSTM: {
+  <Z, A, R, E>(zero: Z, f: (accumulator: Z, value: A) => STM.STM<R, E, Z>): (self: TSet<A>) => STM.STM<R, E, Z>
+  <Z, A, R, E>(self: TSet<A>, zero: Z, f: (accumulator: Z, value: A) => STM.STM<R, E, Z>): STM.STM<R, E, Z>
+} = internal.reduceSTM
+
+/**
+ * Removes a single element from the set.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const remove: {
+  <A>(value: A): (self: TSet<A>) => STM.STM<never, never, void>
+  <A>(self: TSet<A>, value: A): STM.STM<never, never, void>
+} = internal.remove
+
+/**
+ * Removes elements from the set.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const removeAll: {
+  <A>(iterable: Iterable<A>): (self: TSet<A>) => STM.STM<never, never, void>
+  <A>(self: TSet<A>, iterable: Iterable<A>): STM.STM<never, never, void>
+} = internal.removeAll
+
+/**
+ * Removes bindings matching predicate and returns the removed entries.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const removeIf: {
+  <A>(predicate: Predicate<A>): (self: TSet<A>) => STM.STM<never, never, Array<A>>
+  <A>(self: TSet<A>, predicate: Predicate<A>): STM.STM<never, never, Array<A>>
+} = internal.removeIf
+
+/**
+ * Removes elements matching predicate.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const removeIfDiscard: {
+  <A>(predicate: Predicate<A>): (self: TSet<A>) => STM.STM<never, never, void>
+  <A>(self: TSet<A>, predicate: Predicate<A>): STM.STM<never, never, void>
+} = internal.removeIfDiscard
+
+/**
+ * Retains bindings matching predicate and returns removed bindings.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const retainIf: {
+  <A>(predicate: Predicate<A>): (self: TSet<A>) => STM.STM<never, never, Array<A>>
+  <A>(self: TSet<A>, predicate: Predicate<A>): STM.STM<never, never, Array<A>>
+} = internal.retainIf
+
+/**
+ * Retains elements matching predicate.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const retainIfDiscard: {
+  <A>(predicate: Predicate<A>): (self: TSet<A>) => STM.STM<never, never, void>
+  <A>(self: TSet<A>, predicate: Predicate<A>): STM.STM<never, never, void>
+} = internal.retainIfDiscard
+
+/**
+ * Returns the set's cardinality.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const size: <A>(self: TSet<A>) => STM.STM<never, never, number> = internal.size
+
+/**
+ * Takes the first matching value, or retries until there is one.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const takeFirst: {
+  <A, B>(pf: (a: A) => Option.Option<B>): (self: TSet<A>) => STM.STM<never, never, B>
+  <A, B>(self: TSet<A>, pf: (a: A) => Option.Option<B>): STM.STM<never, never, B>
+} = internal.takeFirst
+
+/**
+ * Takes the first matching value, or retries until there is one.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const takeFirstSTM: {
+  <A, R, E, B>(pf: (a: A) => STM.STM<R, Option.Option<E>, B>): (self: TSet<A>) => STM.STM<R, E, B>
+  <A, R, E, B>(self: TSet<A>, pf: (a: A) => STM.STM<R, Option.Option<E>, B>): STM.STM<R, E, B>
+} = internal.takeFirstSTM
+
+/**
+ * Takes all matching values, or retries until there is at least one.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const takeSome: {
+  <A, B>(pf: (a: A) => Option.Option<B>): (self: TSet<A>) => STM.STM<never, never, [B, ...Array<B>]>
+  <A, B>(self: TSet<A>, pf: (a: A) => Option.Option<B>): STM.STM<never, never, [B, ...Array<B>]>
+} = internal.takeSome
+
+/**
+ * Takes all matching values, or retries until there is at least one.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const takeSomeSTM: {
+  <A, R, E, B>(pf: (a: A) => STM.STM<R, Option.Option<E>, B>): (self: TSet<A>) => STM.STM<R, E, [B, ...Array<B>]>
+  <A, R, E, B>(self: TSet<A>, pf: (a: A) => STM.STM<R, Option.Option<E>, B>): STM.STM<R, E, [B, ...Array<B>]>
+} = internal.takeSomeSTM
+
+/**
+ * Collects all elements into a `Chunk`.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+export const toChunk: <A>(self: TSet<A>) => STM.STM<never, never, Array<A>> = internal.toChunk
+
+/**
+ * Collects all elements into a `HashSet`.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+export const toHashSet: <A>(self: TSet<A>) => STM.STM<never, never, HashSet.HashSet<A>> = internal.toHashSet
+
+/**
+ * Collects all elements into a `ReadonlyArray`.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+export const toReadonlyArray: <A>(self: TSet<A>) => STM.STM<never, never, ReadonlyArray<A>> = internal.toReadonlyArray
+
+/**
+ * Collects all elements into a `ReadonlySet`.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+export const toReadonlySet: <A>(self: TSet<A>) => STM.STM<never, never, ReadonlySet<A>> = internal.toReadonlySet
+
+/**
+ * Atomically updates all elements using a pure function.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const transform: {
+  <A>(f: (a: A) => A): (self: TSet<A>) => STM.STM<never, never, void>
+  <A>(self: TSet<A>, f: (a: A) => A): STM.STM<never, never, void>
+} = internal.transform
+
+/**
+ * Atomically updates all elements using a transactional function.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const transformSTM: {
+  <A, R, E>(f: (a: A) => STM.STM<R, E, A>): (self: TSet<A>) => STM.STM<R, E, void>
+  <A, R, E>(self: TSet<A>, f: (a: A) => STM.STM<R, E, A>): STM.STM<R, E, void>
+} = internal.transformSTM
+
+/**
+ * Atomically transforms the set into the union of itself and the provided
+ * set.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const union: {
+  <A>(other: TSet<A>): (self: TSet<A>) => STM.STM<never, never, void>
+  <A>(self: TSet<A>, other: TSet<A>): STM.STM<never, never, void>
+} = internal.union

package/src/Take.ts

@@ -0,0 +1,257 @@
+/**
+ * @since 2.0.0
+ */
+import type * as Cause from "./Cause"
+import type * as Chunk from "./Chunk"
+import type * as Effect from "./Effect"
+import type * as Exit from "./Exit"
+import * as internal from "./internal/take"
+import type * as Option from "./Option"
+import type { Pipeable } from "./Pipeable"
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const TakeTypeId: unique symbol = internal.TakeTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type TakeTypeId = typeof TakeTypeId
+
+/**
+ * A `Take<E, A>` represents a single `take` from a queue modeling a stream of
+ * values. A `Take` may be a failure cause `Cause<E>`, a chunk value `Chunk<A>`,
+ * or an end-of-stream marker.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export interface Take<E, A> extends Take.Variance<E, A>, Pipeable {
+  /** @internal */
+  readonly exit: Exit.Exit<Option.Option<E>, Chunk.Chunk<A>>
+}
+
+/**
+ * @since 2.0.0
+ */
+export declare namespace Take {
+  /**
+   * @since 2.0.0
+   * @category models
+   */
+  export interface Variance<E, A> {
+    readonly [TakeTypeId]: {
+      readonly _E: (_: never) => E
+      readonly _A: (_: never) => A
+    }
+  }
+}
+
+/**
+ * Creates a `Take` with the specified chunk.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const chunk: <A>(chunk: Chunk.Chunk<A>) => Take<never, A> = internal.chunk
+
+/**
+ * Creates a failing `Take` with the specified defect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const die: (defect: unknown) => Take<never, never> = internal.die
+
+/**
+ * Creates a failing `Take` with the specified error message.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const dieMessage: (message: string) => Take<never, never> = internal.dieMessage
+
+/**
+ * Transforms a `Take<E, A>` to an `Effect<never, E, A>`.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+export const done: <E, A>(self: Take<E, A>) => Effect.Effect<never, Option.Option<E>, Chunk.Chunk<A>> = internal.done
+
+/**
+ * Represents the end-of-stream marker.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const end: Take<never, never> = internal.end
+
+/**
+ * Creates a failing `Take` with the specified error.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const fail: <E>(error: E) => Take<E, never> = internal.fail
+
+/**
+ * Creates a failing `Take` with the specified cause.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const failCause: <E>(cause: Cause.Cause<E>) => Take<E, never> = internal.failCause
+
+/**
+ * Creates an effect from `Effect<R, E, A>` that does not fail, but succeeds with
+ * the `Take<E, A>`. Error from stream when pulling is converted to
+ * `Take.failCause`. Creates a single value chunk.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const fromEffect: <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, never, Take<E, A>> =
+  internal.fromEffect
+
+/**
+ * Creates a `Take` from an `Exit`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const fromExit: <E, A>(exit: Exit.Exit<E, A>) => Take<E, A> = internal.fromExit
+
+/**
+ * Creates effect from `Effect<R, Option<E>, Chunk<A>>` that does not fail, but
+ * succeeds with the `Take<E, A>`. Errors from stream when pulling are converted
+ * to `Take.failCause`, and the end-of-stream is converted to `Take.end`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const fromPull: <R, E, A>(
+  pull: Effect.Effect<R, Option.Option<E>, Chunk.Chunk<A>>
+) => Effect.Effect<R, never, Take<E, A>> = internal.fromPull
+
+/**
+ * Checks if this `take` is done (`Take.end`).
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const isDone: <E, A>(self: Take<E, A>) => boolean = internal.isDone
+
+/**
+ * Checks if this `take` is a failure.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const isFailure: <E, A>(self: Take<E, A>) => boolean = internal.isFailure
+
+/**
+ * Checks if this `take` is a success.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const isSuccess: <E, A>(self: Take<E, A>) => boolean = internal.isSuccess
+
+/**
+ * Constructs a `Take`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const make: <E, A>(exit: Exit.Exit<Option.Option<E>, Chunk.Chunk<A>>) => Take<E, A> = internal.make
+
+/**
+ * Transforms `Take<E, A>` to `Take<E, B>` by applying function `f`.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+export const map: {
+  <A, B>(f: (a: A) => B): <E>(self: Take<E, A>) => Take<E, B>
+  <E, A, B>(self: Take<E, A>, f: (a: A) => B): Take<E, B>
+} = internal.map
+
+/**
+ * Folds over the failure cause, success value and end-of-stream marker to
+ * yield a value.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+export const match: {
+  <Z, E, Z2, A, Z3>(
+    options: {
+      readonly onEnd: () => Z
+      readonly onFailure: (cause: Cause.Cause<E>) => Z2
+      readonly onSuccess: (chunk: Chunk.Chunk<A>) => Z3
+    }
+  ): (self: Take<E, A>) => Z | Z2 | Z3
+  <Z, E, Z2, A, Z3>(
+    self: Take<E, A>,
+    options: {
+      readonly onEnd: () => Z
+      readonly onFailure: (cause: Cause.Cause<E>) => Z2
+      readonly onSuccess: (chunk: Chunk.Chunk<A>) => Z3
+    }
+  ): Z | Z2 | Z3
+} = internal.match
+
+/**
+ * Effectful version of `Take.fold`.
+ *
+ * Folds over the failure cause, success value and end-of-stream marker to
+ * yield an effect.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+export const matchEffect: {
+  <R, E2, Z, R2, E, Z2, A, R3, E3, Z3>(
+    options: {
+      readonly onEnd: () => Effect.Effect<R, E2, Z>
+      readonly onFailure: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, Z2>
+      readonly onSuccess: (chunk: Chunk.Chunk<A>) => Effect.Effect<R3, E3, Z3>
+    }
+  ): (self: Take<E, A>) => Effect.Effect<R | R2 | R3, E2 | E | E3, Z | Z2 | Z3>
+  <R, E2, Z, R2, E, Z2, A, R3, E3, Z3>(
+    self: Take<E, A>,
+    options: {
+      readonly onEnd: () => Effect.Effect<R, E2, Z>
+      readonly onFailure: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, Z2>
+      readonly onSuccess: (chunk: Chunk.Chunk<A>) => Effect.Effect<R3, E3, Z3>
+    }
+  ): Effect.Effect<R | R2 | R3, E2 | E | E3, Z | Z2 | Z3>
+} = internal.matchEffect
+
+/**
+ * Creates a `Take` with a single value chunk.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const of: <A>(value: A) => Take<never, A> = internal.of
+
+/**
+ * Returns an effect that effectfully "peeks" at the success of this take.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+export const tap: {
+  <A, R, E2, _>(
+    f: (chunk: Chunk.Chunk<A>) => Effect.Effect<R, E2, _>
+  ): <E>(self: Take<E, A>) => Effect.Effect<R, E2 | E, void>
+  <E, A, R, E2, _>(
+    self: Take<E, A>,
+    f: (chunk: Chunk.Chunk<A>) => Effect.Effect<R, E2, _>
+  ): Effect.Effect<R, E | E2, void>
+} = internal.tap