@fncts/io 0.0.34 → 0.0.36

package/_src/Push/definition.ts

@@ -15,37 +15,39 @@ export class Push<R, E, A> {
     readonly _E: (_: never) => E;
     readonly _A: (_: never) => A;
   };
-  constructor(readonly run: <R1>(emitter: Emitter<R1, E, A>) => IO<R | R1 | Scope, never, unknown>) {}
+  constructor(readonly run: <R1>(emitter: Sink<R1, E, A>) => IO<R | R1, never, unknown>) {}
+}
+
+export declare namespace Push {
+  export type EnvironmentOf<X> = [X] extends [{ [PushVariance]: { readonly _R: (_: never) => infer R } }] ? R : never;
+  export type ErrorOf<X> = [X] extends [{ [PushVariance]: { readonly _E: (_: never) => infer E } }] ? E : never;
+  export type ValueOf<X> = [X] extends [{ [PushVariance]: { readonly _A: (_: never) => infer A } }] ? A : never;
 }
 
 /**
- * @tsplus type fncts.io.Push.Emitter
- * @tsplus companion fncts.io.Push.EmitterOps
+ * @tsplus type fncts.io.Push.Sink
+ * @tsplus companion fncts.io.Push.SinkOps
  */
-export class Emitter<R, E, A> {
+export class Sink<R, E, A> {
   constructor(
-    readonly emit: (value: A) => IO<R, never, unknown>,
-    readonly failCause: (cause: Cause<E>) => IO<R, never, void>,
-    readonly end: IO<R, never, void>,
+    readonly event: (value: A) => IO<R, never, void>,
+    readonly error: (cause: Cause<E>) => IO<R, never, void>,
   ) {}
 }
 
 /**
  * @tsplus static fncts.io.PushOps __call
  */
-export function makePush<R, E, A>(
-  run: <R1>(emitter: Emitter<R1, E, A>) => IO<R | R1 | Scope, never, unknown>,
-): Push<R, E, A> {
+export function makePush<R, E, A>(run: <R1>(sink: Sink<R1, E, A>) => IO<R | R1, never, unknown>): Push<R, E, A> {
   return new Push(run);
 }
 
 /**
- * @tsplus static fncts.io.Push.EmitterOps __call
+ * @tsplus static fncts.io.Push.SinkOps __call
  */
-export function makeEmitter<R, E, A>(
-  emit: (value: A) => IO<R, never, unknown>,
-  failCause: (cause: Cause<E>) => IO<R, never, unknown>,
-  end: IO<R, never, unknown>,
-): Emitter<R, E, A> {
-  return new Emitter(emit, failCause, end);
+export function makeSink<R, E, A>(
+  value: (value: A) => IO<R, never, unknown>,
+  error: (cause: Cause<E>) => IO<R, never, unknown>,
+): Sink<R, E, A> {
+  return new Sink(value, error);
 }

package/_src/Push/internal.ts

@@ -1,39 +1,71 @@
-export function withCountdownLatch<R, E, A, R1, E1, B>(
-  n: number,
-  f: (latch: CountdownLatch) => IO<R, E, A>,
-  onEnd: IO<R1, E1, B>,
-): IO<R | R1, E | E1, B> {
-  return Do((Δ) => {
-    const latch = Δ(CountdownLatch(n));
-    Δ(f(latch));
-    return Δ(latch.await > onEnd);
-  });
+import type { RuntimeFiber } from "@fncts/io/Fiber";
+
+export function withScopedFork<R, E, A>(
+  f: (fork: <R, E, A>(io: IO<R, E, A>) => IO<R, never, RuntimeFiber<E, A>>) => IO<R, E, A>,
+): IO<R, E, A> {
+  return IO.bracketExit(
+    Scope.make,
+    (scope) => f((io) => io.forkIn(scope)),
+    (scope, exit) => scope.close(exit),
+  );
 }
 
-export const EarlyExitTypeId = Symbol.for("fncts.io.Push.EarlyExit");
-export type EarlyExitTypeId = typeof EarlyExitTypeId;
+export function withSwitch<R, E, A>(f: (fork: <R>(io: URIO<R, void>) => URIO<R, void>) => IO<R, E, A>) {
+  return withScopedFork((fork) =>
+    Do((Δ) => {
+      const ref = Δ(Ref.Synchronized.make<Fiber<never, void>>(Fiber.unit));
+
+      const switchFork = <R>(io: URIO<R, void>) => {
+        return ref.updateIO((currentFiber) => currentFiber.interruptFork.flatMap(() => fork(io)));
+      };
+
+      Δ(f(switchFork));
+
+      const fiber = Δ(ref.get);
 
-export class EarlyExit {
-  readonly [EarlyExitTypeId]: EarlyExitTypeId = EarlyExitTypeId;
+      Δ(fiber.join.when(fiber !== undefined));
+    }),
+  );
 }
 
-export function isEarlyExit(u: unknown): u is EarlyExit {
-  return isObject(u) && EarlyExitTypeId in u;
+export function withUnboundedConcurrency<R, E, A>(
+  f: (fork: <R>(io: URIO<R, void>) => URIO<R, RuntimeFiber<never, void>>) => IO<R, E, A>,
+) {
+  return withScopedFork((fork) =>
+    Do((Δ) => {
+      const fibers = Δ(IO.succeed(new Set<RuntimeFiber<never, void>>()));
+      Δ(
+        f((io) =>
+          Do((Δ) => {
+            const fiber = Δ(fork(io));
+            Δ(IO(fibers.add(fiber)));
+            Δ(fork(fiber.join.ensuring(IO(fibers.delete(fiber)))));
+            return fiber;
+          }),
+        ),
+      );
+      Δ(Fiber.joinAll(fibers));
+    }),
+  );
 }
 
-export const earlyExit = IO.haltNow(new EarlyExit());
-
-export function onEarlyExit<R1, E1, B>(onEarlyExit: IO<R1, E1, B>) {
-  return <R, E, A>(self: IO<R, E, A>): IO<R | R1, E | E1, A | B> => {
-    return self.matchCauseIO(
-      (cause) =>
-        cause
-          .find((cause) => (cause.isHalt() && isEarlyExit(cause.value) ? Just(cause) : Nothing()))
-          .match(
-            () => IO.failCauseNow(cause),
-            () => onEarlyExit,
-          ),
-      IO.succeedNow,
-    );
-  };
+export function withExhaust<R, E, A>(f: (fork: <R>(io: URIO<R, void>) => URIO<R, void>) => IO<R, E, A>) {
+  return withScopedFork((fork) =>
+    Do((Δ) => {
+      const ref   = Δ(Ref.make<RuntimeFiber<never, void> | null>(null));
+      const reset = ref.set(null);
+
+      const exhaustFork = <R>(io: IO<R, never, void>) =>
+        io
+          .ensuring(reset)
+          .fork.flatMap((fiber) => ref.set(fiber))
+          .whenRef(ref, (fiber) => fiber === null).asUnit;
+
+      Δ(f(exhaustFork));
+
+      const fiber = Δ(ref.get);
+
+      Δ(IO.defer(fiber === null ? IO.unit : fiber.join));
+    }),
+  );
 }

package/_src/RefSubject/Atomic.ts

@@ -1,4 +1,4 @@
-import type { Emitter } from "@fncts/io/Push";
+import type { Sink } from "@fncts/io/Push";
 
 import { AtomicReference } from "@fncts/base/internal/AtomicReference";
 import { Hold, Push } from "@fncts/io/Push";
@@ -7,7 +7,7 @@ import { RefSubjectInternal } from "@fncts/io/RefSubject/definition";
 
 export class AtomicRefSubject<E, A> extends RefSubjectInternal<never, E, A, A> {
   readonly stream   = new Hold<never, E, A>(Push.never);
-  readonly maybeRef = new Atomic(this.stream.value);
+  readonly maybeRef = new Atomic(this.stream.current);
   readonly ref      = new AtomicEmitRef(
     new AtomicDimapRef(
       this.maybeRef,
@@ -19,7 +19,7 @@ export class AtomicRefSubject<E, A> extends RefSubjectInternal<never, E, A, A> {
 
   constructor(readonly initial: A) {
     super();
-    this.stream.value.set(Just(initial));
+    this.stream.current.set(Just(initial));
   }
 
   get get() {
@@ -38,30 +38,24 @@ export class AtomicRefSubject<E, A> extends RefSubjectInternal<never, E, A, A> {
     return this.ref.modify(f);
   }
 
-  run<R>(emitter: Emitter<R, E, A>): IO<Scope | R, never, unknown> {
+  run<R>(emitter: Sink<R, E, A>): IO<R, never, unknown> {
     return this.stream.run(emitter);
   }
 
-  emit(value: A): IO<never, never, void> {
-    return this.stream.emit(value);
+  event(value: A): IO<never, never, void> {
+    return this.stream.event(value);
   }
 
-  failCause(cause: Cause<E>): IO<never, never, void> {
-    return this.stream.failCause(cause);
+  error(cause: Cause<E>): IO<never, never, void> {
+    return this.stream.error(cause);
   }
 
-  end: IO<never, never, void> = this.stream.end;
-
-  unsafeEmit(value: A): void {
-    this.stream.emit(value).unsafeRunFiber();
-  }
-
-  unsafeFailCause(cause: Cause<E>): void {
-    this.stream.failCause(cause).unsafeRunFiber();
+  unsafeEvent(value: A): void {
+    this.stream.event(value).unsafeRunFiber();
   }
 
-  unsafeEnd(): void {
-    this.stream.end.unsafeRunFiber();
+  unsafeError(cause: Cause<E>): void {
+    this.stream.error(cause).unsafeRunFiber();
   }
 
   get unsafeGet(): A {
@@ -97,7 +91,7 @@ class AtomicDimapRef<A, B> extends Atomic<B> {
 }
 
 class AtomicEmitRef<E, A> extends Atomic<A> {
-  constructor(readonly ref: Atomic<A>, readonly emitter: Emitter<never, E, A>) {
+  constructor(readonly ref: Atomic<A>, readonly sink: Sink<never, E, A>) {
     super(ref.value);
   }
 
@@ -111,14 +105,14 @@ class AtomicEmitRef<E, A> extends Atomic<A> {
 
   unsafeSet(value: A) {
     this.ref.unsafeSet(value);
-    this.emitter.emit(value).unsafeRunFiber();
+    this.sink.event(value).unsafeRunFiber();
   }
 
   set(value: A, __tsplusTrace?: string) {
-    return this.ref.set(value) < this.emitter.emit(value);
+    return this.ref.set(value) < this.sink.event(value);
   }
 
   modify<B>(f: (a: A) => readonly [B, A], __tsplusTrace?: string) {
-    return this.ref.modify(f) < this.ref.get.flatMap((value) => this.emitter.emit(value));
+    return this.ref.modify(f) < this.ref.get.flatMap((value) => this.sink.event(value));
   }
 }

package/_src/RefSubject/Synchronized/definition.ts

@@ -1,7 +1,6 @@
 import type { RefSubject } from "../definition.js";
 import type { Cause } from "@fncts/base/data/Cause";
-import type { Emitter } from "@fncts/io/Push";
-import type { Scope } from "@fncts/io/Scope";
+import type { Sink } from "@fncts/io/Push";
 
 import { IO } from "@fncts/io/IO";
 
@@ -44,7 +43,7 @@ export class SynchronizedRefSubjectInternal<R, E, A, B>
     return this.withPermit(this.ref.set(a));
   }
 
-  run<R1>(emitter: Emitter<R1, E, B>): IO<Scope | R | R1, never, void> {
+  run<R1>(emitter: Sink<R1, E, B>): IO<R | R1, never, void> {
     return this.ref.run(emitter);
   }
 
@@ -56,16 +55,14 @@ export class SynchronizedRefSubjectInternal<R, E, A, B>
     return this.withPermit(this.ref.get.flatMap(f).flatMap(([b, a]) => this.ref.set(a).as(b)));
   }
 
-  emit(value: A): IO<R, never, void> {
-    return this.withPermit(this.ref.emit(value));
+  event(value: A): IO<R, never, void> {
+    return this.withPermit(this.ref.event(value));
   }
 
-  failCause(cause: Cause<E>): IO<R, never, void> {
-    return this.withPermit(this.ref.failCause(cause));
+  error(cause: Cause<E>): IO<R, never, void> {
+    return this.withPermit(this.ref.error(cause));
   }
 
-  end: IO<R, never, void> = this.withPermit(this.ref.end);
-
   withPermit<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
     return this.semaphore.withPermit(io);
   }

package/_src/RefSubject/api.ts

@@ -1,5 +1,5 @@
 import { tuple } from "@fncts/base/data/function";
-import { Emitter } from "@fncts/io/Push";
+import { Sink } from "@fncts/io/Push";
 import { AtomicRefSubject } from "@fncts/io/RefSubject/Atomic";
 
 import { RefSubject } from "./definition.js";
@@ -64,26 +64,23 @@ class Dimap<R, E, A, B, C, D> extends RefSubjectInternal<R, E, C, D> {
     });
   }
 
-  run<R1>(emitter: Emitter<R1, E, D>): IO<Scope | R | R1, never, void> {
+  run<R1>(emitter: Sink<R1, E, D>): IO<R | R1, never, void> {
     return this.ref.run(
-      Emitter(
-        (value) => emitter.emit(this.g(value)),
-        (cause) => emitter.failCause(cause),
-        emitter.end,
+      Sink(
+        (value) => emitter.event(this.g(value)),
+        (cause) => emitter.error(cause),
       ),
     );
   }
 
-  emit(value: C): IO<R, never, void> {
-    return this.ref.emit(this.f(value));
+  event(value: C): IO<R, never, void> {
+    return this.ref.event(this.f(value));
   }
 
-  failCause(cause: Cause<E>): IO<R, never, void> {
-    return this.ref.failCause(cause);
+  error(cause: Cause<E>): IO<R, never, void> {
+    return this.ref.error(cause);
   }
 
-  end: IO<R, never, void> = this.ref.end;
-
   get unsafeGet(): D {
     return this.g(this.ref.unsafeGet);
   }

package/_src/RefSubject/definition.ts

@@ -1,4 +1,4 @@
-import type { Emitter } from "../Push.js";
+import type { Sink } from "../Push.js";
 import type { Push } from "../Push.js";
 import type { ModifiableRef, ReadableRef, WritableRef } from "../Ref.js";
 import type { SynchronizedRefSubject } from "@fncts/io/RefSubject/Synchronized/definition";
@@ -10,7 +10,7 @@ import { RefVariance } from "../Ref.js";
 /**
  * @tsplus type fncts.io.Push.RefSubject
  */
-export interface RefSubject<out R, in out E, in A, out B> extends Push<R, E, B>, Emitter<R, E, A> {}
+export interface RefSubject<out R, in out E, in A, out B> extends Push<R, E, B>, Sink<R, E, A> {}
 
 /**
  * @tsplus type fncts.io.Push.RefSubjectOps
@@ -29,7 +29,7 @@ export abstract class RefSubjectInternal<R, E, A, B>
     WritableRef<R, never, A>,
     ModifiableRef<R, R, never, never, A, B>,
     Push<R, E, B>,
-    Emitter<R, E, A>
+    Sink<R, E, A>
 {
   readonly [PushTypeId]: PushTypeId = PushTypeId;
   declare [RefVariance]: {
@@ -52,13 +52,11 @@ export abstract class RefSubjectInternal<R, E, A, B>
 
   abstract modify<C>(f: (b: B) => readonly [C, A], __tsplusTrace?: string): IO<R, never, C>;
 
-  abstract run<R1>(emitter: Emitter<R1, E, B>): IO<Scope | R | R1, never, void>;
+  abstract run<R1>(emitter: Sink<R1, E, B>): IO<R | R1, never, void>;
 
-  abstract failCause(cause: Cause<E>): IO<R, never, void>;
+  abstract error(cause: Cause<E>): IO<R, never, void>;
 
-  abstract emit(value: A): IO<R, never, void>;
-
-  abstract end: IO<R, never, void>;
+  abstract event(value: A): IO<R, never, void>;
 
   abstract get unsafeGet(): B;
 }

package/_src/STM/api.ts

@@ -1,13 +1,8 @@
 import type { Journal } from "./internal/Journal.js";
 
 import { identity } from "@fncts/base/data/function";
-import { AtomicReference } from "@fncts/base/internal/AtomicReference";
-import { TxnId } from "@fncts/io/TxnId";
 
 import { ContramapEnvironment, Effect, HaltException, STM } from "./definition.js";
-import { CommitState } from "./internal/CommitState.js";
-import { tryCommitAsync, tryCommitSync } from "./internal/Journal.js";
-import { TryCommitTag } from "./internal/TryCommit.js";
 
 /**
  * Maps the success value of this effect to the specified constant value.

package/_src/STM/definition.ts

@@ -1,7 +1,7 @@
 import type { Journal } from "./internal/Journal.js";
 import type { _A, _E, _R } from "@fncts/base/types";
 
-import { IOOpCode, IOTypeId, IOVariance } from "@fncts/io/IO/definition";
+import { IOTag, IOTypeId, IOVariance } from "@fncts/io/IO/definition";
 
 export const enum STMTag {
   Effect = "Effect",
@@ -25,7 +25,7 @@ export type STMTypeId = typeof STMTypeId;
  */
 export abstract class STM<R, E, A> {
   readonly [IOTypeId]: IOTypeId = IOTypeId;
-  readonly _tag                 = IOOpCode.Commit;
+  readonly _tag                 = IOTag.Commit;
   readonly trace?: string;
   readonly [STMTypeId]: STMTypeId = STMTypeId;
   declare [IOVariance]: {
@@ -40,6 +40,12 @@ export abstract class STM<R, E, A> {
   };
 }
 
+export declare namespace STM {
+  type EnvironmentOf<X> = [X] extends [{ [STMVariance]: { _R: () => infer R } }] ? R : never;
+  type ErrorOf<X> = [X] extends [{ [STMVariance]: { _E: () => infer E } }] ? E : never;
+  type ValueOf<X> = [X] extends [{ [STMVariance]: { _A: () => infer A } }] ? A : never;
+}
+
 /**
  * @tsplus unify fncts.io.STM
  */

package/_src/Sink/api.ts

@@ -17,7 +17,7 @@ export function zipLeft<In, L, R1, E1, In1 extends In, L1 extends L, Z1>(
 }
 
 /**
- * Like {@link zipC}, but keeps only the result from this sink
+ * Like {@link zipConcurrent}, but keeps only the result from this sink
  *
  * @tsplus pipeable fncts.io.Sink zipLeftC
  */
@@ -26,7 +26,7 @@ export function zipLeftC<In, L, R1, E1, In1 extends In, L1 extends L, Z1>(
   __tsplusTrace?: string,
 ) {
   return <R, E, Z>(self: Sink<R, E, In, L, Z>): Sink<R | R1, E | E1, In & In1, L | L1, Z> => {
-    return self.zipWithC(that, (z, _) => z);
+    return self.zipWithConcurrent(that, (z, _) => z);
   };
 }
 
@@ -45,7 +45,7 @@ export function zipRight<In, L, R1, E1, In1 extends In, L1 extends L, Z1>(
 }
 
 /**
- * Like {@link zipC}, but keeps only the result from the `that` sink
+ * Like {@link zipConcurrent}, but keeps only the result from the `that` sink
  *
  * @tsplus pipeable fncts.io.Sink zipRightC
  */
@@ -54,7 +54,7 @@ export function zipRightC<In, L, R1, E1, In1 extends In, L1 extends L, Z1>(
   __tsplusTrace?: string,
 ) {
   return <R, E, Z>(self: Sink<R, E, In, L, Z>): Sink<R | R1, E | E1, In & In1, L | L1, Z1> => {
-    return self.zipWithC(that, (_, z1) => z1);
+    return self.zipWithConcurrent(that, (_, z1) => z1);
   };
 }
 
@@ -1704,14 +1704,14 @@ export function zip<In, L, R1, E1, In1 extends In, L1 extends L, Z1>(
  * Runs both sinks in parallel on the input and combines the results in a
  * tuple.
  *
- * @tsplus pipeable fncts.io.Sink zipC
+ * @tsplus pipeable fncts.io.Sink zipConcurrent
  */
-export function zipC<In, L, R1, E1, In1 extends In, L1 extends L, Z1>(
+export function zipConcurrent<In, L, R1, E1, In1 extends In, L1 extends L, Z1>(
   that: Lazy<Sink<R1, E1, In1, L1, Z1>>,
   __tsplusTrace?: string,
 ) {
   return <R, E, Z>(self: Sink<R, E, In, L, Z>): Sink<R | R1, E | E1, In & In1, L | L1, readonly [Z, Z1]> => {
-    return self.zipWithC(that, Function.tuple);
+    return self.zipWithConcurrent(that, Function.tuple);
   };
 }
 
@@ -1736,9 +1736,9 @@ export function zipWith<In, L, Z, R1, E1, In1 extends In, L1 extends L, Z1, Z2>(
  * Runs both sinks in parallel on the input and combines the results using the
  * provided function.
  *
- * @tsplus pipeable fncts.io.Sink zipWithC
+ * @tsplus pipeable fncts.io.Sink zipWithConcurrent
  */
-export function zipWithC<Z, R1, E1, In1, L1, Z1, Z2>(
+export function zipWithConcurrent<Z, R1, E1, In1, L1, Z1, Z2>(
   that: Lazy<Sink<R1, E1, In1, L1, Z1>>,
   f: (z: Z, z1: Z1) => Z2,
   __tsplusTrace?: string,

package/_src/Subject/Atomic.ts

@@ -1,4 +1,4 @@
-import type { Emitter } from "@fncts/io/Push/definition";
+import type { Sink } from "@fncts/io/Push/definition";
 import type { Subject } from "@fncts/io/Subject/definition";
 
 import { Multicast, Push } from "@fncts/io/Push";
@@ -16,17 +16,15 @@ export class AtomicSubject<E, A> implements Subject<never, E, A> {
 
   readonly stream = new Multicast<never, E, A>(Push.never);
 
-  run<R>(emitter: Emitter<R, E, A>): IO<R | Scope, never, unknown> {
+  run<R>(emitter: Sink<R, E, A>): IO<R, never, unknown> {
     return this.stream.run(emitter);
   }
 
-  emit(value: A): IO<never, never, void> {
-    return this.stream.emit(value);
+  event(value: A): IO<never, never, void> {
+    return this.stream.event(value);
   }
 
-  failCause(cause: Cause<E>): IO<never, never, void> {
-    return this.stream.failCause(cause);
+  error(cause: Cause<E>): IO<never, never, void> {
+    return this.stream.error(cause);
   }
-
-  end = this.stream.end;
 }

package/_src/Subject/definition.ts

@@ -1,4 +1,4 @@
-import type { Emitter, Push } from "../Push.js";
+import type { Push,Sink } from "../Push.js";
 
 export const SubjectTypeId = Symbol.for("fncts.io.Push.Subject");
 export type SubjectTypeId = typeof SubjectTypeId;
@@ -6,7 +6,7 @@ export type SubjectTypeId = typeof SubjectTypeId;
 /**
  * @tsplus type fncts.io.Push.Subject
  */
-export interface Subject<R, E, A> extends Push<R, E, A>, Emitter<R, E, A> {
+export interface Subject<R, E, A> extends Push<R, E, A>, Sink<R, E, A> {
   readonly [SubjectTypeId]: SubjectTypeId;
 }
 

package/_src/collection/immutable/Conc/dropUntilIO.ts

@@ -3,20 +3,23 @@
  */
 export function dropUntilIO<A, R, E>(p: (a: A) => IO<R, E, boolean>, __tsplusTrace?: string) {
   return (self: Conc<A>): IO<R, E, Conc<A>> => {
-    return IO.defer(() => {
-      const builder                   = new ConcBuilder<A>();
-      let dropping: IO<R, E, boolean> = IO.succeedNow(false);
-      for (const elem of self) {
-        dropping = dropping.flatMap((b) => {
-          if (b) {
-            builder.append(elem);
-            return IO.succeedNow(true);
-          } else {
-            return p(elem);
-          }
-        });
-      }
-      return dropping.as(builder.result());
-    });
+    return IO.defer(dropUntilIOLoop(self, self[Symbol.iterator](), p, 0));
   };
 }
+
+function dropUntilIOLoop<A, R, E>(
+  self: Conc<A>,
+  iterator: Iterator<A>,
+  p: (a: A) => IO<R, E, boolean>,
+  index: number,
+  __tsplusTrace?: string,
+): IO<R, E, Conc<A>> {
+  let result: IteratorResult<A>;
+  if (!(result = iterator.next()).done) {
+    return p(result.value).flatMap((b) =>
+      b ? IO.succeed(self.drop(index + 1)) : dropUntilIOLoop(self, iterator, p, index + 1),
+    );
+  } else {
+    return IO.succeed(Conc.empty());
+  }
+}

package/_src/collection/immutable/Conc/dropWhileIO.ts

@@ -3,22 +3,23 @@
  */
 export function dropWhileIO<A, R, E>(p: (a: A) => IO<R, E, boolean>, __tsplusTrace?: string) {
   return (self: Conc<A>): IO<R, E, Conc<A>> => {
-    return IO.defer(() => {
-      const builder                   = new ConcBuilder<A>();
-      let dropping: IO<R, E, boolean> = IO.succeedNow(true);
-      for (const elem of self) {
-        dropping = dropping.flatMap((d) =>
-          (d ? p(elem) : IO.succeedNow(false)).map((b) => {
-            if (b) {
-              return true;
-            } else {
-              builder.append(elem);
-              return false;
-            }
-          }),
-        );
-      }
-      return dropping.as(builder.result());
-    });
+    return IO.defer(dropWhileIOLoop(self, self[Symbol.iterator](), p, 0));
   };
 }
+
+function dropWhileIOLoop<A, R, E>(
+  self: Conc<A>,
+  iterator: Iterator<A>,
+  p: (a: A) => IO<R, E, boolean>,
+  index: number,
+  __tsplusTrace?: string,
+): IO<R, E, Conc<A>> {
+  let result: IteratorResult<A>;
+  if (!(result = iterator.next()).done) {
+    return p(result.value).flatMap((b) =>
+      b ? dropWhileIOLoop(self, iterator, p, index + 1) : IO.succeed(self.drop(index)),
+    );
+  } else {
+    return IO.succeed(Conc.empty());
+  }
+}

package/_src/collection/immutable/Conc/filterIO.ts

@@ -3,16 +3,6 @@
  */
 export function filterIO<A, R, E>(p: (a: A) => IO<R, E, boolean>, __tsplusTrace?: string) {
   return (self: Conc<A>): IO<R, E, Conc<A>> => {
-    return IO.defer(() => {
-      const builder = new ConcBuilder<A>();
-      let dest: IO<R, E, ConcBuilder<A>> = IO.succeedNow(builder);
-      for (const a of self) {
-        dest = dest.zipWith(p(a), (builder, res) => {
-          if (res) return builder.append(a);
-          else return builder;
-        });
-      }
-      return dest.map((builder) => builder.result());
-    });
+    return IO.filter(self, p);
   };
 }

package/_src/collection/immutable/Conc/mapIO.ts

@@ -2,14 +2,7 @@
  * @tsplus pipeable fncts.Conc mapIO
  */
 export function mapIO<A, R, E, B>(f: (a: A) => IO<R, E, B>, __tsplusTrace?: string) {
-  return (as: Conc<A>): IO<R, E, Conc<B>> => {
-    return IO.defer(() => {
-      const out = Conc.builder<B>();
-      return IO.foreachDiscard(as, (a) =>
-        f(a).map((b) => {
-          out.append(b);
-        }),
-      ).as(out.result());
-    });
+  return (self: Conc<A>): IO<R, E, Conc<B>> => {
+    return IO.foreach(self, f);
   };
 }