@fncts/io 0.0.2 → 0.0.5

package/_src/Stream/api.ts

@@ -12,7 +12,8 @@ import { DEFAULT_CHUNK_SIZE, Stream } from "./definition.js";
 import { DebounceState } from "./internal/DebounceState.js";
 import { Handoff, HandoffSignal } from "./internal/Handoff.js";
 import { Pull } from "./internal/Pull.js";
-import { ScheduleEnd, ScheduleTimeout, SinkEnd, UpstreamEnd } from "./internal/SinkEndReason.js";
+import { SinkEndReasonTag } from "./internal/SinkEndReason.js";
+import { ScheduleEnd, UpstreamEnd } from "./internal/SinkEndReason.js";
 import { Take } from "./internal/Take.js";
 
 /**
@@ -77,17 +78,17 @@ export function aggregateAsyncWithinEither_<R, E, A extends A1, R1, E1, A1, B, R
   sink: Sink<R1, E1, A1, A1, B>,
   schedule: Schedule<R2, Maybe<B>, C>,
 ): Stream<R & R1 & R2, E | E1, Either<C, B>> {
-  type LocalHandoffSignal = HandoffSignal<C, E | E1, A1>;
-  type LocalSinkEndReason = SinkEndReason<C>;
+  type LocalHandoffSignal = HandoffSignal<E | E1, A1>;
 
   const deps = IO.sequenceT(
     Handoff<LocalHandoffSignal>(),
-    Ref.make<LocalSinkEndReason>(new SinkEnd()),
+    Ref.make<SinkEndReason>(new ScheduleEnd()),
     Ref.make(Conc.empty<A1>()),
     schedule.driver,
+    Ref.make(false),
   );
 
-  return Stream.fromIO(deps).flatMap(([handoff, sinkEndReason, sinkLeftovers, scheduleDriver]) => {
+  return Stream.fromIO(deps).flatMap(([handoff, sinkEndReason, sinkLeftovers, scheduleDriver, consumed]) => {
     const handoffProducer: Channel<unknown, E | E1, Conc<A1>, unknown, never, never, any> = Channel.readWithCause(
       (_in: Conc<A1>) => Channel.fromIO(handoff.offer(HandoffSignal.Emit(_in))).apSecond(handoffProducer),
       (cause: Cause<E | E1>) => Channel.fromIO(handoff.offer(HandoffSignal.Halt(cause))),
@@ -96,62 +97,102 @@ export function aggregateAsyncWithinEither_<R, E, A extends A1, R1, E1, A1, B, R
 
     const handoffConsumer: Channel<unknown, unknown, unknown, unknown, E | E1, Conc<A1>, void> = Channel.unwrap(
       sinkLeftovers.getAndSet(Conc.empty<A>()).flatMap((leftovers) => {
-        if (leftovers.isEmpty) {
-          return IO.succeedNow(Channel.writeNow(leftovers).apSecond(handoffConsumer));
+        if (leftovers.isNonEmpty) {
+          return consumed.set(true) > IO.succeedNow(Channel.writeNow(leftovers) > handoffConsumer);
         } else {
           return handoff.take.map((signal) =>
             signal.match({
-              Emit: ({ els }) => Channel.writeNow(els).apSecond(handoffConsumer),
+              Emit: ({ els }) => Channel.fromIO(consumed.set(true)) > Channel.writeNow(els) > handoffConsumer,
               Halt: ({ error }) => Channel.failCause(error),
-              End: ({ reason }) => Channel.fromIO(sinkEndReason.set(reason)),
+              End: ({ reason }) => {
+                if (reason._tag === SinkEndReasonTag.ScheduleEnd) {
+                  return Channel.unwrap(
+                    consumed.get.map((p) =>
+                      p
+                        ? Channel.fromIO(sinkEndReason.set(new ScheduleEnd()))
+                        : Channel.fromIO(sinkEndReason.set(new ScheduleEnd())) > handoffConsumer,
+                    ),
+                  );
+                } else {
+                  return Channel.fromIO(sinkEndReason.set(reason));
+                }
+              },
             }),
           );
         }
       }),
     );
 
+    function timeout(lastB: Maybe<B>): IO<R2, Nothing, C> {
+      return scheduleDriver.next(lastB);
+    }
+
     const scheduledAggregator = (
-      lastB: Maybe<B>,
+      sinkFiber: Fiber.Runtime<E | E1, readonly [Conc<Conc<A1>>, B]>,
+      scheduleFiber: Fiber.Runtime<Nothing, C>,
     ): Channel<R1 & R2, unknown, unknown, unknown, E | E1, Conc<Either<C, B>>, any> => {
-      const timeout = scheduleDriver.next(lastB).matchCauseIO(
-        (_) =>
-          _.failureOrCause.match(
-            () => handoff.offer(HandoffSignal.End(new ScheduleTimeout())),
-            (cause) => handoff.offer(HandoffSignal.Halt(cause)),
-          ),
-        (c) => handoff.offer(HandoffSignal.End(new ScheduleEnd(c))),
-      );
+      const forkSink =
+        consumed.set(false) > handoffConsumer.pipeToOrFail(sink.channel).doneCollect.runScoped.forkScoped;
+
+      function handleSide(leftovers: Conc<Conc<A1>>, b: B, c: Maybe<C>) {
+        return Channel.unwrap(
+          sinkLeftovers.set(leftovers.flatten) >
+            sinkEndReason.get.map((reason) =>
+              reason.match({
+                ScheduleEnd: () =>
+                  Channel.unwrapScoped(
+                    Do((Δ) => {
+                      const consumed_     = Δ(consumed.get);
+                      const sinkFiber     = Δ(forkSink);
+                      const scheduleFiber = Δ(timeout(Just(b)).forkScoped);
+                      const toWrite       = c.match(
+                        () => Conc(Either.right(b)),
+                        (c) => Conc(Either.right(b), Either.left(c)),
+                      );
+                      return consumed_
+                        ? Channel.write(toWrite) > scheduledAggregator(sinkFiber, scheduleFiber)
+                        : scheduledAggregator(sinkFiber, scheduleFiber);
+                    }),
+                  ),
+                UpstreamEnd: () =>
+                  Channel.unwrap(consumed.get.map((p) => (p ? Channel.write(Conc(Either.right(b))) : Channel.unit))),
+              }),
+            ),
+        );
+      }
 
-      return Channel.unwrapScoped(
-        timeout.forkScoped.map((fiber) => {
-          return handoffConsumer.pipeToOrFail(sink.channel).doneCollect.flatMap(([leftovers, b]) => {
-            return Channel.fromIO(fiber.interrupt.apSecond(sinkLeftovers.set(leftovers.flatten))).apSecond(
-              Channel.unwrap(
-                sinkEndReason.modify((reason) =>
-                  reason.match({
-                    ScheduleEnd: ({ c }) =>
-                      tuple(Channel.writeNow(Conc.from([Either.right(b), Either.left(c)])).as(Just(b)), new SinkEnd()),
-                    ScheduleTimeout: () =>
-                      tuple(Channel.writeNow(Conc.single(Either.right(b))).as(Just(b)), new SinkEnd()),
-                    SinkEnd: () => tuple(Channel.writeNow(Conc.single(Either.right(b))).as(Just(b)), new SinkEnd()),
-                    UpstreamEnd: () =>
-                      tuple(Channel.writeNow(Conc.single(Either.right(b))).as(Nothing()), new UpstreamEnd()),
-                  }),
+      return Channel.unwrap(
+        sinkFiber.join.raceWith(
+          scheduleFiber.join,
+          (sinkExit, scheduleFiber) =>
+            scheduleFiber.interrupt >
+            IO.fromExit(sinkExit).map(([leftovers, b]) => handleSide(leftovers, b, Nothing())),
+          (scheduleExit, sinkFiber) =>
+            IO.fromExit(scheduleExit).matchCauseIO(
+              (cause) =>
+                cause.failureOrCause.match(
+                  () =>
+                    handoff.offer(HandoffSignal.End(new ScheduleEnd())).forkDaemon >
+                    sinkFiber.join.map(([leftovers, b]) => handleSide(leftovers, b, Nothing())),
+                  (cause) =>
+                    handoff.offer(HandoffSignal.Halt(cause)).forkDaemon >
+                    sinkFiber.join.map(([leftovers, b]) => handleSide(leftovers, b, Nothing())),
                 ),
-              ),
-            );
-          });
-        }),
-      ).flatMap((_) =>
-        _.match(
-          () => Channel.unit,
-          () => scheduledAggregator(_),
+              (c) =>
+                handoff.offer(HandoffSignal.End(new ScheduleEnd())).forkDaemon >
+                sinkFiber.join.map(([leftovers, b]) => handleSide(leftovers, b, Just(c))),
+            ),
         ),
       );
     };
 
-    return Stream.scoped(stream.channel.pipeTo(handoffProducer).runScoped.forkDaemon).apSecond(
-      new Stream(scheduledAggregator(Nothing())),
+    return Stream.unwrapScoped(
+      Do((Δ) => {
+        Δ(stream.channel.pipeTo(handoffProducer).runScoped.forkScoped);
+        const sinkFiber     = Δ(handoffConsumer.pipeToOrFail(sink.channel).doneCollect.runScoped.forkScoped);
+        const scheduleFiber = Δ(timeout(Nothing()).forkScoped);
+        return new Stream(scheduledAggregator(sinkFiber, scheduleFiber));
+      }),
     );
   });
 }
@@ -669,23 +710,28 @@ export function collectWhileIO_<R, E, A, R1, E1, B>(
   stream: Stream<R, E, A>,
   pf: (a: A) => Maybe<IO<R1, E1, B>>,
 ): Stream<R & R1, E | E1, B> {
-  return stream.loopOnPartialChunks((chunk, emit) => {
-    const pfJust = (a: A) =>
-      pf(a).match(
-        () => IO.succeedNow(false),
-        (effect) => effect.flatMap(emit).as(true),
-      );
-
-    const loop = (chunk: Conc<A>): IO<R1, E1, boolean> => {
-      if (chunk.isEmpty) {
-        return IO.succeedNow(true);
-      } else {
-        return pfJust(chunk.unsafeHead).flatMap((cont) => (cont ? loop(chunk.unsafeTail) : IO.succeedNow(false)));
-      }
-    };
+  return new Stream(stream.channel.pipeTo(collectWhileIOLoop(Iterable.empty<A>()[Symbol.iterator](), pf)));
+}
 
-    return loop(chunk);
-  });
+function collectWhileIOLoop<R, E, A, R1, E1, B>(
+  iterator: Iterator<A>,
+  pf: (a: A) => Maybe<IO<R1, E1, B>>,
+): Channel<R & R1, E, Conc<A>, unknown, E | E1, Conc<B>, unknown> {
+  const next = iterator.next();
+  if (next.done) {
+    return Channel.readWithCause(
+      (elem) => collectWhileIOLoop(elem[Symbol.iterator](), pf),
+      Channel.failCauseNow,
+      Channel.succeedNow,
+    );
+  } else {
+    return Channel.unwrap(
+      pf(next.value).match(
+        () => IO.succeedNow(Channel.unit),
+        (b) => b.map((b) => Channel.writeNow(Conc.single(b)) > collectWhileIOLoop<R, E, A, R1, E1, B>(iterator, pf)),
+      ),
+    );
+  }
 }
 
 function combineProducer<Err, Elem>(
@@ -857,11 +903,11 @@ export function contramapEnvironment_<R, E, A, R0>(
 /**
  * @tsplus fluent fncts.io.Stream debounce
  */
-export function debounce_<R, E, A>(stream: Stream<R, E, A>, duration: number): Stream<R, E, A> {
+export function debounce_<R, E, A>(stream: Stream<R, E, A>, duration: Lazy<Duration>): Stream<R, E, A> {
   return Stream.unwrap(
     IO.transplant((grafter) =>
       Do((Δ) => {
-        const handoff = Δ(Handoff<HandoffSignal<void, E, A>>());
+        const handoff = Δ(Handoff<HandoffSignal<E, A>>());
         function enqueue(last: Conc<A>) {
           return grafter(Clock.sleep(duration).as(last).fork).map((f) => consumer(DebounceState.Previous(f)));
         }
@@ -1274,7 +1320,29 @@ export function filterIO_<R, E, A, R1, E1>(
   fa: Stream<R, E, A>,
   f: (a: A) => IO<R1, E1, boolean>,
 ): Stream<R & R1, E | E1, A> {
-  return fa.loopOnPartialChunksElements((a, emit) => f(a).flatMap((r) => (r ? emit(a) : IO.unit)));
+  return new Stream(fa.channel.pipeTo(filterIOLoop(Iterable.empty<A>()[Symbol.iterator](), f)));
+}
+
+function filterIOLoop<R, E, A, R1, E1>(
+  iterator: Iterator<A>,
+  f: (a: A) => IO<R1, E1, boolean>,
+): Channel<R & R1, E, Conc<A>, unknown, E | E1, Conc<A>, unknown> {
+  const next = iterator.next();
+  if (next.done) {
+    return Channel.readWithCause(
+      (elem) => filterIOLoop(elem[Symbol.iterator](), f),
+      Channel.failCauseNow,
+      Channel.succeedNow,
+    );
+  } else {
+    return Channel.unwrap(
+      f(next.value).map((b) =>
+        b
+          ? Channel.writeNow(Conc.single(next.value)) > filterIOLoop<R, E, A, R1, E1>(iterator, f)
+          : filterIOLoop<R, E, A, R1, E1>(iterator, f),
+      ),
+    );
+  }
 }
 
 /**
@@ -1291,7 +1359,30 @@ export function filterMapIO_<R, E, A, R1, E1, B>(
   fa: Stream<R, E, A>,
   f: (a: A) => IO<R1, E1, Maybe<B>>,
 ): Stream<R & R1, E | E1, B> {
-  return fa.loopOnPartialChunksElements((a, emit) => f(a).flatMap((maybeB) => maybeB.match(() => IO.unit, emit)));
+  return new Stream(fa.channel.pipeTo(filterMapIOLoop<R, E, A, R1, E1, B>(Iterable.empty<A>()[Symbol.iterator](), f)));
+}
+
+function filterMapIOLoop<R, E, A, R1, E1, B>(
+  iterator: Iterator<A>,
+  f: (a: A) => IO<R1, E1, Maybe<B>>,
+): Channel<R & R1, E, Conc<A>, unknown, E | E1, Conc<B>, unknown> {
+  const next = iterator.next();
+  if (next.done) {
+    return Channel.readWithCause(
+      (elem) => filterMapIOLoop(elem[Symbol.iterator](), f),
+      Channel.failCauseNow,
+      Channel.succeedNow,
+    );
+  } else {
+    return Channel.unwrap(
+      f(next.value).map((b) =>
+        b.match(
+          () => filterMapIOLoop(iterator, f),
+          (b) => Channel.writeNow(Conc.single(b)) > filterMapIOLoop<R, E, A, R1, E1, B>(iterator, f),
+        ),
+      ),
+    );
+  }
 }
 
 /**
@@ -1788,68 +1879,6 @@ export function interruptWhenFuture_<R, E, A, E1>(
   return new Stream(fa.channel.interruptWhen(future));
 }
 
-/**
- * Loops over the stream chunks concatenating the result of f
- *
- * @tsplus fluent fncts.io.Stream loopOnChunks
- */
-export function loopOnChunks_<R, E, A, R1, E1, A1>(
-  stream: Stream<R, E, A>,
-  f: (a: Conc<A>) => Channel<R1, E | E1, Conc<A>, unknown, E | E1, Conc<A1>, boolean>,
-): Stream<R & R1, E | E1, A1> {
-  const loop: Channel<R1, E | E1, Conc<A>, unknown, E | E1, Conc<A1>, boolean> = Channel.readWithCause(
-    (chunk) => f(chunk).flatMap((cont) => (cont ? loop : Channel.endNow(false))),
-    Channel.failCauseNow,
-    (_) => Channel.succeedNow(false),
-  );
-  return new Stream(stream.channel.pipeTo(loop));
-}
-
-/**
- * Loops on chunks emitting partially
- *
- * @tsplus fluent fncts.io.Stream loopOnPartialChunks
- */
-export function loopOnPartialChunks_<R, E, A, R1, E1, A1>(
-  stream: Stream<R, E, A>,
-  f: (a: Conc<A>, emit: (a: A1) => UIO<void>) => IO<R1, E1, boolean>,
-): Stream<R & R1, E | E1, A1> {
-  return stream.loopOnChunks((chunk) =>
-    Channel.unwrap(
-      IO.defer(() => {
-        let outputChunk = Conc.empty<A1>();
-        return f(chunk, (a) =>
-          IO.succeed(() => {
-            outputChunk = outputChunk.append(a);
-          }),
-        )
-          .map((cont) => Channel.write(outputChunk).apSecond(Channel.endNow(cont)))
-          .catchAll((failure) =>
-            IO.succeed(() => {
-              if (outputChunk.isEmpty) {
-                return Channel.failNow(failure);
-              } else {
-                return Channel.writeNow(outputChunk).apSecond(Channel.failNow(failure));
-              }
-            }),
-          );
-      }),
-    ),
-  );
-}
-
-/**
- * Loops on chunks elements emitting partially
- *
- * @tsplus fluent fncts.io.Stream loopOnPartialChunksElements
- */
-export function loopOnPartialChunksElements_<R, E, A, R1, E1, A1>(
-  stream: Stream<R, E, A>,
-  f: (a: A, emit: (a: A1) => UIO<void>) => IO<R1, E1, void>,
-): Stream<R & R1, E | E1, A1> {
-  return stream.loopOnPartialChunks((as, emit) => as.mapIO((a) => f(a, emit)).as(true));
-}
-
 /**
  * Transforms the elements of this stream using the supplied function.
  *
@@ -1861,11 +1890,11 @@ export function map_<R, E, A, B>(stream: Stream<R, E, A>, f: (o: A) => B): Strea
 
 function mapAccumAccumulator<S, E = never, A = never, B = never>(
   currS: S,
-  f: (s: S, a: A) => readonly [B, S],
+  f: (s: S, a: A) => readonly [S, B],
 ): Channel<unknown, E, Conc<A>, unknown, E, Conc<B>, void> {
   return Channel.readWith(
     (inp: Conc<A>) => {
-      const [bs, nextS] = inp.mapAccum(currS, f);
+      const [nextS, bs] = inp.mapAccum(currS, f);
       return Channel.writeNow(bs).apSecond(mapAccumAccumulator(nextS, f));
     },
     Channel.failNow,
@@ -1881,7 +1910,7 @@ function mapAccumAccumulator<S, E = never, A = never, B = never>(
 export function mapAccum_<R, E, A, S, B>(
   stream: Stream<R, E, A>,
   s: S,
-  f: (s: S, a: A) => readonly [B, S],
+  f: (s: S, a: A) => readonly [S, B],
 ): Stream<R, E, B> {
   return new Stream(stream.channel.pipeTo(mapAccumAccumulator(s, f)));
 }
@@ -2023,7 +2052,25 @@ export function mapIO_<R, E, A, R1, E1, B>(
   stream: Stream<R, E, A>,
   f: (a: A) => IO<R1, E1, B>,
 ): Stream<R & R1, E | E1, B> {
-  return stream.loopOnPartialChunksElements((a, emit) => f(a).flatMap(emit));
+  return new Stream(stream.channel.pipeTo(mapIOLoop(Iterable.empty<A>()[Symbol.iterator](), f)));
+}
+
+function mapIOLoop<R, E, A, R1, E1, B>(
+  iterator: Iterator<A>,
+  f: (a: A) => IO<R1, E1, B>,
+): Channel<R & R1, E, Conc<A>, unknown, E | E1, Conc<B>, unknown> {
+  const next = iterator.next();
+  if (next.done) {
+    return Channel.readWithCause(
+      (elem) => mapIOLoop(elem[Symbol.iterator](), f),
+      Channel.failCauseNow,
+      Channel.succeedNow,
+    );
+  } else {
+    return Channel.unwrap(
+      f(next.value).map((b) => Channel.writeNow(Conc.single(b)) > mapIOLoop<R, E, A, R1, E1, B>(iterator, f)),
+    );
+  }
 }
 
 /**
@@ -2582,11 +2629,29 @@ export function takeUntilIO_<R, E, A, R1, E1>(
   ma: Stream<R, E, A>,
   f: (a: A) => IO<R1, E1, boolean>,
 ): Stream<R & R1, E | E1, A> {
-  return ma.loopOnPartialChunks((chunk, emit) =>
-    chunk
-      .takeWhileIO((v) => emit(v).apSecond(f(v).map((b) => !b)))
-      .map((taken) => taken.drop(taken.length).take(1).isEmpty),
-  );
+  return new Stream(ma.channel.pipeTo(takeUntilIOLoop(Iterable.empty<A>()[Symbol.iterator](), f)));
+}
+
+function takeUntilIOLoop<R, E, A, R1, E1>(
+  iterator: Iterator<A>,
+  f: (a: A) => IO<R1, E1, boolean>,
+): Channel<R & R1, E, Conc<A>, unknown, E | E1, Conc<A>, unknown> {
+  const next = iterator.next();
+  if (next.done) {
+    return Channel.readWithCause(
+      (elem) => takeUntilIOLoop(elem[Symbol.iterator](), f),
+      Channel.failCauseNow,
+      Channel.succeedNow,
+    );
+  } else {
+    return Channel.unwrap(
+      f(next.value).map((b) =>
+        b
+          ? Channel.writeNow(Conc.single(next.value))
+          : Channel.writeNow(Conc.single(next.value)) > takeUntilIOLoop<R, E, A, R1, E1>(iterator, f),
+      ),
+    );
+  }
 }
 
 function takeUntilLoop<R, E, A>(p: Predicate<A>): Channel<R, E, Conc<A>, unknown, E, Conc<A>, unknown> {

package/_src/Stream/internal/DebounceState.ts

@@ -23,7 +23,7 @@ export const CurrentTag = Symbol();
 export type CurrentTag = typeof CurrentTag;
 export class Current<E, A> {
   readonly _tag = DebounceStateTag.Current;
-  constructor(readonly fiber: Fiber<E, HandoffSignal<void, E, A>>) {}
+  constructor(readonly fiber: Fiber<E, HandoffSignal<E, A>>) {}
 }
 
 /**
@@ -53,7 +53,7 @@ export function previous<A>(fiber: Fiber<never, Conc<A>>): DebounceState<never,
 /**
  * @tsplus static fncts.io.Stream.DebounceStateOps Current
  */
-export function current<E, A>(fiber: Fiber<E, HandoffSignal<void, E, A>>): DebounceState<E, A> {
+export function current<E, A>(fiber: Fiber<E, HandoffSignal<E, A>>): DebounceState<E, A> {
   return new Current(fiber);
 }
 

package/_src/Stream/internal/Handoff.ts

@@ -112,17 +112,17 @@ export class Halt<E> {
 
 export const EndTypeId = Symbol("fncts.io.Stream.HandoffSignal.End");
 export type EndTypeId = typeof EndTypeId;
-export class End<C> {
+export class End {
   readonly _typeId: typeof HandoffSignalTypeId = HandoffSignalTypeId;
   readonly _tag: typeof EndTypeId              = EndTypeId;
 
-  constructor(readonly reason: SinkEndReason<C>) {}
+  constructor(readonly reason: SinkEndReason) {}
 }
 
 /**
  * @tsplus type fncts.io.Stream.HandoffSignal
  */
-export type HandoffSignal<C, E, A> = Emit<A> | Halt<E> | End<C>;
+export type HandoffSignal<E, A> = Emit<A> | Halt<E> | End;
 
 /**
  * @tsplus type fncts.io.Stream.HandoffSignalOps
@@ -134,33 +134,33 @@ export const HandoffSignal: HandoffSignalOps = {};
 /**
  * @tsplus static fncts.io.Stream.HandoffSignalOps Emit
  */
-export function emit<A>(els: Conc<A>): HandoffSignal<never, never, A> {
+export function emit<A>(els: Conc<A>): HandoffSignal<never, A> {
   return new Emit(els);
 }
 
 /**
  * @tsplus static fncts.io.Stream.HandoffSignalOps Halt
  */
-export function halt<E>(error: Cause<E>): HandoffSignal<never, E, never> {
+export function halt<E>(error: Cause<E>): HandoffSignal<E, never> {
   return new Halt(error);
 }
 
 /**
  * @tsplus static fncts.io.Stream.HandoffSignalOps End
  */
-export function end<C>(reason: SinkEndReason<C>): HandoffSignal<C, never, never> {
+export function end<C>(reason: SinkEndReason): HandoffSignal<never, never> {
   return new End(reason);
 }
 
 /**
  * @tsplus fluent fncts.io.Stream.HandoffSignal match
  */
-export function matchSignal_<C, E, A, B, D, F>(
-  signal: HandoffSignal<C, E, A>,
+export function matchSignal_<E, A, B, D, F>(
+  signal: HandoffSignal<E, A>,
   cases: {
     Emit: (_: Emit<A>) => B;
     Halt: (_: Halt<E>) => D;
-    End: (_: End<C>) => F;
+    End: (_: End) => F;
   },
 ): B | D | F {
   switch (signal._tag) {

package/_src/Stream/internal/SinkEndReason.ts

@@ -7,21 +7,9 @@ export const enum SinkEndReasonTag {
 
 export const SinkEndReasonTypeId = Symbol.for("fncts.io.Stream.SinkEndReason");
 
-export class SinkEnd {
-  readonly _typeId: typeof SinkEndReasonTypeId = SinkEndReasonTypeId;
-  readonly _tag = SinkEndReasonTag.SinkEnd;
-}
-
-export class ScheduleTimeout {
-  readonly _typeId: typeof SinkEndReasonTypeId = SinkEndReasonTypeId;
-  readonly _tag = SinkEndReasonTag.ScheduleTimeout;
-}
-
-export class ScheduleEnd<C> {
+export class ScheduleEnd {
   readonly _typeId: typeof SinkEndReasonTypeId = SinkEndReasonTypeId;
   readonly _tag = SinkEndReasonTag.ScheduleEnd;
-
-  constructor(readonly c: C) {}
 }
 
 export class UpstreamEnd {
@@ -32,25 +20,19 @@ export class UpstreamEnd {
 /**
  * @tsplus type fncts.io.Stream.SinkEndReason
  */
-export type SinkEndReason<C> = SinkEnd | ScheduleTimeout | ScheduleEnd<C> | UpstreamEnd;
+export type SinkEndReason = ScheduleEnd | UpstreamEnd;
 
 /**
  * @tsplus fluent fncts.io.Stream.SinkEndReason match
  */
-export function matchSinkEndReason_<A, B, C, D, E>(
-  self: SinkEndReason<A>,
+export function matchSinkEndReason_<A, B>(
+  self: SinkEndReason,
   cases: {
-    SinkEnd: (_: SinkEnd) => B;
-    ScheduleTimeout: (_: ScheduleTimeout) => C;
-    ScheduleEnd: (_: ScheduleEnd<A>) => D;
-    UpstreamEnd: (_: UpstreamEnd) => E;
+    ScheduleEnd: (_: ScheduleEnd) => A;
+    UpstreamEnd: (_: UpstreamEnd) => B;
   },
-): B | C | D | E {
+): A | B {
   switch (self._tag) {
-    case SinkEndReasonTag.SinkEnd:
-      return cases.SinkEnd(self);
-    case SinkEndReasonTag.ScheduleTimeout:
-      return cases.ScheduleTimeout(self);
     case SinkEndReasonTag.ScheduleEnd:
       return cases.ScheduleEnd(self);
     case SinkEndReasonTag.UpstreamEnd:

package/_src/TFuture/definition.ts

@@ -1,7 +1,7 @@
 import type { UTRef } from "../TRef.js";
 
 interface TFutureN extends HKT {
-  readonly type: TFuture<this["E"], this["A"]>;
+  readonly [HKT.T]: TFuture<HKT._E<this>, HKT._A<this>>;
 }
 
 /**
@@ -20,4 +20,4 @@ export interface TFuture<E, A>
  */
 export interface TFutureOps extends NewtypeIso<TFutureN> {}
 
-export const TFuture: TFutureOps = Newtype<TFutureN>();
+export const TFuture: TFutureOps = Newtype<TFutureN>();

package/_src/TSemaphore/definition.ts

@@ -1,5 +1,5 @@
 interface TSemaphoreN extends HKT {
-  readonly type: TSemaphore;
+  readonly [HKT.T]: TSemaphore;
 }
 
 /**

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@fncts/io",
-  "version": "0.0.2",
+  "version": "0.0.5",
   "dependencies": {
-    "@fncts/base": "0.0.2",
-    "@fncts/typelevel": "0.0.2"
+    "@fncts/base": "0.0.5",
+    "@fncts/typelevel": "0.0.5"
   },
   "exports": {
     "./*": {

package/runTests.d.ts

@@ -0,0 +1 @@
+export {};