@clayroach/effect 3.19.14-source-capture.8 → 3.19.14-source-trace.1

package/src/Take.ts

@@ -0,0 +1,258 @@
+/**
+ * @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

@@ -0,0 +1,158 @@
+/**
+ * @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

@@ -0,0 +1,119 @@
+/**
+ * @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

@@ -0,0 +1,117 @@
+/**
+ * @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)