@fncts/io 0.0.20 → 0.0.22

package/_src/TRef/definition.ts

@@ -1,8 +1,12 @@
-import type { Todo } from "../STM/internal/Journal.js";
-import type { Versioned } from "../STM/internal/Versioned.js";
 import type { AtomicReference } from "@fncts/base/internal/AtomicReference";
+import type { Journal, Todo } from "@fncts/io/STM/internal/Journal";
+import type { Versioned } from "@fncts/io/STM/internal/Versioned";
 import type { TxnId } from "@fncts/io/TxnId";
 
+import { STM } from "@fncts/io/STM";
+import { Effect } from "@fncts/io/STM";
+import { Entry } from "@fncts/io/STM/internal/Entry";
+import { _A, _B, _EA, _EB } from "@fncts/io/TRef/symbols";
 export const TRefTypeId = Symbol.for("fncts.io.TRef");
 export type TRefTypeId = typeof TRefTypeId;
 
@@ -23,14 +27,19 @@ export type TRefTypeId = typeof TRefTypeId;
  *
  * @tsplus type fncts.io.TRef
  */
-export interface TRef<EA, EB, A, B> {
+export interface PTRef<out EA, out EB, in A, out B> {
   readonly _typeId: TRefTypeId;
-  readonly _EA: () => EA;
-  readonly _EB: () => EB;
-  readonly _A: (_: A) => void;
-  readonly _B: () => B;
+  readonly [_EA]: () => EA;
+  readonly [_EB]: () => EB;
+  readonly [_A]: (_: A) => void;
+  readonly [_B]: () => B;
 }
 
+/**
+ * @tsplus type fncts.io.TRef
+ */
+export type TRef<A> = PTRef<never, never, A, A>;
+
 /**
  * @tsplus type fncts.io.TRefOps
  */
@@ -38,72 +47,91 @@ export interface TRefOps {}
 
 export const TRef: TRefOps = {};
 
-export abstract class TRefInternal<EA, EB, A, B> implements TRef<EA, EB, A, B> {
+export abstract class TRefInternal<EA, EB, A, B> implements PTRef<EA, EB, A, B> {
   readonly _typeId: TRefTypeId = TRefTypeId;
-  readonly _EA!: () => EA;
-  readonly _EB!: () => EB;
-  readonly _A!: (_: A) => void;
-  readonly _B!: () => B;
-
+  declare [_EA]: () => EA;
+  declare [_EB]: () => EB;
+  declare [_A]: (_: A) => void;
+  declare [_B]: () => B;
+  abstract get: STM<never, EB, B>;
+  abstract modify<C>(f: (b: B) => readonly [C, A], __tsplusTrace?: string): STM<never, EA | EB, C>;
+  abstract set(a: A, __tsplusTrace?: string): STM<never, EA, void>;
+  abstract unsafeGet(journal: Journal, __tsplusTrace?: string): A;
+  abstract unsafeSet(journal: Journal, a: A, __tsplusTrace?: string): void;
   abstract match<EC, ED, C, D>(
     ea: (ea: EA) => EC,
     eb: (ea: EB) => ED,
     ca: (c: C) => Either<EC, A>,
     bd: (b: B) => Either<ED, D>,
-  ): TRef<EC, ED, C, D>;
-
+  ): PTRef<EC, ED, C, D>;
   abstract matchAll<EC, ED, C, D>(
     ea: (ea: EA) => EC,
     eb: (ea: EB) => ED,
     ec: (ea: EB) => EC,
     ca: (c: C) => (b: B) => Either<EC, A>,
     bd: (b: B) => Either<ED, D>,
-  ): TRef<EC, ED, C, D>;
+  ): PTRef<EC, ED, C, D>;
 }
 
-/**
- * @tsplus type fncts.io.TRef
- */
-export interface UTRef<A> extends TRef<never, never, A, A> {}
-
-/**
- * @tsplus type fncts.io.TRef
- */
-export interface ETRef<E, A> extends TRef<E, E, A, A> {}
-
 export class Atomic<A> extends TRefInternal<never, never, A, A> {
   readonly _typeId: TRefTypeId     = TRefTypeId;
-  readonly _tag                    = "Atomic";
   readonly atomic: Atomic<unknown> = this as Atomic<unknown>;
-
   constructor(public versioned: Versioned<A>, readonly todo: AtomicReference<HashMap<TxnId, Todo>>) {
     super();
   }
-
   match<EC, ED, C, D>(
     _ea: (ea: never) => EC,
     _eb: (ea: never) => ED,
     ca: (c: C) => Either<EC, A>,
     bd: (b: A) => Either<ED, D>,
-  ): TRef<EC, ED, C, D> {
+  ): PTRef<EC, ED, C, D> {
     return new Derived((f) => f(bd, ca, this, this.atomic));
   }
-
   matchAll<EC, ED, C, D>(
     _ea: (ea: never) => EC,
     _eb: (ea: never) => ED,
     _ec: (ea: never) => EC,
     ca: (c: C) => (b: A) => Either<EC, A>,
     bd: (b: A) => Either<ED, D>,
-  ): TRef<EC, ED, C, D> {
+  ): PTRef<EC, ED, C, D> {
     return new DerivedAll((f) => f(bd, ca, this, this.atomic));
   }
+
+  get get(): STM<never, never, A> {
+    return new Effect((journal) => {
+      const entry = getOrMakeEntry(this, journal);
+      return entry.use((_) => _.unsafeGet<A>());
+    });
+  }
+
+  set(a: A, __tsplusTrace?: string | undefined): STM<never, never, void> {
+    return new Effect((journal) => {
+      const entry = getOrMakeEntry(this, journal);
+      return entry.use((_) => _.unsafeSet(a));
+    });
+  }
+
+  modify<C>(f: (b: A) => readonly [C, A], __tsplusTrace?: string | undefined): STM<never, never, C> {
+    return new Effect((journal) => {
+      const entry                = getOrMakeEntry(this, journal);
+      const oldValue             = entry.use((_) => _.unsafeGet<A>());
+      const [retValue, newValue] = f(oldValue);
+      entry.use((_) => _.unsafeSet(newValue));
+      return retValue;
+    });
+  }
+
+  unsafeGet(journal: Journal, __tsplusTrace?: string | undefined): A {
+    return getOrMakeEntry(this.atomic, journal).use((entry) => entry.unsafeGet<A>());
+  }
+
+  unsafeSet(journal: Journal, a: A, __tsplusTrace?: string | undefined): void {
+    return getOrMakeEntry(this.atomic, journal).use((entry) => entry.unsafeSet(a));
+  }
 }
 
 export class Derived<EA, EB, A, B> extends TRefInternal<EA, EB, A, B> {
   readonly _typeId: TRefTypeId = TRefTypeId;
-  readonly _tag                = "Derived";
-
   constructor(
     readonly use: <X>(
       f: <S>(
@@ -116,13 +144,12 @@ export class Derived<EA, EB, A, B> extends TRefInternal<EA, EB, A, B> {
   ) {
     super();
   }
-
   match<EC, ED, C, D>(
     ea: (ea: EA) => EC,
     eb: (ea: EB) => ED,
     ca: (c: C) => Either<EC, A>,
     bd: (b: B) => Either<ED, D>,
-  ): TRef<EC, ED, C, D> {
+  ): PTRef<EC, ED, C, D> {
     return this.use(
       (getEither, setEither, value, atomic) =>
         new Derived((f) =>
@@ -135,14 +162,13 @@ export class Derived<EA, EB, A, B> extends TRefInternal<EA, EB, A, B> {
         ),
     );
   }
-
   matchAll<EC, ED, C, D>(
     ea: (ea: EA) => EC,
     eb: (ea: EB) => ED,
     ec: (ea: EB) => EC,
     ca: (c: C) => (b: B) => Either<EC, A>,
     bd: (b: B) => Either<ED, D>,
-  ): TRef<EC, ED, C, D> {
+  ): PTRef<EC, ED, C, D> {
     return this.use(
       (getEither, setEither, value, atomic) =>
         new DerivedAll((f) =>
@@ -158,12 +184,49 @@ export class Derived<EA, EB, A, B> extends TRefInternal<EA, EB, A, B> {
         ),
     );
   }
+
+  get get(): STM<never, EB, B> {
+    return this.use((getEither, _setEither, value, _atomic) =>
+      value.get.flatMap((s) => getEither(s).match(STM.failNow, STM.succeedNow)),
+    );
+  }
+
+  set(a: A, __tsplusTrace?: string | undefined): STM<never, EA, void> {
+    return this.use((_getEither, setEither, value, _atomic) => setEither(a).match(STM.failNow, (s) => value.set(s)));
+  }
+
+  modify<C>(f: (b: B) => readonly [C, A], __tsplusTrace?: string | undefined): STM<never, EA | EB, C> {
+    return this.use((getEither, setEither, value, _atomic) =>
+      value.modify((s) =>
+        getEither(s).match(
+          (e) => [Either.left<EA | EB, C>(e), s],
+          (a1) => {
+            const [b, a2] = f(a1);
+            return setEither(a2).match(
+              (e) => [Either.left(e), s],
+              (s) => [Either.right(b), s],
+            );
+          },
+        ),
+      ),
+    ).absolve;
+  }
+
+  unsafeGet(journal: Journal, __tsplusTrace?: string | undefined): A {
+    return this.use((_getEither, _setEither, _value, atomic) => getOrMakeEntry(atomic, journal)).use((entry) =>
+      entry.unsafeGet(),
+    );
+  }
+
+  unsafeSet(journal: Journal, a: A, __tsplusTrace?: string | undefined): void {
+    return this.use((_getEither, _setEither, _value, atomic) => getOrMakeEntry(atomic, journal)).use((entry) =>
+      entry.unsafeSet(a),
+    );
+  }
 }
 
 export class DerivedAll<EA, EB, A, B> extends TRefInternal<EA, EB, A, B> {
   readonly _typeId: TRefTypeId = TRefTypeId;
-  readonly _tag                = "DerivedAll";
-
   constructor(
     readonly use: <X>(
       f: <S>(
@@ -176,13 +239,12 @@ export class DerivedAll<EA, EB, A, B> extends TRefInternal<EA, EB, A, B> {
   ) {
     super();
   }
-
   match<EC, ED, C, D>(
     ea: (ea: EA) => EC,
     eb: (ea: EB) => ED,
     ca: (c: C) => Either<EC, A>,
     bd: (b: B) => Either<ED, D>,
-  ): TRef<EC, ED, C, D> {
+  ): PTRef<EC, ED, C, D> {
     return this.use(
       (getEither, setEither, value, atomic) =>
         new DerivedAll((f) =>
@@ -195,14 +257,13 @@ export class DerivedAll<EA, EB, A, B> extends TRefInternal<EA, EB, A, B> {
         ),
     );
   }
-
   matchAll<EC, ED, C, D>(
     ea: (ea: EA) => EC,
     eb: (ea: EB) => ED,
     ec: (ea: EB) => EC,
     ca: (c: C) => (b: B) => Either<EC, A>,
     bd: (b: B) => Either<ED, D>,
-  ): TRef<EC, ED, C, D> {
+  ): PTRef<EC, ED, C, D> {
     return this.use(
       (getEither, setEither, value, atomic) =>
         new DerivedAll((f) =>
@@ -218,13 +279,68 @@ export class DerivedAll<EA, EB, A, B> extends TRefInternal<EA, EB, A, B> {
         ),
     );
   }
+
+  get get(): STM<never, EB, B> {
+    return this.use((getEither, _setEither, value, _atomic) =>
+      value.get.flatMap((s) => getEither(s).match(STM.failNow, STM.succeedNow)),
+    );
+  }
+
+  set(a: A, __tsplusTrace?: string | undefined): STM<never, EA, void> {
+    return this.use((_getEither, setEither, value, _atomic) =>
+      value.modify((s) =>
+        setEither(a)(s).match(
+          (e) => [Either.left(e), s] as [Either<EA, void>, typeof s],
+          (s) => [Either.right(undefined), s],
+        ),
+      ),
+    ).absolve;
+  }
+
+  modify<C>(f: (b: B) => readonly [C, A], __tsplusTrace?: string | undefined): STM<never, EA | EB, C> {
+    return this.use((getEither, setEither, value, atomic) =>
+      value.modify((s) =>
+        getEither(s).match(
+          (e) => [Either.left<EA | EB, C>(e), s],
+          (a1) => {
+            const [b, a2] = f(a1);
+            return setEither(a2)(s).match(
+              (e) => [Either.left(e), s],
+              (s) => [Either.right(b), s],
+            );
+          },
+        ),
+      ),
+    ).absolve;
+  }
+
+  unsafeGet(journal: Journal, __tsplusTrace?: string | undefined): A {
+    return this.use((_getEither, _setEither, _value, atomic) => getOrMakeEntry(atomic, journal)).use((entry) =>
+      entry.unsafeGet(),
+    );
+  }
+
+  unsafeSet(journal: Journal, a: A, __tsplusTrace?: string | undefined): void {
+    return this.use((_getEither, _setEither, _value, atomic) => getOrMakeEntry(atomic, journal)).use((entry) =>
+      entry.unsafeSet(a),
+    );
+  }
 }
 
 /**
  * @tsplus macro remove
  */
 export function concrete<EA, EB, A, B>(
-  _: TRef<EA, EB, A, B>,
+  _: PTRef<EA, EB, A, B>,
 ): asserts _ is (Atomic<A> & Atomic<B>) | Derived<EA, EB, A, B> | DerivedAll<EA, EB, A, B> {
   //
 }
+
+function getOrMakeEntry<A>(self: Atomic<A>, journal: Journal, __tsplusTrace?: string): Entry {
+  if (journal.has(self)) {
+    return journal.get(self)!;
+  }
+  const entry = Entry.make(self, false);
+  journal.set(self, entry);
+  return entry;
+}

package/_src/TRef/symbols.ts

@@ -0,0 +1,19 @@
+/**
+ * @tsplus static fncts.io.TRefOps _EA
+ */
+export const _EA: unique symbol = Symbol();
+
+/**
+ * @tsplus static fncts.io.TRefOps _EB
+ */
+export const _EB: unique symbol = Symbol();
+
+/**
+ * @tsplus static fncts.io.TRefOps _A
+ */
+export const _A: unique symbol = Symbol();
+
+/**
+ * @tsplus static fncts.io.TRefOps _B
+ */
+export const _B: unique symbol = Symbol();

package/_src/TRef.ts

@@ -2,4 +2,5 @@
 export * from "./TRef/api.js";
 export * from "./TRef/constructors.js";
 export * from "./TRef/definition.js";
+export * from "./TRef/symbols.js";
 // codegen:end

package/_src/TSemaphore/api.ts

@@ -10,17 +10,17 @@ export function acquire(self: TSemaphore, __tsplusTrace?: string): USTM<void> {
 }
 
 /**
- * @tsplus fluent fncts.io.TSemaphore acquireN
+ * @tsplus pipeable fncts.io.TSemaphore acquireN
  */
-export function acquireN_(self: TSemaphore, n: number, __tsplusTrace?: string): USTM<void> {
-  return new Effect((journal) => {
-    assert(n >= 0, "Negative permits given to TSemaphore#acquire");
-
-    const value = TSemaphore.reverseGet(self).unsafeGet(journal);
-
-    if (value < n) throw new RetryException();
-    else return TSemaphore.reverseGet(self).unsafeSet(journal, value - n);
-  });
+export function acquireN(n: number, __tsplusTrace?: string) {
+  return (self: TSemaphore): USTM<void> => {
+    return new Effect((journal) => {
+      assert(n >= 0, "Negative permits given to TSemaphore#acquireN");
+      const value = TSemaphore.reverseGet(self).unsafeGet(journal);
+      if (value < n) throw new RetryException();
+      else return TSemaphore.reverseGet(self).unsafeSet(journal, value - n);
+    });
+  };
 }
 
 /**
@@ -38,15 +38,16 @@ export function release(self: TSemaphore, __tsplusTrace?: string): USTM<void> {
 }
 
 /**
- * @tsplus fluent fncts.io.TSemaphore releaseN
+ * @tsplus pipeable fncts.io.TSemaphore releaseN
  */
-export function releaseN_(self: TSemaphore, n: number, __tsplusTrace?: string): USTM<void> {
-  return new Effect((journal) => {
-    assert(n >= 0, "Negative permits given to TSemaphore#releaseN");
-
-    const current = TSemaphore.reverseGet(self).unsafeGet(journal);
-    TSemaphore.reverseGet(self).unsafeSet(journal, current + n);
-  });
+export function releaseN(n: number, __tsplusTrace?: string) {
+  return (self: TSemaphore): USTM<void> => {
+    return new Effect((journal) => {
+      assert(n >= 0, "Negative permits given to TSemaphore#releaseN");
+      const current = TSemaphore.reverseGet(self).unsafeGet(journal);
+      TSemaphore.reverseGet(self).unsafeSet(journal, current + n);
+    });
+  };
 }
 
 /**
@@ -56,7 +57,7 @@ export function withPermits(self: TSemaphore, __tsplusTrace?: string) {
   return (n: number) =>
     <R, E, A>(io: IO<R, E, A>) =>
       IO.uninterruptibleMask(({ restore }) =>
-        restore(self.acquireN(n).commit).apSecond(restore(io).ensuring(self.releaseN(n).commit)),
+        restore(self.acquireN(n).commit).zipRight(restore(io).ensuring(self.releaseN(n).commit)),
       );
 }
 

package/_src/TSemaphore/constructors.ts

@@ -6,6 +6,13 @@ export function make(permits: number, __tsplusTrace?: string): USTM<TSemaphore>
   return TRef.make(permits).map((ref) => TSemaphore.get(ref));
 }
 
+/**
+ * @tsplus static fncts.io.TSemaphoreOps makeCommit
+ */
+export function makeCommit(permits: number, __tsplusTrace?: string): UIO<TSemaphore> {
+  return TSemaphore(permits).commit;
+}
+
 /**
  * @tsplus static fncts.io.TSemaphoreOps unsafeMake
  */

package/_src/TSemaphore/definition.ts

@@ -10,7 +10,7 @@ export interface TSemaphore
     {
       readonly TSemaphore: unique symbol;
     },
-    UTRef<number>
+    TRef<number>
   > {}
 
 /**

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

@@ -1,24 +1,22 @@
 /**
- * @tsplus fluent fncts.Conc dropUntilIO
+ * @tsplus pipeable 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());
-  });
+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());
+    });
+  };
 }

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

@@ -1,26 +1,24 @@
 /**
- * @tsplus fluent fncts.Conc dropWhileIO
+ * @tsplus pipeable 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());
-  });
+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());
+    });
+  };
 }

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

@@ -1,20 +1,18 @@
 /**
- * @tsplus fluent fncts.Conc filterIO
+ * @tsplus pipeable fncts.Conc filterIO
  */
-export function filterIO<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 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());
-  });
+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());
+    });
+  };
 }

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

@@ -1,6 +1,6 @@
 import { concrete } from "@fncts/base/collection/immutable/Conc";
 
-function findIOLoop_<R, E, A>(
+function findIOLoop<R, E, A>(
   iterator: Iterator<ArrayLike<A>>,
   f: (a: A) => IO<R, E, boolean>,
   array: ArrayLike<A>,
@@ -10,33 +10,31 @@ function findIOLoop_<R, E, A>(
 ): IO<R, E, Maybe<A>> {
   if (i < length) {
     const a = array[i]!;
-    return f(a).flatMap((b) => (b ? IO.succeedNow(Just(a)) : findIOLoop_(iterator, f, array, i + 1, length)));
+    return f(a).flatMap((b) => (b ? IO.succeedNow(Just(a)) : findIOLoop(iterator, f, array, i + 1, length)));
   }
   let result;
   if (!(result = iterator.next()).done) {
     const arr = result.value;
     const len = arr.length;
-    return findIOLoop_(iterator, f, arr, 0, len);
+    return findIOLoop(iterator, f, arr, 0, len);
   }
   return IO.succeedNow(Nothing());
 }
 
 /**
- * @tsplus fluent fncts.Conc findIO
+ * @tsplus pipeable fncts.Conc findIO
  */
-export function findIO_<R, E, A>(
-  as: Conc<A>,
-  f: (a: A) => IO<R, E, boolean>,
-  __tsplusTrace?: string,
-): IO<R, E, Maybe<A>> {
-  concrete(as);
-  const iterator = as.arrayIterator();
-  let result;
-  if (!(result = iterator.next()).done) {
-    const array  = result.value;
-    const length = array.length;
-    return findIOLoop_(iterator, f, array, 0, length);
-  } else {
-    return IO.succeedNow(Nothing());
-  }
+export function findIO<R, E, A>(f: (a: A) => IO<R, E, boolean>, __tsplusTrace?: string) {
+  return (as: Conc<A>): IO<R, E, Maybe<A>> => {
+    concrete(as);
+    const iterator = as.arrayIterator();
+    let result;
+    if (!(result = iterator.next()).done) {
+      const array  = result.value;
+      const length = array.length;
+      return findIOLoop(iterator, f, array, 0, length);
+    } else {
+      return IO.succeedNow(Nothing());
+    }
+  };
 }

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

@@ -1,13 +1,15 @@
 /**
- * @tsplus fluent fncts.Conc mapIO
+ * @tsplus pipeable fncts.Conc mapIO
  */
-export function mapIO_<A, R, E, B>(as: Conc<A>, f: (a: A) => IO<R, E, B>, __tsplusTrace?: string): 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());
-  });
+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());
+    });
+  };
 }