effect 2.2.5 → 2.3.1

package/src/internal/take.ts

@@ -17,15 +17,15 @@ export const TakeTypeId: Take.TakeTypeId = Symbol.for(
 
 const takeVariance = {
   /* c8 ignore next */
-  _E: (_: never) => _,
+  _A: (_: never) => _,
   /* c8 ignore next */
-  _A: (_: never) => _
+  _E: (_: never) => _
 }
 
 /** @internal */
-export class TakeImpl<out E, out A> implements Take.Take<E, A> {
+export class TakeImpl<out A, out E = never> implements Take.Take<A, E> {
   readonly [TakeTypeId] = takeVariance
-  constructor(readonly exit: Exit.Exit<Option.Option<E>, Chunk.Chunk<A>>) {
+  constructor(readonly exit: Exit.Exit<Chunk.Chunk<A>, Option.Option<E>>) {
   }
   pipe() {
     return pipeArguments(this, arguments)
@@ -33,41 +33,41 @@ export class TakeImpl<out E, out A> implements Take.Take<E, A> {
 }
 
 /** @internal */
-export const chunk = <A>(chunk: Chunk.Chunk<A>): Take.Take<never, A> => new TakeImpl(Exit.succeed(chunk))
+export const chunk = <A>(chunk: Chunk.Chunk<A>): Take.Take<A> => new TakeImpl(Exit.succeed(chunk))
 
 /** @internal */
-export const die = (defect: unknown): Take.Take<never, never> => new TakeImpl(Exit.die(defect))
+export const die = (defect: unknown): Take.Take<never> => new TakeImpl(Exit.die(defect))
 
 /** @internal */
-export const dieMessage = (message: string): Take.Take<never, never> =>
+export const dieMessage = (message: string): Take.Take<never> =>
   new TakeImpl(Exit.die(new Cause.RuntimeException(message)))
 
 /** @internal */
-export const done = <E, A>(self: Take.Take<E, A>): Effect.Effect<never, Option.Option<E>, Chunk.Chunk<A>> =>
+export const done = <A, E>(self: Take.Take<A, E>): Effect.Effect<Chunk.Chunk<A>, Option.Option<E>> =>
   Effect.suspend(() => self.exit)
 
 /** @internal */
-export const end: Take.Take<never, never> = new TakeImpl(Exit.fail(Option.none()))
+export const end: Take.Take<never> = new TakeImpl(Exit.fail(Option.none()))
 
 /** @internal */
-export const fail = <E>(error: E): Take.Take<E, never> => new TakeImpl(Exit.fail(Option.some(error)))
+export const fail = <E>(error: E): Take.Take<never, E> => new TakeImpl(Exit.fail(Option.some(error)))
 
 /** @internal */
-export const failCause = <E>(cause: Cause.Cause<E>): Take.Take<E, never> =>
+export const failCause = <E>(cause: Cause.Cause<E>): Take.Take<never, E> =>
   new TakeImpl(Exit.failCause(pipe(cause, Cause.map(Option.some))))
 
 /** @internal */
-export const fromEffect = <R, E, A>(effect: Effect.Effect<R, E, A>): Effect.Effect<R, never, Take.Take<E, A>> =>
+export const fromEffect = <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<Take.Take<A, E>, never, R> =>
   Effect.matchCause(effect, { onFailure: failCause, onSuccess: of })
 
 /** @internal */
-export const fromExit = <E, A>(exit: Exit.Exit<E, A>): Take.Take<E, A> =>
+export const fromExit = <A, E>(exit: Exit.Exit<A, E>): Take.Take<A, E> =>
   new TakeImpl(pipe(exit, Exit.mapBoth({ onFailure: Option.some, onSuccess: Chunk.of })))
 
 /** @internal */
-export const fromPull = <R, E, A>(
-  pull: Effect.Effect<R, Option.Option<E>, Chunk.Chunk<A>>
-): Effect.Effect<R, never, Take.Take<E, A>> =>
+export const fromPull = <A, E, R>(
+  pull: Effect.Effect<Chunk.Chunk<A>, Option.Option<E>, R>
+): Effect.Effect<Take.Take<A, E>, never, R> =>
   Effect.matchCause(pull, {
     onFailure: (cause) =>
       Option.match(Cause.flipCauseOption(cause), {
@@ -78,30 +78,30 @@ export const fromPull = <R, E, A>(
   })
 
 /** @internal */
-export const isDone = <E, A>(self: Take.Take<E, A>): boolean =>
+export const isDone = <A, E>(self: Take.Take<A, E>): boolean =>
   Exit.match(self.exit, {
     onFailure: (cause) => Option.isNone(Cause.flipCauseOption(cause)),
     onSuccess: constFalse
   })
 
 /** @internal */
-export const isFailure = <E, A>(self: Take.Take<E, A>): boolean =>
+export const isFailure = <A, E>(self: Take.Take<A, E>): boolean =>
   Exit.match(self.exit, {
     onFailure: (cause) => Option.isSome(Cause.flipCauseOption(cause)),
     onSuccess: constFalse
   })
 
 /** @internal */
-export const isSuccess = <E, A>(self: Take.Take<E, A>): boolean =>
+export const isSuccess = <A, E>(self: Take.Take<A, E>): boolean =>
   Exit.match(self.exit, {
     onFailure: constFalse,
     onSuccess: constTrue
   })
 
 /** @internal */
-export const make = <E, A>(
-  exit: Exit.Exit<Option.Option<E>, Chunk.Chunk<A>>
-): Take.Take<E, A> => new TakeImpl(exit)
+export const make = <A, E>(
+  exit: Exit.Exit<Chunk.Chunk<A>, Option.Option<E>>
+): Take.Take<A, E> => new TakeImpl(exit)
 
 /** @internal */
 export const match = dual<
@@ -111,17 +111,17 @@ export const match = dual<
       readonly onFailure: (cause: Cause.Cause<E>) => Z2
       readonly onSuccess: (chunk: Chunk.Chunk<A>) => Z3
     }
-  ) => (self: Take.Take<E, A>) => Z | Z2 | Z3,
-  <Z, E, Z2, A, Z3>(
-    self: Take.Take<E, A>,
+  ) => (self: Take.Take<A, E>) => Z | Z2 | Z3,
+  <A, E, Z, Z2, Z3>(
+    self: Take.Take<A, E>,
     options: {
       readonly onEnd: () => Z
       readonly onFailure: (cause: Cause.Cause<E>) => Z2
       readonly onSuccess: (chunk: Chunk.Chunk<A>) => Z3
     }
   ) => Z | Z2 | Z3
->(2, <Z, E, Z2, A, Z3>(
-  self: Take.Take<E, A>,
+>(2, <A, E, Z, Z2, Z3>(
+  self: Take.Take<A, E>,
   { onEnd, onFailure, onSuccess }: {
     readonly onEnd: () => Z
     readonly onFailure: (cause: Cause.Cause<E>) => Z2
@@ -139,32 +139,32 @@ export const match = dual<
 
 /** @internal */
 export const matchEffect = dual<
-  <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.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.Take<E, A>,
+  ) => (self: Take.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.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>
->(2, <R, E2, Z, R2, E, Z2, A, R3, E3, Z3>(
-  self: Take.Take<E, A>,
+  ) => Effect.Effect<Z | Z2 | Z3, E2 | E | E3, R | R2 | R3>
+>(2, <A, E, Z, E2, R, Z2, R2, Z3, E3, R3>(
+  self: Take.Take<A, E>,
   { onEnd, onFailure, onSuccess }: {
-    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, E | E2 | E3, Z | Z2 | Z3> =>
-  Exit.matchEffect<Option.Option<E>, Chunk.Chunk<A>, R | R2, E | E2, Z | Z2, R3, E3, Z3>(self.exit, {
+): Effect.Effect<Z | Z2 | Z3, E2 | E | E3, R | R2 | R3> =>
+  Exit.matchEffect(self.exit, {
     onFailure: (cause) =>
-      Option.match(Cause.flipCauseOption(cause), {
+      Option.match<Cause.Cause<E>, Effect.Effect<Z | Z2, E2 | E, R | R2>>(Cause.flipCauseOption(cause), {
         onNone: () => onEnd,
         onSome: onFailure
       }),
@@ -173,27 +173,27 @@ export const matchEffect = dual<
 
 /** @internal */
 export const map = dual<
-  <A, B>(f: (a: A) => B) => <E>(self: Take.Take<E, A>) => Take.Take<E, B>,
-  <E, A, B>(self: Take.Take<E, A>, f: (a: A) => B) => Take.Take<E, B>
+  <A, B>(f: (a: A) => B) => <E>(self: Take.Take<A, E>) => Take.Take<B, E>,
+  <A, E, B>(self: Take.Take<A, E>, f: (a: A) => B) => Take.Take<B, E>
 >(
   2,
-  <E, A, B>(self: Take.Take<E, A>, f: (a: A) => B): Take.Take<E, B> =>
+  <A, E, B>(self: Take.Take<A, E>, f: (a: A) => B): Take.Take<B, E> =>
     new TakeImpl(pipe(self.exit, Exit.map(Chunk.map(f))))
 )
 
 /** @internal */
-export const of = <A>(value: A): Take.Take<never, A> => new TakeImpl(Exit.succeed(Chunk.of(value)))
+export const of = <A>(value: A): Take.Take<A> => new TakeImpl(Exit.succeed(Chunk.of(value)))
 
 /** @internal */
 export const tap = dual<
-  <A, R, E2, _>(
-    f: (chunk: Chunk.Chunk<A>) => Effect.Effect<R, E2, _>
-  ) => <E>(self: Take.Take<E, A>) => Effect.Effect<R, E2 | E, void>,
-  <E, A, R, E2, _>(
-    self: Take.Take<E, A>,
-    f: (chunk: Chunk.Chunk<A>) => Effect.Effect<R, E2, _>
-  ) => Effect.Effect<R, E2 | E, void>
->(2, <E, A, R, E2, _>(
-  self: Take.Take<E, A>,
-  f: (chunk: Chunk.Chunk<A>) => Effect.Effect<R, E2, _>
-): Effect.Effect<R, E | E2, void> => pipe(self.exit, Exit.forEachEffect(f), Effect.asUnit))
+  <A, _, E2, R>(
+    f: (chunk: Chunk.Chunk<A>) => Effect.Effect<_, E2, R>
+  ) => <E>(self: Take.Take<A, E>) => Effect.Effect<void, E2 | E, R>,
+  <A, E, _, E2, R>(
+    self: Take.Take<A, E>,
+    f: (chunk: Chunk.Chunk<A>) => Effect.Effect<_, E2, R>
+  ) => Effect.Effect<void, E2 | E, R>
+>(2, <A, E, _, E2, R>(
+  self: Take.Take<A, E>,
+  f: (chunk: Chunk.Chunk<A>) => Effect.Effect<_, E2, R>
+): Effect.Effect<void, E2 | E, R> => pipe(self.exit, Exit.forEachEffect(f), Effect.asUnit))

package/src/internal/testing/sleep.ts

@@ -11,14 +11,14 @@ import type * as FiberId from "../../FiberId.js"
  */
 export interface Sleep {
   readonly duration: Duration.Duration
-  readonly deferred: Deferred.Deferred<never, void>
+  readonly deferred: Deferred.Deferred<void>
   readonly fiberId: FiberId.FiberId
 }
 
 /** @internal */
 export const make = (
   duration: Duration.Duration,
-  deferred: Deferred.Deferred<never, void>,
+  deferred: Deferred.Deferred<void>,
   fiberId: FiberId.FiberId
 ): Sleep => ({
   duration,

package/src/internal/testing/suspendedWarningData.ts

@@ -29,7 +29,7 @@ export interface Start {
 /** @internal */
 export interface Pending {
   readonly _tag: OP_SUSPENDED_WARNING_DATA_PENDING
-  readonly fiber: Fiber.Fiber<Error, void>
+  readonly fiber: Fiber.Fiber<void, Error>
 }
 
 /** @internal */
@@ -53,7 +53,7 @@ export const start: SuspendedWarningData = {
  *
  * @internal
  */
-export const pending = (fiber: Fiber.Fiber<Error, void>): SuspendedWarningData => {
+export const pending = (fiber: Fiber.Fiber<void, Error>): SuspendedWarningData => {
   return {
     _tag: OP_SUSPENDED_WARNING_DATA_PENDING,
     fiber

package/src/internal/testing/warningData.ts

@@ -37,7 +37,7 @@ export interface Start {
 /** @internal */
 export interface Pending {
   readonly _tag: OP_WARNING_DATA_PENDING
-  readonly fiber: Fiber.Fiber<Error, void>
+  readonly fiber: Fiber.Fiber<void, Error>
 }
 
 /** @internal */
@@ -61,7 +61,7 @@ export const start: WarningData = {
  *
  * @internal
  */
-export const pending = (fiber: Fiber.Fiber<Error, void>): WarningData => {
+export const pending = (fiber: Fiber.Fiber<void, Error>): WarningData => {
   return {
     _tag: OP_WARNING_DATA_PENDING,
     fiber

package/src/internal/tracer.ts

@@ -18,14 +18,10 @@ export const make = (options: Omit<Tracer.Tracer, Tracer.TracerTypeId>): Tracer.
 })
 
 /** @internal */
-export const tracerTag = Context.Tag<Tracer.Tracer>(
-  Symbol.for("effect/Tracer")
-)
+export const tracerTag = Context.GenericTag<Tracer.Tracer>("effect/Tracer")
 
 /** @internal */
-export const spanTag = Context.Tag<Tracer.ParentSpan>(
-  Symbol.for("effect/ParentSpan")
-)
+export const spanTag = Context.GenericTag<Tracer.ParentSpan>("effect/ParentSpan")
 
 const ids = globalValue("effect/Tracer/SpanId.ids", () => MutableRef.make(0))
 

package/src/internal/version.ts

@@ -1 +1 @@
-export const moduleVersion = "2.2.5"
+export const moduleVersion = "2.3.1"