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

package/src/Take.ts

@@ -1,258 +0,0 @@
-/**
- * @since 2.0.0
- */
-import type * as Cause from "./Cause.js"
-import type * as Chunk from "./Chunk.js"
-import type * as Effect from "./Effect.js"
-import type * as Exit from "./Exit.js"
-import * as internal from "./internal/take.js"
-import type * as Option from "./Option.js"
-import type { Pipeable } from "./Pipeable.js"
-import type * as Types from "./Types.js"
-
-/**
- * @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<A, E>` 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<out A, out E = never> extends Take.Variance<A, E>, Pipeable {
-  /** @internal */
-  readonly exit: Exit.Exit<Chunk.Chunk<A>, Option.Option<E>>
-}
-
-/**
- * @since 2.0.0
- */
-export declare namespace Take {
-  /**
-   * @since 2.0.0
-   * @category models
-   */
-  export interface Variance<out A, out E> {
-    readonly [TakeTypeId]: {
-      readonly _A: Types.Covariant<A>
-      readonly _E: Types.Covariant<E>
-    }
-  }
-}
-
-/**
- * Creates a `Take` with the specified chunk.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const chunk: <A>(chunk: Chunk.Chunk<A>) => Take<A> = internal.chunk
-
-/**
- * Creates a failing `Take` with the specified defect.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const die: (defect: unknown) => Take<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> = internal.dieMessage
-
-/**
- * Transforms a `Take<A, E>` to an `Effect<A, E>`.
- *
- * @since 2.0.0
- * @category destructors
- */
-export const done: <A, E>(self: Take<A, E>) => Effect.Effect<Chunk.Chunk<A>, Option.Option<E>> = internal.done
-
-/**
- * Represents the end-of-stream marker.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const end: Take<never> = internal.end
-
-/**
- * Creates a failing `Take` with the specified error.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const fail: <E>(error: E) => Take<never, E> = 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<never, E> = internal.failCause
-
-/**
- * Creates an effect from `Effect<A, E, R>` that does not fail, but succeeds with
- * the `Take<A, E>`. Error from stream when pulling is converted to
- * `Take.failCause`. Creates a single value chunk.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const fromEffect: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<Take<A, E>, never, R> =
-  internal.fromEffect
-
-/**
- * Creates a `Take` from an `Exit`.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const fromExit: <A, E>(exit: Exit.Exit<A, E>) => Take<A, E> = internal.fromExit
-
-/**
- * Creates effect from `Effect<Chunk<A>, Option<E>, R>` that does not fail, but
- * succeeds with the `Take<A, E>`. 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: <A, E, R>(
-  pull: Effect.Effect<Chunk.Chunk<A>, Option.Option<E>, R>
-) => Effect.Effect<Take<A, E>, never, R> = internal.fromPull
-
-/**
- * Checks if this `take` is done (`Take.end`).
- *
- * @since 2.0.0
- * @category getters
- */
-export const isDone: <A, E>(self: Take<A, E>) => boolean = internal.isDone
-
-/**
- * Checks if this `take` is a failure.
- *
- * @since 2.0.0
- * @category getters
- */
-export const isFailure: <A, E>(self: Take<A, E>) => boolean = internal.isFailure
-
-/**
- * Checks if this `take` is a success.
- *
- * @since 2.0.0
- * @category getters
- */
-export const isSuccess: <A, E>(self: Take<A, E>) => boolean = internal.isSuccess
-
-/**
- * Constructs a `Take`.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const make: <A, E>(exit: Exit.Exit<Chunk.Chunk<A>, Option.Option<E>>) => Take<A, E> = internal.make
-
-/**
- * Transforms `Take<A, E>` to `Take<B, A>` by applying function `f`.
- *
- * @since 2.0.0
- * @category mapping
- */
-export const map: {
-  <A, B>(f: (a: A) => B): <E>(self: Take<A, E>) => Take<B, E>
-  <A, E, B>(self: Take<A, E>, f: (a: A) => B): Take<B, E>
-} = 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<A, E>) => Z | Z2 | Z3
-  <A, E, Z, Z2, Z3>(
-    self: Take<A, E>,
-    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: {
-  <Z, E2, R, E, Z2, R2, A, Z3, E3, R3>(
-    options: {
-      readonly onEnd: Effect.Effect<Z, E2, R>
-      readonly onFailure: (cause: Cause.Cause<E>) => Effect.Effect<Z2, E2, R2>
-      readonly onSuccess: (chunk: Chunk.Chunk<A>) => Effect.Effect<Z3, E3, R3>
-    }
-  ): (self: Take<A, E>) => Effect.Effect<Z | Z2 | Z3, E2 | E | E3, R | R2 | R3>
-  <A, E, Z, E2, R, Z2, R2, Z3, E3, R3>(
-    self: Take<A, E>,
-    options: {
-      readonly onEnd: Effect.Effect<Z, E2, R>
-      readonly onFailure: (cause: Cause.Cause<E>) => Effect.Effect<Z2, E2, R2>
-      readonly onSuccess: (chunk: Chunk.Chunk<A>) => Effect.Effect<Z3, E3, R3>
-    }
-  ): Effect.Effect<Z | Z2 | Z3, E | E2 | E3, R | R2 | R3>
-} = internal.matchEffect
-
-/**
- * Creates a `Take` with a single value chunk.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const of: <A>(value: A) => Take<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, X, E2, R>(
-    f: (chunk: Chunk.Chunk<A>) => Effect.Effect<X, E2, R>
-  ): <E>(self: Take<A, E>) => Effect.Effect<void, E2 | E, R>
-  <A, E, X, E2, R>(
-    self: Take<A, E>,
-    f: (chunk: Chunk.Chunk<A>) => Effect.Effect<X, E2, R>
-  ): Effect.Effect<void, E | E2, R>
-} = internal.tap

package/src/TestAnnotation.ts

@@ -1,158 +0,0 @@
-/**
- * @since 2.0.0
- */
-import * as Chunk from "./Chunk.js"
-import * as Either from "./Either.js"
-import * as Equal from "./Equal.js"
-import type * as Fiber from "./Fiber.js"
-import { pipe } from "./Function.js"
-import * as Hash from "./Hash.js"
-import * as HashSet from "./HashSet.js"
-import { getBugErrorMessage } from "./internal/errors.js"
-import type * as MutableRef from "./MutableRef.js"
-import { hasProperty } from "./Predicate.js"
-import type * as SortedSet from "./SortedSet.js"
-import type * as Types from "./Types.js"
-
-/** @internal */
-const TestAnnotationSymbolKey = "effect/TestAnnotation"
-
-/**
- * @since 2.0.0
- */
-export const TestAnnotationTypeId: unique symbol = Symbol.for(TestAnnotationSymbolKey)
-
-/**
- * @since 2.0.0
- */
-export type TestAnnotationTypeId = typeof TestAnnotationTypeId
-
-/**
- * @since 2.0.0
- */
-export interface TestAnnotation<in out A> extends Equal.Equal {
-  readonly [TestAnnotationTypeId]: {
-    readonly _A: Types.Invariant<A>
-  }
-  readonly identifier: string
-  readonly initial: A
-  combine(a: A, b: A): A
-}
-
-/** @internal */
-class TestAnnotationImpl<A> implements Equal.Equal {
-  readonly [TestAnnotationTypeId] = {
-    _A: (_: any) => _
-  }
-  constructor(
-    readonly identifier: string,
-    readonly initial: A,
-    readonly combine: (a: A, b: A) => A
-  ) {}
-  [Hash.symbol](): number {
-    return pipe(
-      Hash.hash(TestAnnotationSymbolKey),
-      Hash.combine(Hash.hash(this.identifier)),
-      Hash.cached(this)
-    )
-  }
-  [Equal.symbol](that: unknown): boolean {
-    return isTestAnnotation(that) &&
-      this.identifier === that.identifier
-  }
-}
-
-/**
- * @since 2.0.0
- */
-export const isTestAnnotation = (u: unknown): u is TestAnnotation<unknown> => hasProperty(u, TestAnnotationTypeId)
-
-/**
- * @since 2.0.0
- */
-export const make = <A>(
-  identifier: string,
-  initial: A,
-  combine: (a: A, b: A) => A
-): TestAnnotation<A> => {
-  return new TestAnnotationImpl<A>(identifier, initial, combine)
-}
-
-/**
- * @since 2.0.0
- */
-export const compose = <A>(
-  left: Either.Either<Chunk.Chunk<A>, number>,
-  right: Either.Either<Chunk.Chunk<A>, number>
-): Either.Either<Chunk.Chunk<A>, number> => {
-  if (Either.isLeft(left) && Either.isLeft(right)) {
-    return Either.left(left.left + right.left)
-  }
-  if (Either.isRight(left) && Either.isRight(right)) {
-    return Either.right(pipe(left.right, Chunk.appendAll(right.right)))
-  }
-  if (Either.isRight(left) && Either.isLeft(right)) {
-    return right
-  }
-  if (Either.isLeft(left) && Either.isRight(right)) {
-    return right
-  }
-  throw new Error(getBugErrorMessage("TestAnnotation.compose"))
-}
-
-/**
- * @since 2.0.0
- */
-export const fibers: TestAnnotation<
-  Either.Either<Chunk.Chunk<MutableRef.MutableRef<SortedSet.SortedSet<Fiber.RuntimeFiber<unknown, unknown>>>>, number>
-> = make<
-  Either.Either<Chunk.Chunk<MutableRef.MutableRef<SortedSet.SortedSet<Fiber.RuntimeFiber<unknown, unknown>>>>, number>
->(
-  "fibers",
-  Either.left(0),
-  compose
-)
-
-/**
- * An annotation which counts ignored tests.
- *
- * @since 2.0.0
- */
-export const ignored: TestAnnotation<number> = make(
-  "ignored",
-  0,
-  (a, b) => a + b
-)
-
-/**
- * An annotation which counts repeated tests.
- *
- * @since 2.0.0
- */
-export const repeated: TestAnnotation<number> = make(
-  "repeated",
-  0,
-  (a, b) => a + b
-)
-
-/**
- * An annotation which counts retried tests.
- *
- * @since 2.0.0
- */
-export const retried: TestAnnotation<number> = make(
-  "retried",
-  0,
-  (a, b) => a + b
-)
-
-/**
- * An annotation which tags tests with strings.
- *
- * @since 2.0.0
- */
-export const tagged: TestAnnotation<HashSet.HashSet<string>> = make(
-  "tagged",
-  HashSet.empty(),
-  (a, b) => pipe(a, HashSet.union(b))
-)

package/src/TestAnnotationMap.ts

@@ -1,119 +0,0 @@
-/**
- * @since 2.0.0
- */
-import { dual } from "./Function.js"
-import * as HashMap from "./HashMap.js"
-import { hasProperty } from "./Predicate.js"
-import type * as TestAnnotation from "./TestAnnotation.js"
-
-/**
- * @since 2.0.0
- */
-export const TestAnnotationMapTypeId: unique symbol = Symbol.for("effect/TestAnnotationMap")
-
-/**
- * @since 2.0.0
- */
-export type TestAnnotationMapTypeId = typeof TestAnnotationMapTypeId
-
-/**
- * An annotation map keeps track of annotations of different types.
- *
- * @since 2.0.0
- */
-export interface TestAnnotationMap {
-  readonly [TestAnnotationMapTypeId]: TestAnnotationMapTypeId
-  /** @internal */
-  readonly map: HashMap.HashMap<TestAnnotation.TestAnnotation<any>, any>
-}
-
-/** @internal */
-class TestAnnotationMapImpl implements TestAnnotationMap {
-  readonly [TestAnnotationMapTypeId]: TestAnnotationMapTypeId = TestAnnotationMapTypeId
-  constructor(readonly map: HashMap.HashMap<TestAnnotation.TestAnnotation<any>, any>) {
-  }
-}
-
-/**
- * @since 2.0.0
- */
-export const isTestAnnotationMap = (u: unknown): u is TestAnnotationMap => hasProperty(u, TestAnnotationMapTypeId)
-
-/**
- * @since 2.0.0
- */
-export const empty: (_: void) => TestAnnotationMap = () => new TestAnnotationMapImpl(HashMap.empty())
-
-/**
- * @since 2.0.0
- */
-export const make = (map: HashMap.HashMap<TestAnnotation.TestAnnotation<any>, any>): TestAnnotationMap => {
-  return new TestAnnotationMapImpl(map)
-}
-
-/**
- * @since 2.0.0
- */
-export const overwrite = dual<
-  <A>(key: TestAnnotation.TestAnnotation<A>, value: A) => (self: TestAnnotationMap) => TestAnnotationMap,
-  <A>(self: TestAnnotationMap, key: TestAnnotation.TestAnnotation<A>, value: A) => TestAnnotationMap
->(3, (self, key, value) => make(HashMap.set(self.map, key, value)))
-
-/**
- * @since 2.0.0
- */
-export const update = dual<
-  <A>(key: TestAnnotation.TestAnnotation<A>, f: (value: A) => A) => (self: TestAnnotationMap) => TestAnnotationMap,
-  <A>(self: TestAnnotationMap, key: TestAnnotation.TestAnnotation<A>, f: (value: A) => A) => TestAnnotationMap
->(3, <A>(self: TestAnnotationMap, key: TestAnnotation.TestAnnotation<A>, f: (value: A) => A) => {
-  let value = key.initial
-  if (HashMap.has(self.map, key)) {
-    value = HashMap.unsafeGet(self.map, key) as A
-  }
-  return overwrite(self, key, f(value))
-})
-
-/**
- * Retrieves the annotation of the specified type, or its default value if
- * there is none.
- *
- * @since 2.0.0
- */
-export const get = dual<
-  <A>(key: TestAnnotation.TestAnnotation<A>) => (self: TestAnnotationMap) => A,
-  <A>(self: TestAnnotationMap, key: TestAnnotation.TestAnnotation<A>) => A
->(2, <A>(self: TestAnnotationMap, key: TestAnnotation.TestAnnotation<A>) => {
-  if (HashMap.has(self.map, key)) {
-    return HashMap.unsafeGet(self.map, key) as A
-  }
-  return key.initial
-})
-
-/**
- * Appends the specified annotation to the annotation map.
- *
- * @since 2.0.0
- */
-export const annotate = dual<
-  <A>(key: TestAnnotation.TestAnnotation<A>, value: A) => (self: TestAnnotationMap) => TestAnnotationMap,
-  <A>(self: TestAnnotationMap, key: TestAnnotation.TestAnnotation<A>, value: A) => TestAnnotationMap
->(3, (self, key, value) => update(self, key, (_) => key.combine(_, value)))
-
-/**
- * @since 2.0.0
- */
-export const combine = dual<
-  (that: TestAnnotationMap) => (self: TestAnnotationMap) => TestAnnotationMap,
-  (self: TestAnnotationMap, that: TestAnnotationMap) => TestAnnotationMap
->(2, (self, that) => {
-  let result = self.map
-  for (const entry of that.map) {
-    if (HashMap.has(result, entry[0])) {
-      const value = HashMap.get(result, entry[0])!
-      result = HashMap.set(result, entry[0], entry[0].combine(value, entry[1]))
-    } else {
-      result = HashMap.set(result, entry[0], entry[1])
-    }
-  }
-  return make(result)
-})

package/src/TestAnnotations.ts

@@ -1,117 +0,0 @@
-/**
- * @since 2.0.0
- */
-import * as RA from "./Array.js"
-import * as Context from "./Context.js"
-import type * as Effect from "./Effect.js"
-import * as Equal from "./Equal.js"
-import type * as Fiber from "./Fiber.js"
-import { pipe } from "./Function.js"
-import * as effect from "./internal/core-effect.js"
-import * as core from "./internal/core.js"
-import * as fiber from "./internal/fiber.js"
-import * as MutableRef from "./MutableRef.js"
-import { hasProperty } from "./Predicate.js"
-import * as Ref from "./Ref.js"
-import * as SortedSet from "./SortedSet.js"
-import * as TestAnnotation from "./TestAnnotation.js"
-import * as TestAnnotationMap from "./TestAnnotationMap.js"
-
-/**
- * @since 2.0.0
- */
-export const TestAnnotationsTypeId: unique symbol = Symbol.for("effect/TestAnnotations")
-
-/**
- * @since 2.0.0
- */
-export type TestAnnotationsTypeId = typeof TestAnnotationsTypeId
-
-/**
- * The `Annotations` trait provides access to an annotation map that tests can
- * add arbitrary annotations to. Each annotation consists of a string
- * identifier, an initial value, and a function for combining two values.
- * Annotations form monoids and you can think of `Annotations` as a more
- * structured logging service or as a super polymorphic version of the writer
- * monad effect.
- *
- * @since 2.0.0
- */
-export interface TestAnnotations {
-  readonly [TestAnnotationsTypeId]: TestAnnotationsTypeId
-
-  /**
-   * A ref containing the bacnking map for all annotations
-   */
-  readonly ref: Ref.Ref<TestAnnotationMap.TestAnnotationMap>
-
-  /**
-   * Accesses an `Annotations` instance in the context and retrieves the
-   * annotation of the specified type, or its default value if there is none.
-   */
-  get<A>(key: TestAnnotation.TestAnnotation<A>): Effect.Effect<A>
-
-  /**
-   * Accesses an `Annotations` instance in the context and appends the
-   * specified annotation to the annotation map.
-   */
-  annotate<A>(key: TestAnnotation.TestAnnotation<A>, value: A): Effect.Effect<void>
-
-  /**
-   * Returns the set of all fibers in this test.
-   */
-  readonly supervisedFibers: Effect.Effect<
-    SortedSet.SortedSet<Fiber.RuntimeFiber<unknown, unknown>>
-  >
-}
-
-/** @internal */
-class AnnotationsImpl implements TestAnnotations {
-  readonly [TestAnnotationsTypeId]: TestAnnotationsTypeId = TestAnnotationsTypeId
-  constructor(readonly ref: Ref.Ref<TestAnnotationMap.TestAnnotationMap>) {
-  }
-  get<A>(key: TestAnnotation.TestAnnotation<A>): Effect.Effect<A> {
-    return core.map(Ref.get(this.ref), TestAnnotationMap.get(key))
-  }
-  annotate<A>(key: TestAnnotation.TestAnnotation<A>, value: A): Effect.Effect<void> {
-    return Ref.update(this.ref, TestAnnotationMap.annotate(key, value))
-  }
-  get supervisedFibers(): Effect.Effect<SortedSet.SortedSet<Fiber.RuntimeFiber<unknown, unknown>>> {
-    return effect.descriptorWith((descriptor) =>
-      core.flatMap(this.get(TestAnnotation.fibers), (either) => {
-        switch (either._tag) {
-          case "Left": {
-            return core.succeed(SortedSet.empty(fiber.Order))
-          }
-          case "Right": {
-            return pipe(
-              either.right,
-              core.forEachSequential((ref) => core.sync(() => MutableRef.get(ref))),
-              core.map(RA.reduce(SortedSet.empty(fiber.Order), (a, b) => SortedSet.union(a, b))),
-              core.map(SortedSet.filter((fiber) => !Equal.equals(fiber.id(), descriptor.id)))
-            )
-          }
-        }
-      })
-    )
-  }
-}
-
-/**
- * @since 2.0.0
- */
-export const TestAnnotations: Context.Tag<TestAnnotations, TestAnnotations> = Context.GenericTag<TestAnnotations>(
-  "effect/Annotations"
-)
-
-/**
- * @since 2.0.0
- */
-export const isTestAnnotations = (u: unknown): u is TestAnnotations => hasProperty(u, TestAnnotationsTypeId)
-
-/**
- * @since 2.0.0
- */
-export const make = (
-  ref: Ref.Ref<TestAnnotationMap.TestAnnotationMap>
-): TestAnnotations => new AnnotationsImpl(ref)