@fncts/io 0.0.10 → 0.0.13

package/_src/Stream/definition.ts

@@ -25,9 +25,9 @@ export type StreamTypeId = typeof StreamTypeId;
  */
 export class Stream<R, E, A> {
   readonly [StreamTypeId]: StreamTypeId = StreamTypeId;
-  readonly _R!: (_: R) => void;
-  readonly _E!: () => E;
-  readonly _A!: () => A;
+  declare _R: () => R;
+  declare _E: () => E;
+  declare _A: () => A;
 
   constructor(readonly channel: Channel<R, unknown, unknown, unknown, E, Conc<A>, unknown>) {}
 }

package/_src/Stream/internal/Take.ts

@@ -52,7 +52,7 @@ export function matchIO_<R, R1, R2, E, E1, E2, E3, A, Z>(
   end: IO<R, E1, Z>,
   error: (cause: Cause<E>) => IO<R1, E2, Z>,
   value: (chunk: Conc<A>) => IO<R2, E3, Z>,
-): IO<R & R1 & R2, E1 | E2 | E3, Z> {
+): IO<R | R1 | R2, E1 | E2 | E3, Z> {
   return self.exit.match((cause) => cause.flipCauseMaybe.match(() => end, error), value);
 }
 

package/_src/Supervisor/constructors.ts

@@ -1,12 +1,14 @@
 import type { AtomicReference } from "@fncts/base/internal/AtomicReference";
 
+import { IterableWeakSet } from "@fncts/base/collection/weak/IterableWeakSet";
+
 import { ConstSupervisor } from "./definition.js";
 
 /**
  * @tsplus static fncts.io.SupervisorOps unsafeTrack
  */
-export function unsafeTrack(): Supervisor<Conc<Fiber.Runtime<any, any>>> {
-  const set = new Set<Fiber.Runtime<any, any>>();
+export function unsafeTrack(weak: boolean): Supervisor<Conc<Fiber.Runtime<any, any>>> {
+  const set = weak ? new IterableWeakSet<Fiber.Runtime<any, any>>() : new Set<Fiber.Runtime<any, any>>();
   return new (class extends Supervisor<Conc<Fiber.Runtime<any, any>>> {
     value = IO.succeed(Conc.from(set));
     unsafeOnStart<R, E, A>(
@@ -62,4 +64,6 @@ export const none = new ConstSupervisor(IO.unit);
 /**
  * @tsplus static fncts.io.SupervisorOps track
  */
-export const track: UIO<Supervisor<Conc<Fiber.Runtime<any, any>>>> = IO.succeed(unsafeTrack());
+export function track(weak: boolean, __tsplusTrace?: string): UIO<Supervisor<Conc<Fiber.Runtime<any, any>>>> {
+  return IO.succeed(unsafeTrack(weak));
+}

package/_src/TFuture/api.ts

@@ -37,6 +37,6 @@ export function succeed_<E, A>(self: TFuture<E, A>, a: A): USTM<boolean> {
 /**
  * @tsplus getter fncts.io.TFuture await
  */
-export function wait<E, A>(self: TFuture<E, A>): STM<unknown, E, A> {
+export function wait<E, A>(self: TFuture<E, A>): STM<never, E, A> {
   return TFuture.reverseGet(self).get.filterMapSTM((mea) => mea.map(STM.fromEitherNow));
 }

package/_src/TFuture/definition.ts

@@ -1,7 +1,7 @@
 import type { UTRef } from "../TRef.js";
 
 interface TFutureN extends HKT {
-  readonly [HKT.T]: TFuture<HKT._E<this>, HKT._A<this>>;
+  readonly type: TFuture<this["E"], this["A"]>;
 }
 
 /**

package/_src/TReentrantLock/api.ts

@@ -107,14 +107,14 @@ export function withWriteLock<R, E, A>(self: TReentrantLock, io: IO<R, E, A>): I
 /**
  * @tsplus getter fncts.io.TReentrantLock readLock
  */
-export function readLock(self: TReentrantLock, __tsplusTrace?: string): IO<Has<Scope>, never, number> {
+export function readLock(self: TReentrantLock, __tsplusTrace?: string): IO<Scope, never, number> {
   return self.acquireRead.commit.acquireRelease(() => self.releaseRead.commit);
 }
 
 /**
  * @tsplus getter fncts.io.TReentrantLock writeLock
  */
-export function writeLock(self: TReentrantLock, __tsplusTrace?: string): IO<Has<Scope>, never, number> {
+export function writeLock(self: TReentrantLock, __tsplusTrace?: string): IO<Scope, never, number> {
   return self.acquireWrite.commit.acquireRelease(() => self.releaseWrite.commit);
 }
 

package/_src/TRef/api.ts

@@ -19,7 +19,7 @@ function getOrMakeEntry<A>(self: Atomic<A>, journal: Journal): Entry {
  *
  * @tsplus getter fncts.io.TRef get
  */
-export function get<EA, EB, A, B>(self: TRef<EA, EB, A, B>): STM<unknown, EB, B> {
+export function get<EA, EB, A, B>(self: TRef<EA, EB, A, B>): STM<never, EB, B> {
   concrete(self);
   switch (self._tag) {
     case "Atomic": {
@@ -47,7 +47,7 @@ export function get<EA, EB, A, B>(self: TRef<EA, EB, A, B>): STM<unknown, EB, B>
  *
  * @tsplus fluent fncts.io.TRef modify
  */
-export function modify_<E, A, B>(self: TRef<E, E, A, A>, f: (a: A) => readonly [B, A]): STM<unknown, E, B> {
+export function modify_<E, A, B>(self: TRef<E, E, A, A>, f: (a: A) => readonly [B, A]): STM<never, E, B> {
   concrete(self);
   switch (self._tag) {
     case "Atomic": {
@@ -99,7 +99,7 @@ export function modify_<E, A, B>(self: TRef<E, E, A, A>, f: (a: A) => readonly [
  *
  * @tsplus fluent fncts.io.TRef set
  */
-export function set_<EA, EB, A, B>(self: TRef<EA, EB, A, B>, a: A): STM<unknown, EA, void> {
+export function set_<EA, EB, A, B>(self: TRef<EA, EB, A, B>, a: A): STM<never, EA, void> {
   concrete(self);
   switch (self._tag) {
     case "Atomic": {
@@ -153,7 +153,7 @@ export function modifyJust_<E, A, B>(
   self: TRef<E, E, A, A>,
   b: B,
   f: (a: A) => Maybe<readonly [B, A]>,
-): STM<unknown, E, B> {
+): STM<never, E, B> {
   return self.modify((a) => f(a).getOrElse([b, a]));
 }
 
@@ -162,7 +162,7 @@ export function modifyJust_<E, A, B>(
  *
  * @tsplus fluent fncts.io.TRef getAndSet
  */
-export function getAndSet_<E, A>(self: TRef<E, E, A, A>, a: A): STM<unknown, E, A> {
+export function getAndSet_<E, A>(self: TRef<E, E, A, A>, a: A): STM<never, E, A> {
   concrete(self);
   switch (self._tag) {
     case "Atomic": {
@@ -184,7 +184,7 @@ export function getAndSet_<E, A>(self: TRef<E, E, A, A>, a: A): STM<unknown, E,
  *
  * @tsplus fluent fncts.io.TRef getAndUpdate
  */
-export function getAndUpdate_<E, A>(self: TRef<E, E, A, A>, f: (a: A) => A): STM<unknown, E, A> {
+export function getAndUpdate_<E, A>(self: TRef<E, E, A, A>, f: (a: A) => A): STM<never, E, A> {
   concrete(self);
   switch (self._tag) {
     case "Atomic": {
@@ -207,7 +207,7 @@ export function getAndUpdate_<E, A>(self: TRef<E, E, A, A>, f: (a: A) => A): STM
  *
  * @tsplus fluent fncts.io.TRef getAndUpdateJust
  */
-export function getAndUpdateJust_<E, A>(self: TRef<E, E, A, A>, f: (a: A) => Maybe<A>): STM<unknown, E, A> {
+export function getAndUpdateJust_<E, A>(self: TRef<E, E, A, A>, f: (a: A) => Maybe<A>): STM<never, E, A> {
   concrete(self);
   switch (self._tag) {
     case "Atomic": {
@@ -237,7 +237,7 @@ export function getAndUpdateJust_<E, A>(self: TRef<E, E, A, A>, f: (a: A) => May
  *
  * @tsplus fluent fncts.io.TRef update
  */
-export function update_<E, A>(self: TRef<E, E, A, A>, f: (a: A) => A): STM<unknown, E, void> {
+export function update_<E, A>(self: TRef<E, E, A, A>, f: (a: A) => A): STM<never, E, void> {
   concrete(self);
   switch (self._tag) {
     case "Atomic": {
@@ -257,7 +257,7 @@ export function update_<E, A>(self: TRef<E, E, A, A>, f: (a: A) => A): STM<unkno
  *
  * @tsplus fluent fncts.io.TRef updateJust
  */
-export function updateJust_<E, A>(self: TRef<E, E, A, A>, f: (a: A) => Maybe<A>): STM<unknown, E, void> {
+export function updateJust_<E, A>(self: TRef<E, E, A, A>, f: (a: A) => Maybe<A>): STM<never, E, void> {
   return self.update((a) => f(a).getOrElse(a));
 }
 
@@ -266,7 +266,7 @@ export function updateJust_<E, A>(self: TRef<E, E, A, A>, f: (a: A) => Maybe<A>)
  *
  * @tsplus fluent fncts.io.TRef updateAndGet
  */
-export function updateAndGet_<E, A>(self: TRef<E, E, A, A>, f: (a: A) => A): STM<unknown, E, A> {
+export function updateAndGet_<E, A>(self: TRef<E, E, A, A>, f: (a: A) => A): STM<never, E, A> {
   concrete(self);
   switch (self._tag) {
     case "Atomic": {
@@ -292,7 +292,7 @@ export function updateAndGet_<E, A>(self: TRef<E, E, A, A>, f: (a: A) => A): STM
  *
  * @tsplus fluent fncts.io.TRef updateJustAndGet
  */
-export function updateJustAndGet_<E, A>(self: TRef<E, E, A, A>, f: (a: A) => Maybe<A>): STM<unknown, E, A> {
+export function updateJustAndGet_<E, A>(self: TRef<E, E, A, A>, f: (a: A) => Maybe<A>): STM<never, E, A> {
   return self.updateAndGet((a) => f(a).getOrElse(a));
 }
 

package/_src/TRef/constructors.ts

@@ -13,7 +13,7 @@ import { Atomic } from "./definition.js";
  *
  * @tsplus static fncts.io.TRefOps makeNow
  */
-export function makeNow<A>(a: A): STM<unknown, never, UTRef<A>> {
+export function makeNow<A>(a: A): STM<never, never, UTRef<A>> {
   return new Effect((journal) => {
     const value     = a;
     const versioned = new Versioned(value);
@@ -29,7 +29,7 @@ export function makeNow<A>(a: A): STM<unknown, never, UTRef<A>> {
  *
  * @tsplus static fncts.io.TRefOps make
  */
-export function make<A>(a: Lazy<A>): STM<unknown, never, UTRef<A>> {
+export function make<A>(a: Lazy<A>): STM<never, never, UTRef<A>> {
   return new Effect((journal) => {
     const value     = a();
     const versioned = new Versioned(value);

package/_src/TSemaphore/api.ts

@@ -52,7 +52,7 @@ export function releaseN_(self: TSemaphore, n: number): USTM<void> {
 /**
  * @tsplus getter fncts.io.TSemaphore withPermits
  */
-export function withPermitsSelf(self: TSemaphore) {
+export function withPermits(self: TSemaphore) {
   return (n: number) =>
     <R, E, A>(io: IO<R, E, A>) =>
       IO.uninterruptibleMask(({ restore }) =>
@@ -63,6 +63,6 @@ export function withPermitsSelf(self: TSemaphore) {
 /**
  * @tsplus getter fncts.io.TSemaphore withPermit
  */
-export function withPermitSelf(self: TSemaphore) {
+export function withPermit(self: TSemaphore) {
   return <R, E, A>(io: IO<R, E, A>) => self.withPermits(1)(io);
 }

package/_src/TSemaphore/definition.ts

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

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

@@ -0,0 +1,24 @@
+/**
+ * @tsplus fluent fncts.Conc dropUntilIO
+ */
+export function dropUntilIO<A, R, E>(
+  self: Conc<A>,
+  p: (a: A) => IO<R, E, boolean>,
+  __tsplusTrace?: string,
+): 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());
+  });
+}

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

@@ -0,0 +1,26 @@
+/**
+ * @tsplus fluent fncts.Conc dropWhileIO
+ */
+export function dropWhileIO<A, R, E>(
+  self: Conc<A>,
+  p: (a: A) => IO<R, E, boolean>,
+  __tsplusTrace?: string,
+): 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());
+  });
+}

package/_src/internal/Scheduler.ts

@@ -1,15 +1,59 @@
-let isRunning = false;
-const tasks   = new ListBuffer<() => void>();
-
-export const defaultScheduler: (thunk: () => void) => void = (thunk) => {
-  tasks.append(thunk);
-  if (!isRunning) {
-    isRunning = true;
-    Promise.resolve().then(() => {
-      while (tasks.length > 0) {
-        tasks.unprepend()!();
-      }
-      isRunning = false;
-    });
-  }
-};
+export interface Scheduler {
+  scheduleTask(task: () => void): void;
+}
+
+export class AsyncScheduler implements Scheduler {
+  private running = false;
+  private tasks   = new ListBuffer<() => void>();
+
+  private starveInternal(depth: number) {
+    const toRun = this.tasks;
+    this.tasks  = new ListBuffer();
+    for (const task of toRun) {
+      task();
+    }
+    if (this.tasks.isEmpty) {
+      this.running = false;
+    } else {
+      this.starve(depth);
+    }
+  }
+
+  starve(depth = 0) {
+    if (depth >= 2048) {
+      setTimeout(() => this.starveInternal(0), 0);
+    } else {
+      queueMicrotask(() => this.starveInternal(depth + 1));
+    }
+  }
+
+  scheduleTask(task: () => void) {
+    this.tasks.append(task);
+    if (!this.running) {
+      this.running = true;
+      this.starve();
+    }
+  }
+}
+
+export const defaultScheduler: Scheduler = new AsyncScheduler();
+
+export class StagedScheduler implements Scheduler {
+  private tasks    = new ListBuffer<() => void>();
+  private deferred = false;
+
+  scheduleTask(task: () => void) {
+    if (this.deferred) {
+      defaultScheduler.scheduleTask(task);
+    } else {
+      this.tasks.append(task);
+    }
+  }
+
+  flush() {
+    while (!this.tasks.isEmpty) {
+      this.tasks.unprepend()();
+    }
+    this.deferred = true;
+  }
+}

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

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

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

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

package/internal/Scheduler.d.ts

@@ -1 +1,18 @@
-export declare const defaultScheduler: (thunk: () => void) => void;
+import { ListBuffer } from "@fncts/base/collection/mutable/ListBuffer";
+export interface Scheduler {
+    scheduleTask(task: () => void): void;
+}
+export declare class AsyncScheduler implements Scheduler {
+    private running;
+    private tasks;
+    private starveInternal;
+    starve(depth?: number): void;
+    scheduleTask(task: () => void): void;
+}
+export declare const defaultScheduler: Scheduler;
+export declare class StagedScheduler implements Scheduler {
+    private tasks;
+    private deferred;
+    scheduleTask(task: () => void): void;
+    flush(): void;
+}

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@fncts/io",
-  "version": "0.0.10",
+  "version": "0.0.13",
   "dependencies": {
-    "@fncts/base": "0.0.10",
-    "@fncts/typelevel": "0.0.8"
+    "@fncts/base": "0.0.13",
+    "@fncts/typelevel": "0.0.11"
   },
   "exports": {
     "./*": {