effect 2.2.5 → 2.3.0

package/src/internal/stream/debounceState.ts

@@ -3,7 +3,7 @@ import type * as Fiber from "../../Fiber.js"
 import type * as HandoffSignal from "./handoffSignal.js"
 
 /** @internal */
-export type DebounceState<E, A> = NotStarted | Previous<A> | Current<E, A>
+export type DebounceState<A, E = never> = NotStarted | Previous<A> | Current<A, E>
 
 /** @internal */
 export const OP_NOT_STARTED = "NotStarted" as const
@@ -30,28 +30,28 @@ export interface NotStarted {
 /** @internal */
 export interface Previous<out A> {
   readonly _tag: OP_PREVIOUS
-  readonly fiber: Fiber.Fiber<never, Chunk.Chunk<A>>
+  readonly fiber: Fiber.Fiber<Chunk.Chunk<A>>
 }
 
 /** @internal */
-export interface Current<out E, out A> {
+export interface Current<out A, out E = never> {
   readonly _tag: OP_CURRENT
-  readonly fiber: Fiber.Fiber<E, HandoffSignal.HandoffSignal<E, A>>
+  readonly fiber: Fiber.Fiber<HandoffSignal.HandoffSignal<A, E>, E>
 }
 
 /** @internal */
-export const notStarted: DebounceState<never, never> = {
+export const notStarted: DebounceState<never> = {
   _tag: OP_NOT_STARTED
 }
 
 /** @internal */
-export const previous = <A>(fiber: Fiber.Fiber<never, Chunk.Chunk<A>>): DebounceState<never, A> => ({
+export const previous = <A>(fiber: Fiber.Fiber<Chunk.Chunk<A>>): DebounceState<A> => ({
   _tag: OP_PREVIOUS,
   fiber
 })
 
 /** @internal */
-export const current = <E, A>(fiber: Fiber.Fiber<E, HandoffSignal.HandoffSignal<E, A>>): DebounceState<E, A> => ({
+export const current = <A, E>(fiber: Fiber.Fiber<HandoffSignal.HandoffSignal<A, E>, E>): DebounceState<A, E> => ({
   _tag: OP_CURRENT,
   fiber
 })

package/src/internal/stream/emit.ts

@@ -8,7 +8,7 @@ import type * as Emit from "../../StreamEmit.js"
 
 /** @internal */
 export const make = <R, E, A, B>(
-  emit: (f: Effect.Effect<R, Option.Option<E>, Chunk.Chunk<A>>) => Promise<B>
+  emit: (f: Effect.Effect<Chunk.Chunk<A>, Option.Option<E>, R>) => Promise<B>
 ): Emit.Emit<R, E, A, B> => {
   const ops: Emit.EmitOps<R, E, A, B> = {
     chunk(this: Emit.Emit<R, E, A, B>, as: Chunk.Chunk<A>) {
@@ -20,7 +20,7 @@ export const make = <R, E, A, B>(
     dieMessage(this: Emit.Emit<R, E, A, B>, message: string) {
       return this(Effect.dieMessage(message))
     },
-    done(this: Emit.Emit<R, E, A, B>, exit: Exit.Exit<E, A>) {
+    done(this: Emit.Emit<R, E, A, B>, exit: Exit.Exit<A, E>) {
       return this(Effect.suspend(() => Exit.mapBoth(exit, { onFailure: Option.some, onSuccess: Chunk.of })))
     },
     end(this: Emit.Emit<R, E, A, B>) {
@@ -29,10 +29,10 @@ export const make = <R, E, A, B>(
     fail(this: Emit.Emit<R, E, A, B>, e: E) {
       return this(Effect.fail(Option.some(e)))
     },
-    fromEffect(this: Emit.Emit<R, E, A, B>, effect: Effect.Effect<R, E, A>) {
+    fromEffect(this: Emit.Emit<R, E, A, B>, effect: Effect.Effect<A, E, R>) {
       return this(Effect.mapBoth(effect, { onFailure: Option.some, onSuccess: Chunk.of }))
     },
-    fromEffectChunk(this: Emit.Emit<R, E, A, B>, effect: Effect.Effect<R, E, Chunk.Chunk<A>>) {
+    fromEffectChunk(this: Emit.Emit<R, E, A, B>, effect: Effect.Effect<Chunk.Chunk<A>, E, R>) {
       return this(pipe(effect, Effect.mapError(Option.some)))
     },
     halt(this: Emit.Emit<R, E, A, B>, cause: Cause.Cause<E>) {

package/src/internal/stream/handoff.ts

@@ -48,25 +48,25 @@ export declare namespace Handoff {
   /** @internal */
   export interface Empty {
     readonly _tag: OP_HANDOFF_STATE_EMPTY
-    readonly notifyConsumer: Deferred.Deferred<never, void>
+    readonly notifyConsumer: Deferred.Deferred<void>
   }
 
   /** @internal */
   export interface Full<out A> {
     readonly _tag: OP_HANDOFF_STATE_FULL
     readonly value: A
-    readonly notifyProducer: Deferred.Deferred<never, void>
+    readonly notifyProducer: Deferred.Deferred<void>
   }
 }
 
 /** @internal */
-const handoffStateEmpty = <A>(notifyConsumer: Deferred.Deferred<never, void>): Handoff.State<A> => ({
+const handoffStateEmpty = <A>(notifyConsumer: Deferred.Deferred<void>): Handoff.State<A> => ({
   _tag: OP_HANDOFF_STATE_EMPTY,
   notifyConsumer
 })
 
 /** @internal */
-const handoffStateFull = <A>(value: A, notifyProducer: Deferred.Deferred<never, void>): Handoff.State<A> => ({
+const handoffStateFull = <A>(value: A, notifyProducer: Deferred.Deferred<void>): Handoff.State<A> => ({
   _tag: OP_HANDOFF_STATE_FULL,
   value,
   notifyProducer
@@ -74,8 +74,8 @@ const handoffStateFull = <A>(value: A, notifyProducer: Deferred.Deferred<never,
 
 /** @internal */
 const handoffStateMatch = <A, Z>(
-  onEmpty: (notifyConsumer: Deferred.Deferred<never, void>) => Z,
-  onFull: (value: A, notifyProducer: Deferred.Deferred<never, void>) => Z
+  onEmpty: (notifyConsumer: Deferred.Deferred<void>) => Z,
+  onFull: (value: A, notifyProducer: Deferred.Deferred<void>) => Z
 ) => {
   return (self: Handoff.State<A>): Z => {
     switch (self._tag) {
@@ -95,9 +95,9 @@ const handoffVariance = {
 }
 
 /** @internal */
-export const make = <A>(): Effect.Effect<never, never, Handoff<A>> =>
+export const make = <A>(): Effect.Effect<Handoff<A>> =>
   pipe(
-    Deferred.make<never, void>(),
+    Deferred.make<void>(),
     Effect.flatMap((deferred) => Ref.make(handoffStateEmpty<A>(deferred))),
     Effect.map((ref): Handoff<A> => ({
       [HandoffTypeId]: handoffVariance,
@@ -107,10 +107,10 @@ export const make = <A>(): Effect.Effect<never, never, Handoff<A>> =>
 
 /** @internal */
 export const offer = dual<
-  <A>(value: A) => (self: Handoff<A>) => Effect.Effect<never, never, void>,
-  <A>(self: Handoff<A>, value: A) => Effect.Effect<never, never, void>
->(2, (self, value): Effect.Effect<never, never, void> => {
-  return Effect.flatMap(Deferred.make<never, void>(), (deferred) =>
+  <A>(value: A) => (self: Handoff<A>) => Effect.Effect<void>,
+  <A>(self: Handoff<A>, value: A) => Effect.Effect<void>
+>(2, (self, value): Effect.Effect<void> => {
+  return Effect.flatMap(Deferred.make<void>(), (deferred) =>
     Effect.flatten(
       Ref.modify(self.ref, (state) =>
         pipe(
@@ -118,7 +118,7 @@ export const offer = dual<
           handoffStateMatch(
             (notifyConsumer) => [
               Effect.zipRight(
-                Deferred.succeed<never, void>(notifyConsumer, void 0),
+                Deferred.succeed(notifyConsumer, void 0),
                 Deferred.await(deferred)
               ),
               handoffStateFull(value, deferred)
@@ -136,8 +136,8 @@ export const offer = dual<
 })
 
 /** @internal */
-export const take = <A>(self: Handoff<A>): Effect.Effect<never, never, A> =>
-  Effect.flatMap(Deferred.make<never, void>(), (deferred) =>
+export const take = <A>(self: Handoff<A>): Effect.Effect<A> =>
+  Effect.flatMap(Deferred.make<void>(), (deferred) =>
     Effect.flatten(
       Ref.modify(self.ref, (state) =>
         pipe(
@@ -153,7 +153,7 @@ export const take = <A>(self: Handoff<A>): Effect.Effect<never, never, A> =>
               ] as const,
             (value, notifyProducer) => [
               Effect.as(
-                Deferred.succeed<never, void>(notifyProducer, void 0),
+                Deferred.succeed(notifyProducer, void 0),
                 value
               ),
               handoffStateEmpty<A>(deferred)
@@ -163,8 +163,8 @@ export const take = <A>(self: Handoff<A>): Effect.Effect<never, never, A> =>
     ))
 
 /** @internal */
-export const poll = <A>(self: Handoff<A>): Effect.Effect<never, never, Option.Option<A>> =>
-  Effect.flatMap(Deferred.make<never, void>(), (deferred) =>
+export const poll = <A>(self: Handoff<A>): Effect.Effect<Option.Option<A>> =>
+  Effect.flatMap(Deferred.make<void>(), (deferred) =>
     Effect.flatten(
       Ref.modify(self.ref, (state) =>
         pipe(
@@ -177,7 +177,7 @@ export const poll = <A>(self: Handoff<A>): Effect.Effect<never, never, Option.Op
               ] as const,
             (value, notifyProducer) => [
               Effect.as(
-                Deferred.succeed<never, void>(notifyProducer, void 0),
+                Deferred.succeed(notifyProducer, void 0),
                 Option.some(value)
               ),
               handoffStateEmpty<A>(deferred)

package/src/internal/stream/handoffSignal.ts

@@ -3,7 +3,7 @@ import type * as Chunk from "../../Chunk.js"
 import type * as SinkEndReason from "./sinkEndReason.js"
 
 /** @internal */
-export type HandoffSignal<E, A> = Emit<A> | Halt<E> | End
+export type HandoffSignal<A, E = never> = Emit<A> | Halt<E> | End
 
 /** @internal */
 export const OP_EMIT = "Emit" as const
@@ -41,19 +41,19 @@ export interface End {
 }
 
 /** @internal */
-export const emit = <A>(elements: Chunk.Chunk<A>): HandoffSignal<never, A> => ({
+export const emit = <A>(elements: Chunk.Chunk<A>): HandoffSignal<A> => ({
   _tag: OP_EMIT,
   elements
 })
 
 /** @internal */
-export const halt = <E>(cause: Cause.Cause<E>): HandoffSignal<E, never> => ({
+export const halt = <E>(cause: Cause.Cause<E>): HandoffSignal<never, E> => ({
   _tag: OP_HALT,
   cause
 })
 
 /** @internal */
-export const end = (reason: SinkEndReason.SinkEndReason): HandoffSignal<never, never> => ({
+export const end = (reason: SinkEndReason.SinkEndReason): HandoffSignal<never> => ({
   _tag: OP_END,
   reason
 })

package/src/internal/stream/pull.ts

@@ -7,29 +7,28 @@ import type * as Take from "../../Take.js"
 import * as take from "../take.js"
 
 /** @internal */
-export interface Pull<out R, out E, out A> extends Effect.Effect<R, Option.Option<E>, Chunk.Chunk<A>> {}
+export interface Pull<out R, out E, out A> extends Effect.Effect<Chunk.Chunk<A>, Option.Option<E>, R> {}
 
 /** @internal */
-export const emit = <A>(value: A): Effect.Effect<never, never, Chunk.Chunk<A>> => Effect.succeed(Chunk.of(value))
+export const emit = <A>(value: A): Effect.Effect<Chunk.Chunk<A>> => Effect.succeed(Chunk.of(value))
 
 /** @internal */
-export const emitChunk = <A>(chunk: Chunk.Chunk<A>): Effect.Effect<never, never, Chunk.Chunk<A>> =>
-  Effect.succeed(chunk)
+export const emitChunk = <A>(chunk: Chunk.Chunk<A>): Effect.Effect<Chunk.Chunk<A>> => Effect.succeed(chunk)
 
 /** @internal */
-export const empty = <A>(): Effect.Effect<never, never, Chunk.Chunk<A>> => Effect.succeed(Chunk.empty<A>())
+export const empty = <A>(): Effect.Effect<Chunk.Chunk<A>> => Effect.succeed(Chunk.empty<A>())
 
 /** @internal */
-export const end = (): Effect.Effect<never, Option.Option<never>, never> => Effect.fail(Option.none())
+export const end = (): Effect.Effect<never, Option.Option<never>> => Effect.fail(Option.none())
 
 /** @internal */
-export const fail = <E>(error: E): Effect.Effect<never, Option.Option<E>, never> => Effect.fail(Option.some(error))
+export const fail = <E>(error: E): Effect.Effect<never, Option.Option<E>> => Effect.fail(Option.some(error))
 
 /** @internal */
-export const failCause = <E>(cause: Cause.Cause<E>): Effect.Effect<never, Option.Option<E>, never> =>
+export const failCause = <E>(cause: Cause.Cause<E>): Effect.Effect<never, Option.Option<E>> =>
   Effect.mapError(Effect.failCause(cause), Option.some)
 
 /** @internal */
-export const fromDequeue = <E, A>(
-  dequeue: Queue.Dequeue<Take.Take<E, A>>
-): Effect.Effect<never, Option.Option<E>, Chunk.Chunk<A>> => Effect.flatMap(Queue.take(dequeue), take.done)
+export const fromDequeue = <A, E>(
+  dequeue: Queue.Dequeue<Take.Take<A, E>>
+): Effect.Effect<Chunk.Chunk<A>, Option.Option<E>> => Effect.flatMap(Queue.take(dequeue), take.done)