@fncts/io 0.0.49 → 0.0.50

package/_src/Push/Producer/SyncProducer.ts

@@ -0,0 +1,105 @@
+import type { Push } from "@fncts/io/Push";
+
+export const enum SyncProducerTag {
+  Success,
+  FromSync,
+  FromArray,
+  FromIterable,
+}
+
+/**
+ * @tsplus type fncts.io.Push.SyncProducer
+ * @tsplus companion fncts.io.Push.SyncProducerOps
+ */
+export type SyncProducer<A> = Success<A> | FromSync<A> | FromArray<A> | FromIterable<A>;
+
+export class Success<A> {
+  readonly _tag = SyncProducerTag.Success;
+  constructor(readonly source: A) {}
+}
+
+export class FromSync<A> {
+  readonly _tag = SyncProducerTag.FromSync;
+  constructor(readonly f: Lazy<A>) {}
+}
+
+export class FromArray<A> {
+  readonly _tag = SyncProducerTag.FromArray;
+  constructor(readonly array: ReadonlyArray<A>) {}
+}
+
+export class FromIterable<A> {
+  readonly _tag = SyncProducerTag.FromIterable;
+  constructor(readonly iterable: Iterable<A>) {}
+}
+
+/**
+ * @tsplus static fncts.io.Push.SyncProducerOps Success
+ */
+export function success<A>(source: A): SyncProducer<A> {
+  return new Success(source);
+}
+
+/**
+ * @tsplus static fncts.io.Push.SyncProducerOps fromSync
+ */
+export function fromSync<A>(f: Lazy<A>): SyncProducer<A> {
+  return new FromSync(f);
+}
+
+/**
+ * @tsplus static fncts.io.Push.SyncProducerOps fromArray
+ */
+export function fromArray<A extends ReadonlyArray<any>>(array: A): SyncProducer<A[number]> {
+  return new FromArray(array);
+}
+
+/**
+ * @tsplus static fncts.io.Push.SyncProducerOps fromIterable
+ */
+export function fromIterable<A>(iterable: Iterable<A>): SyncProducer<A> {
+  return new FromIterable(iterable);
+}
+
+export function syncOnce<A>(f: () => A): UIO<A> {
+  let memoized: Maybe<A> = Nothing();
+  const get              = () => {
+    if (memoized.isJust()) {
+      return memoized.value;
+    } else {
+      const a  = f();
+      memoized = Just(a);
+      return a;
+    }
+  };
+
+  return IO(get);
+}
+
+/**
+ * @tsplus fluent fncts.io.Push.SyncProducer runSink
+ */
+export function runSink<R, E, A>(self: SyncProducer<A>, sink: Push.UnsafeSink<R, E, A>): IO<R, never, unknown> {
+  switch (self._tag) {
+    case SyncProducerTag.Success:
+      return sink.onSuccess(self.source);
+    case SyncProducerTag.FromSync:
+      return IO.defer(() => sink.onSuccess(self.f()));
+    case SyncProducerTag.FromArray:
+      return arrayToSink(self.array, sink);
+    case SyncProducerTag.FromIterable:
+      return iterableToSink(self.iterable, sink);
+  }
+}
+
+function arrayToSink<A, R>(array: ReadonlyArray<A>, sink: Push.UnsafeSink<R, never, A>): IO<R, never, unknown> {
+  if (array.length === 0) return IO.unit;
+  else if (array.length === 1) return sink.onSuccess(array[0]);
+  else {
+    return array.mapIO((a) => sink.onSuccess(a));
+  }
+}
+
+function iterableToSink<A, R>(iterable: Iterable<A>, sink: Push.UnsafeSink<R, never, A>): IO<R, never, unknown> {
+  return IO.foreach(iterable, (a) => sink.onSuccess(a));
+}

package/_src/Push/Sink.ts

@@ -0,0 +1,302 @@
+import type { Cause } from "@fncts/base/data/Cause";
+
+import { IO } from "@fncts/io/IO";
+
+interface SinkN extends HKT {
+  readonly type: Sink<this["I"], this["R"], this["E"], this["A"]>;
+  readonly variance: {
+    I: "+";
+    R: "+";
+    E: "-";
+    A: "-";
+  };
+}
+
+/**
+ * @tsplus type fncts.io.Push.Sink
+ */
+export interface Sink<Env, R, E, A> extends Newtype<{ readonly Sink: unique symbol }, URIO<Env, UnsafeSink<R, E, A>>> {}
+
+/**
+ * @tsplus type fncts.io.Push.SinkOps
+ */
+export interface SinkOps extends NewtypeIso<SinkN> {}
+
+export const Sink: SinkOps = Newtype<SinkN>();
+
+/**
+ * @tsplus type fncts.io.Push.Sink
+ * @tsplus companion fncts.io.Push.SinkOps
+ */
+export abstract class UnsafeSink<R, in E, in A> {
+  abstract onSuccess(value: A): IO<R, never, void>;
+  abstract onFailure(cause: Cause<E>): IO<R, never, void>;
+}
+
+/**
+ * @tsplus static fncts.io.Push.SinkOps unsafeMake
+ */
+export function unsafeMakeSink<R, E, A>(
+  onSuccess: (value: A) => IO<R, never, unknown>,
+  onFailure: (cause: Cause<E>) => IO<R, never, unknown>,
+): UnsafeSink<R, E, A> {
+  return new (class extends UnsafeSink<R, E, A> {
+    onSuccess = onSuccess;
+    onFailure = onFailure;
+  })();
+}
+
+/**
+ * @tsplus static fncts.io.Push.SinkOps __call
+ */
+export function makeSink<R, E, A>(
+  onSuccess: (value: A) => IO<R, never, unknown>,
+  onFailure: (cause: Cause<E>) => IO<R, never, unknown>,
+): Sink<never, R, E, A> {
+  return Sink.get(IO(Sink.unsafeMake(onSuccess, onFailure)));
+}
+
+export class WithEarlyExit<R, E, A> extends UnsafeSink<R, E, A> {
+  constructor(
+    readonly onSuccess: (value: A) => IO<R, never, void>,
+    readonly onFailure: (cause: Cause<E>) => IO<R, never, void>,
+    readonly earlyExit: UIO<void>,
+  ) {
+    super();
+  }
+}
+
+/**
+ * @tsplus static fncts.io.Push.SinkOps withEarlyExit
+ */
+export function withEarlyExit<R, E, A, R1, B>(
+  sink: UnsafeSink<R, E, A>,
+  f: (sink: WithEarlyExit<R, E, A>) => IO<R1, E, B>,
+): IO<R | R1, never, void> {
+  return IO.asyncIO((resume) => {
+    const earlyExit = new WithEarlyExit<R, E, A>(
+      (value) => sink.onSuccess(value),
+      (cause) => sink.onFailure(cause),
+      IO(resume(IO.unit)),
+    );
+
+    return f(earlyExit).matchCauseIO(
+      (cause) => sink.onFailure(cause),
+      () => earlyExit.earlyExit,
+    );
+  });
+}
+
+class ProvideSomeEnvironmentSink<R, E, A, R1> extends UnsafeSink<Exclude<R, R1>, E, A> {
+  constructor(
+    readonly sink: UnsafeSink<R, E, A>,
+    readonly environment: Environment<R1>,
+  ) {
+    super();
+    this.onFailure = this.onFailure.bind(this);
+    this.onSuccess = this.onSuccess.bind(this);
+  }
+
+  onFailure(cause: Cause<E>) {
+    return this.sink.onFailure(cause).provideSomeEnvironment(this.environment);
+  }
+
+  onSuccess(value: A) {
+    return this.sink.onSuccess(value).provideSomeEnvironment(this.environment);
+  }
+}
+
+/**
+ * @tsplus pipeable fncts.io.Push.Sink provideSomeEnvironment
+ */
+export function provideSomeEnvironment<R1>(environment: Environment<R1>) {
+  return <Env, R, E, A>(self: Sink<Env, R, E, A>): Sink<Env, Exclude<R, R1>, E, A> => {
+    return Sink.get(Sink.reverseGet(self).map((sink) => new ProvideSomeEnvironmentSink(sink, environment)));
+  };
+}
+
+class MapSink<R, E, A, B> extends UnsafeSink<R, E, A> {
+  constructor(
+    readonly sink: UnsafeSink<R, E, B>,
+    readonly f: (a: A) => B,
+  ) {
+    super();
+    this.onFailure = this.onFailure.bind(this);
+    this.onSuccess = this.onSuccess.bind(this);
+  }
+
+  onFailure(cause: Cause<E>): IO<R, never, unknown> {
+    return this.sink.onFailure(cause);
+  }
+
+  onSuccess(value: A) {
+    return this.sink.onSuccess(this.f(value));
+  }
+}
+
+class FilterSink<R, E, A> extends UnsafeSink<R, E, A> {
+  constructor(
+    readonly sink: UnsafeSink<R, E, A>,
+    readonly predicate: Predicate<A>,
+  ) {
+    super();
+    this.onFailure = this.onFailure.bind(this);
+    this.onSuccess = this.onSuccess.bind(this);
+  }
+
+  onFailure(cause: Cause<E>) {
+    return this.sink.onFailure(cause);
+  }
+
+  onSuccess(value: A) {
+    if (this.predicate(value)) {
+      return this.sink.onSuccess(value);
+    } else {
+      return IO.unit;
+    }
+  }
+}
+
+class FilterMapSink<R, E, A, B> extends UnsafeSink<R, E, A> {
+  constructor(
+    readonly sink: UnsafeSink<R, E, B>,
+    readonly f: (a: A) => Maybe<B>,
+  ) {
+    super();
+    this.onFailure = this.onFailure.bind(this);
+    this.onSuccess = this.onSuccess.bind(this);
+  }
+
+  onFailure(cause: Cause<E>) {
+    return this.sink.onFailure(cause);
+  }
+
+  onSuccess(value: A) {
+    return this.f(value).match(
+      () => IO.unit,
+      (b) => this.sink.onSuccess(b),
+    );
+  }
+}
+
+class MapIOSink<R, E, A, R1, E1, B> extends UnsafeSink<R | R1, E1, B> {
+  constructor(
+    readonly sink: UnsafeSink<R, E | E1, A>,
+    readonly f: (b: B) => IO<R1, E1, A>,
+  ) {
+    super();
+    this.onFailure = this.onFailure.bind(this);
+    this.onSuccess = this.onSuccess.bind(this);
+  }
+
+  onFailure(cause: Cause<E1>) {
+    return this.sink.onFailure(cause);
+  }
+
+  onSuccess(value: B) {
+    return this.f(value).matchCauseIO(
+      (cause) => this.sink.onFailure(cause),
+      (a) => this.sink.onSuccess(a),
+    );
+  }
+}
+
+class FilterMapIOSink<R, E, A, R1, E1, B> extends UnsafeSink<R | R1, E1, B> {
+  constructor(
+    readonly sink: UnsafeSink<R, E | E1, A>,
+    readonly f: (b: B) => IO<R1, E1, Maybe<A>>,
+  ) {
+    super();
+    this.onFailure = this.onFailure.bind(this);
+    this.onSuccess = this.onSuccess.bind(this);
+  }
+
+  onFailure(cause: Cause<E1>) {
+    return this.sink.onFailure(cause);
+  }
+
+  onSuccess(value: B) {
+    return this.f(value).matchCauseIO(
+      (cause) => this.sink.onFailure(cause),
+      (ma) =>
+        ma.match(
+          () => IO.unit,
+          (a) => this.sink.onSuccess(a),
+        ),
+    );
+  }
+}
+
+class FilterIOSink<R, E, A> extends UnsafeSink<R, E, A> {
+  constructor(
+    readonly sink: UnsafeSink<R, E, A>,
+    readonly f: (a: A) => IO<R, E, boolean>,
+  ) {
+    super();
+    this.onFailure = this.onFailure.bind(this);
+    this.onSuccess = this.onSuccess.bind(this);
+  }
+
+  onFailure(cause: Cause<E>) {
+    return this.sink.onFailure(cause);
+  }
+
+  onSuccess(value: A) {
+    return this.f(value).matchCauseIO(
+      (cause) => this.sink.onFailure(cause),
+      (b) => {
+        if (b) {
+          return this.sink.onSuccess(value);
+        } else {
+          return IO.unit;
+        }
+      },
+    );
+  }
+}
+
+class TapIOSink<R, E, A, R1, E1> extends UnsafeSink<R | R1, E, A> {
+  constructor(
+    readonly sink: UnsafeSink<R, E | E1, A>,
+    readonly f: (a: A) => IO<R1, E1, unknown>,
+  ) {
+    super();
+    this.onFailure = this.onFailure.bind(this);
+    this.onSuccess = this.onSuccess.bind(this);
+  }
+
+  onFailure(cause: Cause<E>) {
+    return this.sink.onFailure(cause);
+  }
+
+  onSuccess(value: A) {
+    return this.f(value).matchCauseIO(
+      (cause) => this.sink.onFailure(cause),
+      () => this.sink.onSuccess(value),
+    );
+  }
+}
+
+class LoopSink<R, E, A, B, C> extends UnsafeSink<R, E, A> {
+  constructor(
+    readonly sink: UnsafeSink<R, E, C>,
+    private seed: B,
+    readonly f: (acc: B, a: A) => readonly [C, B],
+  ) {
+    super();
+    this.onFailure = this.onFailure.bind(this);
+    this.onSuccess = this.onSuccess.bind(this);
+  }
+
+  onFailure(cause: Cause<E>) {
+    return this.sink.onFailure(cause);
+  }
+
+  onSuccess(value: A) {
+    const [c, acc] = this.f(this.seed, value);
+    this.seed      = acc;
+    return this.sink.onSuccess(c);
+  }
+}
+
+// class LoopCause<R, E, A, B, C> extends UnsafeSink<R, E, A> {}