@fncts/io 0.0.33 → 0.0.35

package/_src/Push/api.ts

@@ -14,6 +14,49 @@ export function as<B>(b: Lazy<B>) {
   };
 }
 
+interface UnsafeEmitter<E, A> {
+  emit: (value: A) => void;
+  failCause: (cause: Cause<E>) => void;
+  end: () => void;
+}
+
+/**
+ * @tsplus static fncts.io.PushOps asyncInterrupt
+ */
+export function asyncInterrupt<R, E, A>(
+  make: (emitter: UnsafeEmitter<E, A>) => Either<IO<R, never, void>, Push<R, E, A>>,
+): Push<R, E, A> {
+  return Push<R, E, A>(<R1>(emitter: Emitter<R | R1, E, A>) =>
+    Do((Δ) => {
+      const future  = Δ(Future.make<never, void>());
+      const scope   = Δ(IO.scope);
+      const runtime = Δ(IO.runtime<R | R1 | R1>());
+      const unsafeEmitter: UnsafeEmitter<E, A> = {
+        emit: (value) => runtime.unsafeRunOrFork(emitter.emit(value).forkIn(scope)),
+        failCause: (cause) => runtime.unsafeRunOrFork(emitter.failCause(cause).fulfill(future).forkIn(scope)),
+        end: () => runtime.unsafeRunOrFork(emitter.end > future.succeed(undefined)),
+      };
+      const eitherPush = Δ(IO(make(unsafeEmitter)));
+      Δ(
+        eitherPush.match(
+          (canceller) => future.await.onInterrupt(canceller),
+          (push) => push.run(emitter),
+        ),
+      );
+    }),
+  );
+}
+
+/**
+ * @tsplus static fncts.io.PushOps async
+ */
+export function async<E, A>(make: (emitter: UnsafeEmitter<E, A>) => void): Push<never, E, A> {
+  return Push.asyncInterrupt((emitter) => {
+    make(emitter);
+    return Either.left(IO.unit);
+  });
+}
+
 /**
  * @tsplus static fncts.io.PushOps combineLatest
  */
@@ -79,7 +122,7 @@ export function debounce(duration: Lazy<Duration>) {
               (cause) => emitter.failCause(cause),
               latch.countDown,
             ),
-          ),
+          ).forkScoped,
         );
         Δ(latch.await > emitter.end);
       }),
@@ -101,7 +144,7 @@ export function flatMapConcurrentBounded<A, R1, E1, B>(f: (a: A) => Push<R1, E1,
   return <R, E>(self: Push<R, E, A>): Push<R | R1, E | E1, B> => {
     return Push(<R2>(emitter: Emitter<R | R1 | R2, E | E1, B>) =>
       Do((Δ) => {
-        const semaphore = Δ(TSemaphore(concurrency).commit);
+        const semaphore = Δ(Semaphore(concurrency));
         Δ(self.flatMapConcurrentUnbounded((a) => f(a).transform((io) => semaphore.withPermit(io))).run(emitter));
       }),
     );
@@ -124,7 +167,7 @@ export function flatMapConcurrentUnbounded<A, R1, E1, B>(f: (a: A) => Push<R1, E
               emitter.failCause,
               latch.countDown,
             ),
-          ),
+          ).forkScoped,
         );
         Δ(latch.await > emitter.end);
       }),
@@ -467,7 +510,7 @@ export function merge<R1, E1, B>(that: Push<R1, E1, B>) {
  */
 export function mergeAll<A extends ReadonlyArray<Push<any, any, any>>>(
   streams: [...A],
-): Push<_R<A[number]>, _E<A[number]>, _A<A[number]>>;
+): Push<Push.EnvironmentOf<A[number]>, Push.ErrorOf<A[number]>, Push.ValueOf<A[number]>>;
 export function mergeAll<R, E, A>(streams: Iterable<Push<R, E, A>>): Push<R, E, A>;
 export function mergeAll<R, E, A>(streams: Iterable<Push<R, E, A>>): Push<R, E, A> {
   return Push((emitter) =>
@@ -490,6 +533,29 @@ export function mergeAll<R, E, A>(streams: Iterable<Push<R, E, A>>): Push<R, E,
   );
 }
 
+/**
+ * @tsplus pipeable fncts.io.Push observe
+ */
+export function observe<A, R1, E1>(f: (a: A) => IO<R1, E1, void>, __tsplusTrace?: string) {
+  return <R, E>(self: Push<R, E, A>): IO<R | R1 | Scope, E | E1, void> => {
+    return Do((Δ) => {
+      const future = Δ(Future.make<E | E1, void>());
+      const fiber  = Δ(
+        self.run(
+          Emitter(
+            (a) => f(a).catchAllCause((cause) => future.failCause(cause)),
+            (cause) => future.failCause(cause),
+            future.succeed(undefined),
+          ),
+        ).forkScoped,
+      );
+
+      Δ(future.await);
+      Δ(fiber.interruptFork);
+    });
+  };
+}
+
 /**
  * @tsplus static fncts.io.PushOps repeatIOMaybe
  */

package/_src/Push/definition.ts

@@ -18,6 +18,12 @@ export class Push<R, E, A> {
   constructor(readonly run: <R1>(emitter: Emitter<R1, E, A>) => IO<R | R1 | Scope, 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

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]: {

package/_src/Schedule/api.ts

@@ -131,7 +131,7 @@ export function checkIO<In, Out, Env1>(test: (inp: In, out: Out) => URIO<Env1, b
 }
 
 /**
- * @tsplus pipeable fncts.io.Schedule compose_
+ * @tsplus pipeable fncts.io.Schedule compose
  */
 export function compose<O, S1, R1, O2>(that: Schedule.WithState<S1, R1, O, O2>, __tsplusTrace?: string) {
   return <S, R, I>(self: Schedule.WithState<S, R, I, O>): Schedule.WithState<readonly [S, S1], R | R1, I, O2> => {

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);
   };
 }

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

@@ -1,34 +1,25 @@
-import { concrete } from "@fncts/base/collection/immutable/Conc";
-
 /**
  * @tsplus pipeable fncts.Conc takeWhileIO
  */
 export function takeWhileIO<A, R, E>(p: (a: A) => IO<R, E, boolean>, __tsplusTrace?: string) {
-  return (as: Conc<A>): IO<R, E, Conc<A>> => {
-    return IO.defer(() => {
-      concrete(as);
-      let taking: IO<R, E, boolean> = IO.succeedNow(true);
-      const out                     = Conc.builder<A>();
-      const iterator                = as.arrayIterator();
-      let result: IteratorResult<ArrayLike<A>>;
-      while (!(result = iterator.next()).done) {
-        const array = result.value;
-        for (let i = 0; i < array.length; i++) {
-          const j = i;
-          taking  = taking.flatMap((b) => {
-            const a = array[j]!;
-            return (b ? p(a) : IO.succeedNow(false)).map((b1) => {
-              if (b1) {
-                out.append(a);
-                return true;
-              } else {
-                return false;
-              }
-            });
-          });
-        }
-      }
-      return taking.as(out.result());
-    });
+  return (self: Conc<A>): IO<R, E, Conc<A>> => {
+    return IO.defer(takeWhileIOLoop(self, self[Symbol.iterator](), p, 0));
   };
 }
+
+function takeWhileIOLoop<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 ? takeWhileIOLoop(self, iterator, p, index + 1) : IO.succeed(self.take(index)),
+    );
+  } else {
+    return IO.succeed(Conc.empty());
+  }
+}

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

@@ -1,5 +1,5 @@
 import { IO } from "@fncts/io/IO/definition";
-import { Conc, ConcBuilder } from "@fncts/base/collection/immutable/Conc";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
 /**
  * @tsplus pipeable fncts.Conc filterIO
  * @tsplus location "@fncts/io/collection/immutable/Conc/filterIO"

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

@@ -4,4 +4,4 @@ import { Conc } from "@fncts/base/collection/immutable/Conc";
  * @tsplus pipeable fncts.Conc mapIO
  * @tsplus location "@fncts/io/collection/immutable/Conc/mapIO"
  */
-export declare function mapIO<A, R, E, B>(f: (a: A) => IO<R, E, B>, __tsplusTrace?: string): (as: Conc<A>) => IO<R, E, Conc<B>>;
+export declare function mapIO<A, R, E, B>(f: (a: A) => IO<R, E, B>, __tsplusTrace?: string): (self: Conc<A>) => IO<R, E, Conc<B>>;

package/collection/immutable/Conc/takeWhileIO.d.ts

@@ -4,4 +4,4 @@ import { Conc } from "@fncts/base/collection/immutable/Conc";
  * @tsplus pipeable fncts.Conc takeWhileIO
  * @tsplus location "@fncts/io/collection/immutable/Conc/takeWhileIO"
  */
-export declare function takeWhileIO<A, R, E>(p: (a: A) => IO<R, E, boolean>, __tsplusTrace?: string): (as: Conc<A>) => IO<R, E, Conc<A>>;
+export declare function takeWhileIO<A, R, E>(p: (a: A) => IO<R, E, boolean>, __tsplusTrace?: string): (self: Conc<A>) => IO<R, E, Conc<A>>;

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@fncts/io",
-  "version": "0.0.33",
+  "version": "0.0.35",
   "dependencies": {
-    "@fncts/base": "0.0.28",
-    "@fncts/transformers": "0.0.5",
+    "@fncts/base": "0.0.30",
+    "@fncts/transformers": "0.0.6",
     "@fncts/typelevel": "0.0.15"
   },
   "exports": {

package/IOSpec.d.ts

@@ -1,22 +0,0 @@
-import { DefaultRunnableSpec } from "@fncts/test/control/DefaultRunnableSpec";
-import { suite, testIO } from "@fncts/test/api";
-import { Ref } from "@fncts/io/Ref";
-import { strictEqualTo, isTrue, isFalse, fails, isEmpty, isNothing, isUnit, isJust, isRight, isLeft, isLessThanOrEqualTo, isOnlyInterrupted, isInterrupted } from "@fncts/test/control/Assertion";
-import { List } from "@fncts/base/collection/immutable/List/definition";
-import { IO } from "@fncts/io/IO";
-import { Conc } from "@fncts/base/collection/immutable/Conc";
-import { Future } from "@fncts/io/Future";
-import { Cause } from "@fncts/base/data/Cause/definition";
-import { Exit } from "@fncts/base/data/Exit/definition";
-import { UIO } from "@fncts/io/IO/definition";
-import { Clock } from "@fncts/io/Clock";
-import { Just, Nothing } from "@fncts/base/data/Maybe/definition";
-import { Either } from "@fncts/base/data/Either/definition";
-import { Fiber } from "@fncts/io/Fiber/definition";
-import { HashSet } from "@fncts/base/collection/immutable/HashSet/definition";
-import { Live } from "@fncts/test/control/Live";
-declare class IOSpec extends DefaultRunnableSpec {
-    spec: import("@fncts/test/control/Spec.js").Spec<Live, import("@fncts/test/data/TestFailure.js").AssertionFailure | import("@fncts/test/data/TestFailure.js").RuntimeFailure<import("@fncts/test/data/TestFailure.js").AssertionFailure | import("@fncts/test/data/TestFailure.js").RuntimeFailure<import("@fncts/base/collection/immutable/Conc.js").Conc<number>> | import("@fncts/test/data/TestFailure.js").RuntimeFailure<import("@fncts/base/collection/immutable/Conc.js").Conc<void>>>>;
-}
-declare const _default: IOSpec;
-export default _default;

package/Latch.d.ts

@@ -1,3 +0,0 @@
-import { UIO } from "@fncts/io/IO/definition";
-import { IO } from "@fncts/io/IO";
-export declare function withLatch<R, E, A>(f: (_: UIO<void>) => IO<R, E, A>): IO<R, E, A>;

package/runTests.d.ts

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