effect 2.2.5 → 2.3.1

package/src/TSet.ts

@@ -60,8 +60,8 @@ export declare namespace TSet {
  * @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>
+  <A>(value: A): (self: TSet<A>) => STM.STM<void>
+  <A>(self: TSet<A>, value: A): STM.STM<void>
 } = internal.add
 
 /**
@@ -72,8 +72,8 @@ export const add: {
  * @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>
+  <A>(other: TSet<A>): (self: TSet<A>) => STM.STM<void>
+  <A>(self: TSet<A>, other: TSet<A>): STM.STM<void>
 } = internal.difference
 
 /**
@@ -82,7 +82,7 @@ export const difference: {
  * @since 2.0.0
  * @category constructors
  */
-export const empty: <A>() => STM.STM<never, never, TSet<A>> = internal.empty
+export const empty: <A>() => STM.STM<TSet<A>> = internal.empty
 
 /**
  * Atomically performs transactional-effect for each element in set.
@@ -91,8 +91,8 @@ export const empty: <A>() => STM.STM<never, never, TSet<A>> = internal.empty
  * @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>
+  <A, R, E>(f: (value: A) => STM.STM<void, E, R>): (self: TSet<A>) => STM.STM<void, E, R>
+  <A, R, E>(self: TSet<A>, f: (value: A) => STM.STM<void, E, R>): STM.STM<void, E, R>
 } = internal.forEach
 
 /**
@@ -101,7 +101,7 @@ export const forEach: {
  * @since 2.0.0
  * @category constructors
  */
-export const fromIterable: <A>(iterable: Iterable<A>) => STM.STM<never, never, TSet<A>> = internal.fromIterable
+export const fromIterable: <A>(iterable: Iterable<A>) => STM.STM<TSet<A>> = internal.fromIterable
 
 /**
  * Tests whether or not set contains an element.
@@ -110,8 +110,8 @@ export const fromIterable: <A>(iterable: Iterable<A>) => STM.STM<never, never, T
  * @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>
+  <A>(value: A): (self: TSet<A>) => STM.STM<boolean>
+  <A>(self: TSet<A>, value: A): STM.STM<boolean>
 } = internal.has
 
 /**
@@ -122,8 +122,8 @@ export const has: {
  * @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>
+  <A>(other: TSet<A>): (self: TSet<A>) => STM.STM<void>
+  <A>(self: TSet<A>, other: TSet<A>): STM.STM<void>
 } = internal.intersection
 
 /**
@@ -132,7 +132,7 @@ export const intersection: {
  * @since 2.0.0
  * @category getters
  */
-export const isEmpty: <A>(self: TSet<A>) => STM.STM<never, never, boolean> = internal.isEmpty
+export const isEmpty: <A>(self: TSet<A>) => STM.STM<boolean> = internal.isEmpty
 
 /**
  * Makes a new `TSet` that is initialized with specified values.
@@ -142,7 +142,7 @@ export const isEmpty: <A>(self: TSet<A>) => STM.STM<never, never, boolean> = int
  */
 export const make: <Elements extends Array<any>>(
   ...elements: Elements
-) => STM.STM<never, never, TSet<Elements[number]>> = internal.make
+) => STM.STM<TSet<Elements[number]>> = internal.make
 
 /**
  * Atomically folds using a pure function.
@@ -151,8 +151,8 @@ export const make: <Elements extends Array<any>>(
  * @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>
+  <Z, A>(zero: Z, f: (accumulator: Z, value: A) => Z): (self: TSet<A>) => STM.STM<Z>
+  <Z, A>(self: TSet<A>, zero: Z, f: (accumulator: Z, value: A) => Z): STM.STM<Z>
 } = internal.reduce
 
 /**
@@ -162,8 +162,8 @@ export const reduce: {
  * @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>
+  <Z, A, R, E>(zero: Z, f: (accumulator: Z, value: A) => STM.STM<Z, E, R>): (self: TSet<A>) => STM.STM<Z, E, R>
+  <Z, A, R, E>(self: TSet<A>, zero: Z, f: (accumulator: Z, value: A) => STM.STM<Z, E, R>): STM.STM<Z, E, R>
 } = internal.reduceSTM
 
 /**
@@ -173,8 +173,8 @@ export const reduceSTM: {
  * @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>
+  <A>(value: A): (self: TSet<A>) => STM.STM<void>
+  <A>(self: TSet<A>, value: A): STM.STM<void>
 } = internal.remove
 
 /**
@@ -184,8 +184,8 @@ export const remove: {
  * @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>
+  <A>(iterable: Iterable<A>): (self: TSet<A>) => STM.STM<void>
+  <A>(self: TSet<A>, iterable: Iterable<A>): STM.STM<void>
 } = internal.removeAll
 
 /**
@@ -198,23 +198,23 @@ export const removeAll: {
 export const removeIf: {
   <A>(predicate: Predicate<A>, options: {
     readonly discard: true
-  }): (self: TSet<A>) => STM.STM<never, never, void>
+  }): (self: TSet<A>) => STM.STM<void>
   <A>(
     predicate: Predicate<A>,
     options?: {
       readonly discard: false
     }
-  ): (self: TSet<A>) => STM.STM<never, never, Array<A>>
+  ): (self: TSet<A>) => STM.STM<Array<A>>
   <A>(self: TSet<A>, predicate: Predicate<A>, options: {
     readonly discard: true
-  }): STM.STM<never, never, void>
+  }): STM.STM<void>
   <A>(
     self: TSet<A>,
     predicate: Predicate<A>,
     options?: {
       readonly discard: false
     }
-  ): STM.STM<never, never, Array<A>>
+  ): STM.STM<Array<A>>
 } = internal.removeIf
 
 /**
@@ -227,23 +227,23 @@ export const removeIf: {
 export const retainIf: {
   <A>(predicate: Predicate<A>, options: {
     readonly discard: true
-  }): (self: TSet<A>) => STM.STM<never, never, void>
+  }): (self: TSet<A>) => STM.STM<void>
   <A>(
     predicate: Predicate<A>,
     options?: {
       readonly discard: false
     }
-  ): (self: TSet<A>) => STM.STM<never, never, Array<A>>
+  ): (self: TSet<A>) => STM.STM<Array<A>>
   <A>(self: TSet<A>, predicate: Predicate<A>, options: {
     readonly discard: true
-  }): STM.STM<never, never, void>
+  }): STM.STM<void>
   <A>(
     self: TSet<A>,
     predicate: Predicate<A>,
     options?: {
       readonly discard: false
     }
-  ): STM.STM<never, never, Array<A>>
+  ): STM.STM<Array<A>>
 } = internal.retainIf
 
 /**
@@ -252,7 +252,7 @@ export const retainIf: {
  * @since 2.0.0
  * @category getters
  */
-export const size: <A>(self: TSet<A>) => STM.STM<never, never, number> = internal.size
+export const size: <A>(self: TSet<A>) => STM.STM<number> = internal.size
 
 /**
  * Takes the first matching value, or retries until there is one.
@@ -261,8 +261,8 @@ export const size: <A>(self: TSet<A>) => STM.STM<never, never, number> = interna
  * @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>
+  <A, B>(pf: (a: A) => Option.Option<B>): (self: TSet<A>) => STM.STM<B>
+  <A, B>(self: TSet<A>, pf: (a: A) => Option.Option<B>): STM.STM<B>
 } = internal.takeFirst
 
 /**
@@ -272,8 +272,8 @@ export const takeFirst: {
  * @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>
+  <A, R, E, B>(pf: (a: A) => STM.STM<B, Option.Option<E>, R>): (self: TSet<A>) => STM.STM<B, E, R>
+  <A, R, E, B>(self: TSet<A>, pf: (a: A) => STM.STM<B, Option.Option<E>, R>): STM.STM<B, E, R>
 } = internal.takeFirstSTM
 
 /**
@@ -283,8 +283,8 @@ export const takeFirstSTM: {
  * @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>]>
+  <A, B>(pf: (a: A) => Option.Option<B>): (self: TSet<A>) => STM.STM<[B, ...Array<B>]>
+  <A, B>(self: TSet<A>, pf: (a: A) => Option.Option<B>): STM.STM<[B, ...Array<B>]>
 } = internal.takeSome
 
 /**
@@ -294,8 +294,8 @@ export const takeSome: {
  * @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>]>
+  <A, R, E, B>(pf: (a: A) => STM.STM<B, Option.Option<E>, R>): (self: TSet<A>) => STM.STM<[B, ...Array<B>], E, R>
+  <A, R, E, B>(self: TSet<A>, pf: (a: A) => STM.STM<B, Option.Option<E>, R>): STM.STM<[B, ...Array<B>], E, R>
 } = internal.takeSomeSTM
 
 /**
@@ -304,7 +304,7 @@ export const takeSomeSTM: {
  * @since 2.0.0
  * @category destructors
  */
-export const toChunk: <A>(self: TSet<A>) => STM.STM<never, never, Chunk.Chunk<A>> = internal.toChunk
+export const toChunk: <A>(self: TSet<A>) => STM.STM<Chunk.Chunk<A>> = internal.toChunk
 
 /**
  * Collects all elements into a `HashSet`.
@@ -312,7 +312,7 @@ export const toChunk: <A>(self: TSet<A>) => STM.STM<never, never, Chunk.Chunk<A>
  * @since 2.0.0
  * @category destructors
  */
-export const toHashSet: <A>(self: TSet<A>) => STM.STM<never, never, HashSet.HashSet<A>> = internal.toHashSet
+export const toHashSet: <A>(self: TSet<A>) => STM.STM<HashSet.HashSet<A>> = internal.toHashSet
 
 /**
  * Collects all elements into a `Array`.
@@ -320,7 +320,7 @@ export const toHashSet: <A>(self: TSet<A>) => STM.STM<never, never, HashSet.Hash
  * @since 2.0.0
  * @category destructors
  */
-export const toArray: <A>(self: TSet<A>) => STM.STM<never, never, Array<A>> = internal.toArray
+export const toArray: <A>(self: TSet<A>) => STM.STM<Array<A>> = internal.toArray
 
 /**
  * Collects all elements into a `ReadonlySet`.
@@ -328,7 +328,7 @@ export const toArray: <A>(self: TSet<A>) => STM.STM<never, never, Array<A>> = in
  * @since 2.0.0
  * @category destructors
  */
-export const toReadonlySet: <A>(self: TSet<A>) => STM.STM<never, never, ReadonlySet<A>> = internal.toReadonlySet
+export const toReadonlySet: <A>(self: TSet<A>) => STM.STM<ReadonlySet<A>> = internal.toReadonlySet
 
 /**
  * Atomically updates all elements using a pure function.
@@ -337,8 +337,8 @@ export const toReadonlySet: <A>(self: TSet<A>) => STM.STM<never, never, Readonly
  * @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>
+  <A>(f: (a: A) => A): (self: TSet<A>) => STM.STM<void>
+  <A>(self: TSet<A>, f: (a: A) => A): STM.STM<void>
 } = internal.transform
 
 /**
@@ -348,8 +348,8 @@ export const transform: {
  * @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>
+  <A, R, E>(f: (a: A) => STM.STM<A, E, R>): (self: TSet<A>) => STM.STM<void, E, R>
+  <A, R, E>(self: TSet<A>, f: (a: A) => STM.STM<A, E, R>): STM.STM<void, E, R>
 } = internal.transformSTM
 
 /**
@@ -360,6 +360,6 @@ export const transformSTM: {
  * @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>
+  <A>(other: TSet<A>): (self: TSet<A>) => STM.STM<void>
+  <A>(self: TSet<A>, other: TSet<A>): STM.STM<void>
 } = internal.union

package/src/Take.ts

@@ -23,16 +23,16 @@ export const TakeTypeId: unique symbol = internal.TakeTypeId
 export type TakeTypeId = typeof TakeTypeId
 
 /**
- * A `Take<E, A>` represents a single `take` from a queue modeling a stream of
+ * 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 E, out A> extends Take.Variance<E, A>, Pipeable {
+export interface Take<out A, out E = never> extends Take.Variance<A, E>, Pipeable {
   /** @internal */
-  readonly exit: Exit.Exit<Option.Option<E>, Chunk.Chunk<A>>
+  readonly exit: Exit.Exit<Chunk.Chunk<A>, Option.Option<E>>
 }
 
 /**
@@ -43,10 +43,10 @@ export declare namespace Take {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<out E, out A> {
+  export interface Variance<out A, out E> {
     readonly [TakeTypeId]: {
-      readonly _E: Types.Covariant<E>
       readonly _A: Types.Covariant<A>
+      readonly _E: Types.Covariant<E>
     }
   }
 }
@@ -57,7 +57,7 @@ export declare namespace Take {
  * @since 2.0.0
  * @category constructors
  */
-export const chunk: <A>(chunk: Chunk.Chunk<A>) => Take<never, A> = internal.chunk
+export const chunk: <A>(chunk: Chunk.Chunk<A>) => Take<A> = internal.chunk
 
 /**
  * Creates a failing `Take` with the specified defect.
@@ -65,7 +65,7 @@ export const chunk: <A>(chunk: Chunk.Chunk<A>) => Take<never, A> = internal.chun
  * @since 2.0.0
  * @category constructors
  */
-export const die: (defect: unknown) => Take<never, never> = internal.die
+export const die: (defect: unknown) => Take<never> = internal.die
 
 /**
  * Creates a failing `Take` with the specified error message.
@@ -73,15 +73,15 @@ export const die: (defect: unknown) => Take<never, never> = internal.die
  * @since 2.0.0
  * @category constructors
  */
-export const dieMessage: (message: string) => Take<never, never> = internal.dieMessage
+export const dieMessage: (message: string) => Take<never> = internal.dieMessage
 
 /**
- * Transforms a `Take<E, A>` to an `Effect<never, E, A>`.
+ * Transforms a `Take<A, E>` to an `Effect<A, E>`.
  *
  * @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
+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.
@@ -89,7 +89,7 @@ export const done: <E, A>(self: Take<E, A>) => Effect.Effect<never, Option.Optio
  * @since 2.0.0
  * @category constructors
  */
-export const end: Take<never, never> = internal.end
+export const end: Take<never> = internal.end
 
 /**
  * Creates a failing `Take` with the specified error.
@@ -97,7 +97,7 @@ export const end: Take<never, never> = internal.end
  * @since 2.0.0
  * @category constructors
  */
-export const fail: <E>(error: E) => Take<E, never> = internal.fail
+export const fail: <E>(error: E) => Take<never, E> = internal.fail
 
 /**
  * Creates a failing `Take` with the specified cause.
@@ -105,17 +105,17 @@ export const fail: <E>(error: E) => Take<E, never> = internal.fail
  * @since 2.0.0
  * @category constructors
  */
-export const failCause: <E>(cause: Cause.Cause<E>) => Take<E, never> = internal.failCause
+export const failCause: <E>(cause: Cause.Cause<E>) => Take<never, E> = 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
+ * 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: <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, never, Take<E, A>> =
+export const fromEffect: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<Take<A, E>, never, R> =
   internal.fromEffect
 
 /**
@@ -124,19 +124,19 @@ export const fromEffect: <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Eff
  * @since 2.0.0
  * @category constructors
  */
-export const fromExit: <E, A>(exit: Exit.Exit<E, A>) => Take<E, A> = internal.fromExit
+export const fromExit: <A, E>(exit: Exit.Exit<A, E>) => Take<A, E> = 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
+ * 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: <R, E, A>(
-  pull: Effect.Effect<R, Option.Option<E>, Chunk.Chunk<A>>
-) => Effect.Effect<R, never, Take<E, A>> = internal.fromPull
+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`).
@@ -144,7 +144,7 @@ export const fromPull: <R, E, A>(
  * @since 2.0.0
  * @category getters
  */
-export const isDone: <E, A>(self: Take<E, A>) => boolean = internal.isDone
+export const isDone: <A, E>(self: Take<A, E>) => boolean = internal.isDone
 
 /**
  * Checks if this `take` is a failure.
@@ -152,7 +152,7 @@ export const isDone: <E, A>(self: Take<E, A>) => boolean = internal.isDone
  * @since 2.0.0
  * @category getters
  */
-export const isFailure: <E, A>(self: Take<E, A>) => boolean = internal.isFailure
+export const isFailure: <A, E>(self: Take<A, E>) => boolean = internal.isFailure
 
 /**
  * Checks if this `take` is a success.
@@ -160,7 +160,7 @@ export const isFailure: <E, A>(self: Take<E, A>) => boolean = internal.isFailure
  * @since 2.0.0
  * @category getters
  */
-export const isSuccess: <E, A>(self: Take<E, A>) => boolean = internal.isSuccess
+export const isSuccess: <A, E>(self: Take<A, E>) => boolean = internal.isSuccess
 
 /**
  * Constructs a `Take`.
@@ -168,17 +168,17 @@ export const isSuccess: <E, A>(self: Take<E, A>) => boolean = internal.isSuccess
  * @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
+export const make: <A, E>(exit: Exit.Exit<Chunk.Chunk<A>, Option.Option<E>>) => Take<A, E> = internal.make
 
 /**
- * Transforms `Take<E, A>` to `Take<E, B>` by applying function `f`.
+ * 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<E, A>) => Take<E, B>
-  <E, A, B>(self: Take<E, A>, f: (a: A) => B): Take<E, B>
+  <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
 
 /**
@@ -195,9 +195,9 @@ export const match: {
       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>,
+  ): (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
@@ -216,21 +216,21 @@ export const match: {
  * @category destructors
  */
 export const matchEffect: {
-  <R, E2, Z, R2, E, Z2, A, R3, E3, Z3>(
+  <Z, E2, R, E, Z2, R2, A, Z3, E3, R3>(
     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>
+      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<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>,
+  ): (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<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>
+      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<R | R2 | R3, E2 | E | E3, Z | Z2 | Z3>
+  ): Effect.Effect<Z | Z2 | Z3, E | E2 | E3, R | R2 | R3>
 } = internal.matchEffect
 
 /**
@@ -239,7 +239,7 @@ export const matchEffect: {
  * @since 2.0.0
  * @category constructors
  */
-export const of: <A>(value: A) => Take<never, A> = internal.of
+export const of: <A>(value: A) => Take<A> = internal.of
 
 /**
  * Returns an effect that effectfully "peeks" at the success of this take.
@@ -248,11 +248,11 @@ export const of: <A>(value: A) => Take<never, A> = internal.of
  * @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>
+  <A, _, E2, R>(
+    f: (chunk: Chunk.Chunk<A>) => Effect.Effect<_, E2, R>
+  ): <E>(self: Take<A, E>) => Effect.Effect<void, E2 | E, R>
+  <A, E, _, E2, R>(
+    self: Take<A, E>,
+    f: (chunk: Chunk.Chunk<A>) => Effect.Effect<_, E2, R>
+  ): Effect.Effect<void, E | E2, R>
 } = internal.tap

package/src/TestAnnotation.ts

@@ -2,7 +2,6 @@
  * @since 2.0.0
  */
 import * as Chunk from "./Chunk.js"
-import * as Context from "./Context.js"
 import * as Either from "./Either.js"
 import * as Equal from "./Equal.js"
 import type * as Fiber from "./Fiber.js"
@@ -34,7 +33,6 @@ export interface TestAnnotation<in out A> extends Equal.Equal {
     readonly _A: Types.Invariant<A>
   }
   readonly identifier: string
-  readonly tag: Context.Tag<A, A>
   readonly initial: A
   combine(a: A, b: A): A
 }
@@ -46,21 +44,18 @@ class TestAnnotationImpl<A> implements Equal.Equal {
   }
   constructor(
     readonly identifier: string,
-    readonly tag: Context.Tag<A, A>,
     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.combine(Hash.hash(this.tag))
+      Hash.combine(Hash.hash(this.identifier))
     )
   }
   [Equal.symbol](that: unknown): boolean {
     return isTestAnnotation(that) &&
-      this.identifier === that.identifier &&
-      Equal.equals(this.tag, that.tag)
+      this.identifier === that.identifier
   }
 }
 
@@ -74,11 +69,10 @@ export const isTestAnnotation = (u: unknown): u is TestAnnotation<unknown> => ha
  */
 export const make = <A>(
   identifier: string,
-  tag: Context.Tag<A, A>,
   initial: A,
   combine: (a: A, b: A) => A
 ): TestAnnotation<A> => {
-  return new TestAnnotationImpl(identifier, tag, initial, combine)
+  return new TestAnnotationImpl<A>(identifier, initial, combine)
 }
 
 /**
@@ -111,11 +105,10 @@ export const fibers: TestAnnotation<
     number,
     Chunk.Chunk<MutableRef.MutableRef<SortedSet.SortedSet<Fiber.RuntimeFiber<unknown, unknown>>>>
   >
-> = make(
+> = make<
+  Either.Either<number, Chunk.Chunk<MutableRef.MutableRef<SortedSet.SortedSet<Fiber.RuntimeFiber<unknown, unknown>>>>>
+>(
   "fibers",
-  Context.Tag<
-    Either.Either<number, Chunk.Chunk<MutableRef.MutableRef<SortedSet.SortedSet<Fiber.RuntimeFiber<unknown, unknown>>>>>
-  >(),
   Either.left(0),
   compose
 )
@@ -127,7 +120,6 @@ export const fibers: TestAnnotation<
  */
 export const ignored: TestAnnotation<number> = make(
   "ignored",
-  Context.Tag<number>(Symbol.for("effect/TestAnnotation/ignored")),
   0,
   (a, b) => a + b
 )
@@ -139,7 +131,6 @@ export const ignored: TestAnnotation<number> = make(
  */
 export const repeated: TestAnnotation<number> = make(
   "repeated",
-  Context.Tag<number>(Symbol.for("effect/TestAnnotation/repeated")),
   0,
   (a, b) => a + b
 )
@@ -151,7 +142,6 @@ export const repeated: TestAnnotation<number> = make(
  */
 export const retried: TestAnnotation<number> = make(
   "retried",
-  Context.Tag<number>(Symbol.for("effect/TestAnnotation/retired")),
   0,
   (a, b) => a + b
 )
@@ -163,7 +153,6 @@ export const retried: TestAnnotation<number> = make(
  */
 export const tagged: TestAnnotation<HashSet.HashSet<string>> = make(
   "tagged",
-  Context.Tag<HashSet.HashSet<string>>(Symbol.for("effect/TestAnnotation/tagged")),
   HashSet.empty(),
   (a, b) => pipe(a, HashSet.union(b))
 )