@fncts/io 0.0.48 → 0.0.50

package/_src/Push/Operator/LoopOperator.ts

@@ -0,0 +1,242 @@
+import type { Bounds } from "../Bounds.js";
+import type { SyncOperator } from "./SyncOperator.js";
+
+export const enum SyncLoopOperatorTag {
+  Loop = "Loop",
+  FilterMapLoop = "FilterMapLoop",
+}
+
+/**
+ * @tsplus type fncts.io.Push.SyncLoopOperator
+ */
+export type SyncLoopOperator<B = any, A = any, C = any> = LoopOperator<B, A, C> | FilterMapLoopOperator<B, A, C>;
+
+export interface LoopOperator<B, A, C> {
+  readonly _tag: SyncLoopOperatorTag.Loop;
+  readonly seed: B;
+  readonly f: (acc: B, a: A) => readonly [C, B];
+}
+
+export function LoopOperator<const B, A, C>(seed: B, f: (acc: B, a: A) => readonly [C, B]): LoopOperator<B, A, C> {
+  return {
+    _tag: SyncLoopOperatorTag.Loop,
+    seed,
+    f,
+  };
+}
+
+export interface FilterMapLoopOperator<B, A, C> {
+  readonly _tag: SyncLoopOperatorTag.FilterMapLoop;
+  readonly seed: B;
+  readonly f: (acc: B, a: A) => readonly [Maybe<C>, B];
+}
+
+export function FilterMapLoopOperator<const B, A, C>(
+  seed: B,
+  f: (acc: B, a: A) => readonly [Maybe<C>, B],
+): FilterMapLoopOperator<B, A, C> {
+  return {
+    _tag: SyncLoopOperatorTag.FilterMapLoop,
+    seed,
+    f,
+  };
+}
+
+export const enum SliceOperatorTag {
+  SliceOperator,
+  FilterMapSliceOperator,
+}
+
+export interface SliceOperator {
+  readonly _tag: SliceOperatorTag.SliceOperator;
+  readonly bounds: Bounds;
+}
+
+export function SliceOperator(bounds: Bounds): SliceOperator {
+  return {
+    _tag: SliceOperatorTag.SliceOperator,
+    bounds,
+  };
+}
+
+export interface FilterMapSliceOperator<A, B, C> {
+  readonly _tag: SliceOperatorTag.FilterMapSliceOperator;
+  readonly seed: B;
+  readonly f: (acc: B, a: A) => Either<readonly [Maybe<C>, B], Maybe<C>>;
+}
+
+export function FilterMapSliceOperator<const B, A, C>(
+  seed: B,
+  f: (acc: B, a: A) => Either<readonly [Maybe<C>, B], Maybe<C>>,
+): FilterMapSliceOperator<A, B, C> {
+  return {
+    _tag: SliceOperatorTag.FilterMapSliceOperator,
+    seed,
+    f,
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.io.Push.SyncLoopOperator match
+ */
+export function matchSyncLoopOperator<A, B, C, D, E>(matchers: {
+  Loop: (op: LoopOperator<A, B, C>) => D;
+  FilterMapLoop: (op: FilterMapLoopOperator<A, B, C>) => E;
+}) {
+  return (self: SyncLoopOperator<A, B, C>): D | E => {
+    switch (self._tag) {
+      case SyncLoopOperatorTag.Loop:
+        return matchers.Loop(self);
+      case SyncLoopOperatorTag.FilterMapLoop:
+        return matchers.FilterMapLoop(self);
+    }
+  };
+}
+
+export function fuseSyncOperatorBefore(that: SyncOperator) {
+  return (self: SyncLoopOperator): SyncLoopOperator => {
+    return that.match({
+      Map: (op) =>
+        self.match({
+          Loop: (lop) => LoopOperator(lop.seed, (acc, a) => lop.f(acc, op.f(a))),
+          FilterMapLoop: (lop) => FilterMapLoopOperator(lop.seed, (acc, a) => lop.f(acc, op.f(a))),
+        }),
+      Filter: (op) =>
+        self.match({
+          Loop: (lop) =>
+            FilterMapLoopOperator(lop.seed, (acc, a) => {
+              const [b, c] = lop.f(acc, a);
+              if (op.f(a)) {
+                return [Just(b), c];
+              } else {
+                return [Nothing(), c];
+              }
+            }),
+          FilterMapLoop: (lop) =>
+            FilterMapLoopOperator(lop.seed, (acc, a) => {
+              if (op.f(a)) {
+                return [Nothing(), acc];
+              } else {
+                return lop.f(acc, a);
+              }
+            }),
+        }),
+      FilterMap: (op) =>
+        self.match({
+          Loop: (lop) =>
+            FilterMapLoopOperator(lop.seed, (acc, a) =>
+              op.f(a).match(
+                () => [Nothing(), acc],
+                (x) => {
+                  const [b, c] = lop.f(acc, x);
+                  return [Just(b), c];
+                },
+              ),
+            ),
+          FilterMapLoop: (lop) =>
+            FilterMapLoopOperator(lop.seed, (acc, a) =>
+              op.f(a).match(
+                () => [Nothing(), acc],
+                (x) => lop.f(acc, x.value),
+              ),
+            ),
+        }),
+    });
+  };
+}
+
+export function fuseSyncOperatorAfter(that: SyncOperator) {
+  return (self: SyncLoopOperator): SyncLoopOperator =>
+    self.match({
+      Loop: (lop) =>
+        that.match({
+          Map: (op) =>
+            LoopOperator(lop.seed, (acc, a) => {
+              const [b, c] = lop.f(acc, a);
+              return [op.f(b), c];
+            }),
+          Filter: (op) =>
+            FilterMapLoopOperator(lop.seed, (acc, a) => {
+              const [b, c] = lop.f(acc, a);
+              if (op.f(b)) {
+                return [Just(b), c];
+              } else {
+                return [Nothing(), c];
+              }
+            }),
+          FilterMap: (op) =>
+            FilterMapLoopOperator(lop.seed, (acc, a) => {
+              const [b, c] = lop.f(acc, a);
+              return op.f(b).match(
+                () => [Nothing(), c],
+                (d) => [Just(d), c],
+              );
+            }),
+        }),
+      FilterMapLoop: (lop) =>
+        that.match({
+          Map: (op) =>
+            FilterMapLoopOperator(lop.seed, (acc, a) => {
+              const [b, c] = lop.f(acc, a);
+              return [b.map(op.f), c];
+            }),
+          Filter: (op) =>
+            FilterMapLoopOperator(lop.seed, (acc, a) => {
+              const [b, c] = lop.f(acc, a);
+              return [b.filter(op.f), c];
+            }),
+          FilterMap: (op) =>
+            FilterMapLoopOperator(lop.seed, (acc, a) => {
+              const [b, c] = lop.f(acc, a);
+              return [b.flatMap(op.f), c];
+            }),
+        }),
+    });
+}
+
+export function fuse<C, D, E>(that: SyncLoopOperator<D, C, E>) {
+  return <A, B>(self: SyncLoopOperator<A, B, C>): SyncLoopOperator<readonly [A, D], B, E> => {
+    return self.match({
+      Loop: (op1) =>
+        that.match({
+          Loop: (op2) =>
+            LoopOperator([op1.seed, op2.seed], ([a, d], b) => {
+              const [c, a1] = op1.f(a, b);
+              const [e, d1] = op2.f(d, c);
+              return [e, [a1, d1]];
+            }),
+          FilterMapLoop: (op2) =>
+            FilterMapLoopOperator([op1.seed, op2.seed], ([a, d], b) => {
+              const [c, a1] = op1.f(a, b);
+              const [e, d1] = op2.f(d, c);
+              return [e, [a1, d1]];
+            }),
+        }),
+      FilterMapLoop: (op1) =>
+        that.match({
+          Loop: (op2) =>
+            FilterMapLoopOperator([op1.seed, op2.seed], ([a, d], b) => {
+              const [c, a1] = op1.f(a, b);
+              return c.match(
+                () => [Nothing(), [a1, d]],
+                (c) => {
+                  const [e, d1] = op2.f(d, c);
+                  return [Just(e), [a1, d1]];
+                },
+              );
+            }),
+          FilterMapLoop: (op2) =>
+            FilterMapLoopOperator([op1.seed, op2.seed], ([a, d], b) => {
+              const [c, a1] = op1.f(a, b);
+              return c.match(
+                () => [Nothing(), [a1, d]],
+                (c) => {
+                  const [e, d1] = op2.f(d, c);
+                  return [e, [a1, d1]];
+                },
+              );
+            }),
+        }),
+    });
+  };
+}

package/_src/Push/Operator/SyncOperator.ts

@@ -0,0 +1,107 @@
+export const enum SyncOperatorTag {
+  Map = "Map",
+  Filter = "Filter",
+  FilterMap = "FilterMap",
+}
+
+export interface Map<A, B> {
+  readonly _tag: SyncOperatorTag.Map;
+  readonly f: (a: A) => B;
+}
+
+export function Map<A, B>(f: (a: A) => B): Map<A, B> {
+  return {
+    _tag: SyncOperatorTag.Map,
+    f,
+  };
+}
+
+export interface Filter<A> {
+  readonly _tag: SyncOperatorTag.Filter;
+  readonly f: Predicate<A>;
+}
+
+export function Filter<A>(f: Predicate<A>): Filter<A> {
+  return {
+    _tag: SyncOperatorTag.Filter,
+    f,
+  };
+}
+
+export interface FilterMap<A, B> {
+  readonly _tag: SyncOperatorTag.FilterMap;
+  readonly f: (a: A) => Maybe<B>;
+}
+
+export function FilterMap<A, B>(f: (a: A) => Maybe<B>): FilterMap<A, B> {
+  return {
+    _tag: SyncOperatorTag.FilterMap,
+    f,
+  };
+}
+
+/**
+ * @tsplus type fncts.io.Push.SyncOperator
+ * @tsplus companion fncts.io.Push.SyncOperatorOps
+ */
+export type SyncOperator<A = any, B = any> = Map<A, B> | Filter<A> | FilterMap<A, B>;
+
+type SyncOperatorFusionMap = {
+  readonly [K in SyncOperator["_tag"]]: {
+    readonly [K2 in SyncOperator["_tag"]]: (
+      op1: Extract<SyncOperator, { readonly _tag: K }>,
+      op2: Extract<SyncOperator, { readonly _tag: K2 }>,
+    ) => SyncOperator;
+  };
+};
+
+const SyncOperatorFusionMap: SyncOperatorFusionMap = {
+  [SyncOperatorTag.Map]: {
+    [SyncOperatorTag.Map]: (op1, op2) => Map(op1.f.compose(op2.f)),
+    [SyncOperatorTag.Filter]: (op1, op2) =>
+      FilterMap((a) => {
+        const b = op1.f(a);
+        return op2.f(b) ? Just(b) : Nothing();
+      }),
+    [SyncOperatorTag.FilterMap]: (op1, op2) => FilterMap(op1.f.compose(op2.f)),
+  },
+  [SyncOperatorTag.Filter]: {
+    [SyncOperatorTag.Map]: (op1, op2) => FilterMap((a) => (op1.f(a) ? Just(op2.f(a)) : Nothing())),
+    [SyncOperatorTag.Filter]: (op1, op2) => Filter(op1.f && op2.f),
+    [SyncOperatorTag.FilterMap]: (op1, op2) => FilterMap((a) => (op1.f(a) ? op2.f(a) : Nothing())),
+  },
+  [SyncOperatorTag.FilterMap]: {
+    [SyncOperatorTag.Map]: (op1, op2) => FilterMap((a) => op1.f(a).map(op2.f)),
+    [SyncOperatorTag.Filter]: (op1, op2) => FilterMap((a) => op1.f(a).filter(op2.f)),
+    [SyncOperatorTag.FilterMap]: (op1, op2) => FilterMap((a) => op1.f(a).flatMap(op2.f)),
+  },
+};
+
+/**
+ * @tsplus pipeable fncts.io.Push.SyncOperator fuse
+ */
+export function fuse(that: SyncOperator) {
+  return (self: SyncOperator) => {
+    return SyncOperatorFusionMap[self._tag][that._tag](self as any, that as any);
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.io.Push.SyncOperator match
+ */
+export function match<A, B, C, D, E>(cases: {
+  readonly Map: (f: Map<A, B>) => C;
+  readonly Filter: (f: Filter<A>) => D;
+  readonly FilterMap: (f: FilterMap<A, B>) => E;
+}) {
+  return (self: SyncOperator<A, B>): C | D | E => {
+    switch (self._tag) {
+      case SyncOperatorTag.Map:
+        return cases.Map(self);
+      case SyncOperatorTag.Filter:
+        return cases.Filter(self);
+      case SyncOperatorTag.FilterMap:
+        return cases.FilterMap(self);
+    }
+  };
+}

package/_src/Push/Operator.ts

@@ -0,0 +1,7 @@
+/* eslint-disable simple-import-sort/exports */
+// codegen:start { preset: type-barrel, include: ./Operator/*.ts }
+export type {} from "./Operator/SyncOperator.js"
+export type {} from "./Operator/LoopOperator.js"
+export type {} from "./Operator/IOOperator.js"
+export type {} from "./Operator/IOLoopOperator.js"
+// codegen:end

package/_src/Push/Producer/IOProducer.ts

@@ -0,0 +1,83 @@
+import type { Push } from "../definition.js";
+
+export const enum IOProducerTag {
+  FromIO,
+  FromScheduled,
+  Scheduled,
+}
+
+export class FromIO<R, E, A> {
+  readonly _tag = IOProducerTag.FromIO;
+  constructor(readonly source: IO<R, E, A>) {}
+}
+
+export class FromScheduled<R, E, I, R1, O> {
+  readonly _tag = IOProducerTag.FromScheduled;
+  constructor(
+    readonly input: IO<R, E, I>,
+    readonly schedule: Schedule<R1, I, O>,
+  ) {}
+}
+
+export class Scheduled<R, E, A, R1, O> {
+  readonly _tag = IOProducerTag.Scheduled;
+  constructor(
+    readonly input: IO<R, E, A>,
+    readonly schedule: Schedule<R1, unknown, O>,
+  ) {}
+}
+
+/**
+ * @tsplus type fncts.io.Push.IOProducer
+ * @tsplus companion fncts.io.Push.IOProducerOps
+ */
+export type IOProducer<R, E, A> = FromIO<R, E, A> | FromScheduled<R, E, any, any, A> | Scheduled<R, E, A, any, any>;
+
+/**
+ * @tsplus fluent fncts.io.Push.IOProducer runSink
+ */
+export function runSink<R, E, A, R1>(
+  self: IOProducer<R, E, A>,
+  sink: Push.UnsafeSink<R1, E, A>,
+): IO<R | R1, never, unknown> {
+  switch (self._tag) {
+    case IOProducerTag.FromIO:
+      return self.source.matchCauseIO(sink.onFailure, sink.onSuccess);
+    case IOProducerTag.Scheduled:
+      return self.input
+        .matchCauseIO(sink.onFailure, sink.onSuccess)
+        .schedule(self.schedule)
+        .catchAllCause(sink.onFailure);
+    case IOProducerTag.FromScheduled:
+      return self.input
+        .flatMap((i) => self.input.scheduleFrom(() => i, self.schedule.mapIO(sink.onSuccess)))
+        .catchAllCause(sink.onFailure);
+  }
+}
+
+/**
+ * @tsplus fluent fncts.io.Push.IOProducer runIO
+ */
+export function runIO<R, E, A, R1, E1, A1>(
+  self: IOProducer<R, E, A>,
+  f: (a: A) => IO<R1, E1, A1>,
+): IO<R | R1, E | E1, unknown> {
+  switch (self._tag) {
+    case IOProducerTag.FromIO:
+      return self.source.flatMap(f);
+    case IOProducerTag.FromScheduled:
+      return self.input.flatMap((i) =>
+        IO.asyncIO((resume) => {
+          const onFailure = (cause: Cause<E | E1>) => IO.succeedNow(resume(IO.failCauseNow(cause)));
+          return self.input
+            .scheduleFrom(
+              () => i,
+              self.schedule.mapIO((a) => f(a).catchAllCause(onFailure)),
+            )
+            .matchCauseIO(onFailure, () => IO.succeedNow(resume(IO.unit))).asUnit;
+        }),
+      );
+    case IOProducerTag.Scheduled:
+      return self.input.flatMap(f).schedule(self.schedule);
+  }
+}

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