@typed/fx 1.22.2 → 1.24.0

package/src/Pull.ts

@@ -19,28 +19,27 @@ import type { Sink } from "./Sink.js"
  * An Effect which can be used to pull values of a Stream.
  * @since 1.18.0
  */
-export interface Pull<out R, out E, out A> extends Effect.Effect<R, Option.Option<E>, Chunk.Chunk<A>> {}
+export interface Pull<out A, out E = never, out R = never> extends Effect.Effect<Chunk.Chunk<A>, Option.Option<E>, R> {}
 
-function schedulePull<R, E, A, R2, R3>(
-  pull: Pull<R, E, A>,
-  f: (effect: Effect.Effect<R | R3, never, unknown>) => Effect.Effect<R2, never, unknown>,
-  sink: Sink<R3, E, A>
-): Effect.Effect<R2, never, void> {
-  return Effect.asyncEffect((resume) =>
-    pull.pipe(
-      Effect.matchCauseEffect({
-        onFailure: (cause: Cause.Cause<Option.Option<E>>) =>
-          Cause.failureOrCause(cause).pipe(
-            Either.match({
-              onLeft: Option.match({
-                onNone: () => Effect.sync(() => resume(Effect.unit)),
-                onSome: (e: E) => sink.onFailure(Cause.fail(e))
-              }),
-              onRight: sink.onFailure
-            })
-          ),
-        onSuccess: (chunk) => Effect.forEach(chunk, sink.onSuccess)
-      }),
+function schedulePull<A, E, R, R2, R3>(
+  pull: Pull<A, E, R>,
+  f: (effect: Effect.Effect<unknown, never, R | R3>) => Effect.Effect<unknown, never, R2>,
+  sink: Sink<A, E, R3>
+): Effect.Effect<void, never, R2> {
+  return Effect.asyncEffect<void, never, never, void, never, R2>((resume) =>
+    Effect.matchCauseEffect(pull, {
+      onFailure: (cause: Cause.Cause<Option.Option<E>>) =>
+        Cause.failureOrCause(cause).pipe(
+          Either.match({
+            onLeft: Option.match({
+              onNone: () => Effect.sync(() => resume(Effect.unit)),
+              onSome: (e: E) => sink.onFailure(Cause.fail(e))
+            }),
+            onRight: sink.onFailure
+          })
+        ),
+      onSuccess: (chunk: Chunk.Chunk<A>) => Effect.forEach(chunk, sink.onSuccess, { discard: true })
+    }).pipe(
       f,
       Effect.flatMap(() => Effect.sync(() => resume(Effect.unit)))
     )
@@ -53,21 +52,21 @@ function schedulePull<R, E, A, R2, R3>(
  * @since 1.18.0
  */
 export const schedule: {
-  <R2, R3, E, A>(
+  <R2, A, E, R3>(
     schedule: Schedule.Schedule<R2, unknown, unknown>,
-    sink: Sink<R3, E, A>
-  ): <R>(pull: Pull<R, E, A>) => Effect.Effect<R | R2 | R3, never, unknown>
+    sink: Sink<A, E, R3>
+  ): <R>(pull: Pull<A, E, R>) => Effect.Effect<unknown, never, R | R2 | R3>
 
-  <R, E, A, R2, R3>(
-    pull: Pull<R, E, A>,
+  <A, E, R, R2, R3>(
+    pull: Pull<A, E, R>,
     schedule: Schedule.Schedule<R2, unknown, unknown>,
-    sink: Sink<R3, E, A>
-  ): Effect.Effect<R | R2 | R3, never, unknown>
-} = dual(3, function schedule<R, E, A, R2, R3>(
-  pull: Pull<R, E, A>,
+    sink: Sink<A, E, R3>
+  ): Effect.Effect<unknown, never, R | R2 | R3>
+} = dual(3, function schedule<A, E, R, R2, R3>(
+  pull: Pull<A, E, R>,
   schedule: Schedule.Schedule<R2, unknown, unknown>,
-  sink: Sink<R3, E, A>
-): Effect.Effect<R | R2 | R3, never, void> {
+  sink: Sink<A, E, R3>
+): Effect.Effect<void, never, R | R2 | R3> {
   return schedulePull(pull, Effect.schedule(schedule), sink)
 })
 
@@ -77,20 +76,20 @@ export const schedule: {
  * @since 1.18.0
  */
 export const repeat: {
-  <R2, R3, E, A>(
+  <R2, A, E, R3>(
     schedule: Schedule.Schedule<R2, unknown, unknown>,
-    sink: Sink<R3, E, A>
-  ): <R>(pull: Pull<R, E, A>) => Effect.Effect<R | R2 | R3, never, unknown>
+    sink: Sink<A, E, R3>
+  ): <R>(pull: Pull<A, E, R>) => Effect.Effect<unknown, never, R | R2 | R3>
 
-  <R, E, A, R2, R3>(
-    pull: Pull<R, E, A>,
+  <A, E, R, R2, R3>(
+    pull: Pull<A, E, R>,
     schedule: Schedule.Schedule<R2, unknown, unknown>,
-    sink: Sink<R3, E, A>
-  ): Effect.Effect<R | R2 | R3, never, unknown>
-} = dual(3, function repeat<R, E, A, R2, R3>(
-  pull: Pull<R, E, A>,
+    sink: Sink<A, E, R3>
+  ): Effect.Effect<unknown, never, R | R2 | R3>
+} = dual(3, function repeat<A, E, R, R2, R3>(
+  pull: Pull<A, E, R>,
   schedule: Schedule.Schedule<R2, unknown, unknown>,
-  sink: Sink<R3, E, A>
-): Effect.Effect<R | R2 | R3, never, void> {
+  sink: Sink<A, E, R3>
+): Effect.Effect<void, never, R | R2 | R3> {
   return schedulePull(pull, Effect.repeat(schedule), sink)
 })