@fncts/io 0.0.49 → 0.0.50

package/_src/Push/Operator/IOOperator.ts

@@ -0,0 +1,173 @@
+import type { SyncOperator } from "./SyncOperator.js";
+
+export const enum IOOperatorTag {
+  MapIO = "MapIO",
+  TapIO = "TapIO",
+  FilterIO = "FilterIO",
+  FilterMapIO = "FilterMapIO",
+}
+
+/**
+ * @tsplus type fncts.io.Push.IOOperator
+ * @tsplus companion fncts.io.Push.IOOperatorOps
+ */
+export type IOOperator =
+  | MapIO<any, any, any, any>
+  | TapIO<any, any, any, any>
+  | FilterIO<any, any, any>
+  | FilterMapIO<any, any, any, any>;
+
+export interface MapIO<R, E, A, B> {
+  readonly _tag: IOOperatorTag.MapIO;
+  readonly f: (a: A) => IO<R, E, B>;
+}
+
+export function MapIO<R, E, A, B>(f: (a: A) => IO<R, E, B>): MapIO<R, E, A, B> {
+  return {
+    _tag: IOOperatorTag.MapIO,
+    f,
+  };
+}
+
+export interface TapIO<R, E, A, B> {
+  readonly _tag: IOOperatorTag.TapIO;
+  readonly f: (a: A) => IO<R, E, B>;
+}
+
+export function TapIO<R, E, A, B>(f: (a: A) => IO<R, E, B>): TapIO<R, E, A, B> {
+  return {
+    _tag: IOOperatorTag.TapIO,
+    f,
+  };
+}
+
+export interface FilterIO<R, E, A> {
+  readonly _tag: IOOperatorTag.FilterIO;
+  readonly f: (a: A) => IO<R, E, boolean>;
+}
+
+export function FilterIO<R, E, A>(f: (a: A) => IO<R, E, boolean>): FilterIO<R, E, A> {
+  return {
+    _tag: IOOperatorTag.FilterIO,
+    f,
+  };
+}
+
+export interface FilterMapIO<R, E, A, B> {
+  readonly _tag: IOOperatorTag.FilterMapIO;
+  readonly f: (a: A) => IO<R, E, Maybe<B>>;
+}
+
+export function FilterMapIO<R, E, A, B>(f: (a: A) => IO<R, E, Maybe<B>>): FilterMapIO<R, E, A, B> {
+  return {
+    _tag: IOOperatorTag.FilterMapIO,
+    f,
+  };
+}
+
+export type IOOperatorFusionMap = {
+  readonly [K in IOOperator["_tag"]]: {
+    readonly [K2 in IOOperator["_tag"]]: (
+      op1: Extract<IOOperator, { readonly _tag: K }>,
+      op2: Extract<IOOperator, { readonly _tag: K2 }>,
+    ) => IOOperator;
+  };
+};
+
+const IOOperatorFusionMap: IOOperatorFusionMap = {
+  [IOOperatorTag.MapIO]: {
+    [IOOperatorTag.MapIO]: (op1, op2) => MapIO((a) => op1.f(a).flatMap(op2.f)),
+    [IOOperatorTag.TapIO]: (op1, op2) => MapIO((a) => op1.f(a).tap(op2.f)),
+    [IOOperatorTag.FilterIO]: (op1, op2) =>
+      FilterMapIO((a) => op1.f(a).flatMap((b) => op2.f(b).map((b2) => (b2 ? Just(b) : Nothing())))),
+    [IOOperatorTag.FilterMapIO]: (op1, op2) => FilterMapIO((a) => op1.f(a).flatMap(op2.f)),
+  },
+  [IOOperatorTag.TapIO]: {
+    [IOOperatorTag.MapIO]: (op1, op2) => MapIO((a) => op1.f(a).flatMap(() => op2.f(a))),
+    [IOOperatorTag.TapIO]: (op1, op2) => TapIO((a) => op1.f(a).tap(() => op2.f(a))),
+    [IOOperatorTag.FilterIO]: (op1, op2) => FilterIO((a) => op1.f(a).flatMap(() => op2.f(a))),
+    [IOOperatorTag.FilterMapIO]: (op1, op2) => FilterMapIO((a) => op1.f(a).flatMap(() => op2.f(a))),
+  },
+  [IOOperatorTag.FilterIO]: {
+    [IOOperatorTag.MapIO]: (op1, op2) =>
+      FilterMapIO((a) => op1.f(a).flatMap((b) => (b ? op2.f(a).map(Maybe.just) : IO.succeedNow(Nothing())))),
+    [IOOperatorTag.TapIO]: (op1, op2) => FilterIO((a) => op1.f(a).tap(() => op2.f(a))),
+    [IOOperatorTag.FilterIO]: (op1, op2) => FilterIO((a) => op1.f(a).zipWith(op2.f(a), (b1, b2) => b1 && b2)),
+    [IOOperatorTag.FilterMapIO]: (op1, op2) =>
+      FilterMapIO((a) => op1.f(a).flatMap((b) => (b ? op2.f(a) : IO.succeedNow(Nothing())))),
+  },
+  [IOOperatorTag.FilterMapIO]: {
+    [IOOperatorTag.MapIO]: (op1, op2) =>
+      FilterMapIO((a) => op1.f(a).flatMap((mb) => mb.match(() => IO.succeedNow(Nothing()), op2.f))),
+    [IOOperatorTag.TapIO]: (op1, op2) =>
+      FilterMapIO((a) =>
+        op1.f(a).flatMap((mb) =>
+          mb.match(
+            () => IO.succeedNow(Nothing()),
+            (b) => op2.f(b).as(() => a),
+          ),
+        ),
+      ),
+    [IOOperatorTag.FilterIO]: (op1, op2) =>
+      FilterMapIO((a) =>
+        op1.f(a).flatMap((mb) =>
+          mb.match(
+            () => IO.succeedNow(Nothing()),
+            (b) => op2.f(b).map((b2) => (b2 ? Just(b) : Nothing())),
+          ),
+        ),
+      ),
+    [IOOperatorTag.FilterMapIO]: (op1, op2) =>
+      FilterMapIO((a) =>
+        op1.f(a).flatMap((mb) =>
+          mb.match(
+            () => IO.succeedNow(Nothing()),
+            (b) => op2.f(b),
+          ),
+        ),
+      ),
+  },
+};
+
+/**
+ * @tsplus pipeable fncts.io.Push.IOOperator fuse
+ */
+export function fuse(that: IOOperator) {
+  return (self: IOOperator): IOOperator => {
+    return IOOperatorFusionMap[self._tag][that._tag](self as any, that as any);
+  };
+}
+
+/**
+ * @tsplus static fncts.io.Push.IOOperatorOps fromSyncOperator
+ */
+export function fromSyncOperator(op: SyncOperator): IOOperator {
+  return op.match({
+    Map: (op) => MapIO((a) => IO.succeedNow(op.f(a))),
+    Filter: (op) => FilterIO((a) => IO.succeedNow(op.f(a))),
+    FilterMap: (op) => FilterMapIO((a) => IO.succeedNow(op.f(a))),
+  });
+}
+
+/**
+ * @tsplus pipeable fncts.io.Push.IOOperator match
+ */
+export function match<A, B, C, D>(cases: {
+  readonly MapIO: (f: MapIO<any, any, any, any>) => A;
+  readonly TapIO: (f: TapIO<any, any, any, any>) => B;
+  readonly FilterIO: (f: FilterIO<any, any, any>) => C;
+  readonly FilterMapIO: (f: FilterMapIO<any, any, any, any>) => D;
+}) {
+  return (self: IOOperator): A | B | C | D => {
+    switch (self._tag) {
+      case IOOperatorTag.MapIO:
+        return cases.MapIO(self);
+      case IOOperatorTag.TapIO:
+        return cases.TapIO(self);
+      case IOOperatorTag.FilterIO:
+        return cases.FilterIO(self);
+      case IOOperatorTag.FilterMapIO:
+        return cases.FilterMapIO(self);
+    }
+  };
+}

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