@fncts/base 0.0.1 → 0.0.4

package/_src/data/These/api.ts

@@ -0,0 +1,184 @@
+import type { Both, Left, Right } from "@fncts/base/data/These/definition";
+import type * as P from "@fncts/base/typeclass";
+
+import { TheseTag } from "@fncts/base/data/These/definition";
+
+/**
+ * @tsplus fluent fncts.These isLeft
+ */
+export function isLeft<E, A>(self: These<E, A>): self is Left<E> {
+  return self._tag === TheseTag.Left;
+}
+
+/**
+ * @tsplus fluent fncts.These isRight
+ */
+export function isRight<E, A>(self: These<E, A>): self is Right<A> {
+  return self._tag === TheseTag.Right;
+}
+
+/**
+ * @tsplus fluent fncts.These isBoth
+ */
+export function isBoth<E, A>(self: These<E, A>): self is Both<E, A> {
+  return self._tag === TheseTag.Both;
+}
+
+/**
+ * @tsplus fluent fncts.These map
+ */
+export function map<E, A, B>(self: These<E, A>, f: (a: A) => B): These<E, B> {
+  switch (self._tag) {
+    case TheseTag.Left:
+      return self;
+    case TheseTag.Right:
+      return These.right(f(self.right));
+    case TheseTag.Both:
+      return These.both(self.left, f(self.right));
+  }
+}
+
+/**
+ * @tsplus fluent fncts.These mapLeft
+ */
+export function mapLeft<E, A, E1>(self: These<E, A>, f: (e: E) => E1): These<E1, A> {
+  switch (self._tag) {
+    case TheseTag.Left:
+      return These.left(f(self.left));
+    case TheseTag.Right:
+      return self;
+    case TheseTag.Both:
+      return These.both(f(self.left), self.right);
+  }
+}
+
+/**
+ * @tsplus fluent fncts.These bimap
+ */
+export function bimap<E, A, E1, B>(self: These<E, A>, f: (e: E) => E1, g: (a: A) => B): These<E1, B> {
+  switch (self._tag) {
+    case TheseTag.Left:
+      return These.left(f(self.left));
+    case TheseTag.Right:
+      return These.right(g(self.right));
+    case TheseTag.Both:
+      return These.both(f(self.left), g(self.right));
+  }
+}
+
+/**
+ * @tsplus fluent fncts.These zipWith
+ */
+export function zipWith<E, A, B, C>(
+  self: These<E, A>,
+  that: These<E, B>,
+  f: (a: A, b: B) => C,
+  /** @tsplus auto */ S: P.Semigroup<E>,
+): These<E, C> {
+  switch (self._tag) {
+    case TheseTag.Left:
+      switch (that._tag) {
+        case TheseTag.Left:
+          return These.left(S.combine(self.left, that.left));
+        case TheseTag.Right:
+          return self;
+        case TheseTag.Both:
+          return These.left(S.combine(self.left, that.left));
+      }
+    case TheseTag.Right:
+      switch (that._tag) {
+        case TheseTag.Left:
+          return that;
+        case TheseTag.Right:
+          return These.right(f(self.right, that.right));
+        case TheseTag.Both:
+          return These.left(that.left);
+      }
+    case TheseTag.Both:
+      switch (that._tag) {
+        case TheseTag.Left:
+          return These.left(S.combine(self.left, that.left));
+        case TheseTag.Right:
+          return These.both(self.left, f(self.right, that.right));
+        case TheseTag.Both:
+          return These.both(S.combine(self.left, that.left), f(self.right, that.right));
+      }
+  }
+}
+
+/**
+ * @tsplus fluent fncts.These zip
+ */
+export function zip<E, A, B>(
+  self: These<E, A>,
+  that: These<E, B>,
+  /** @tsplus auto */ S: P.Semigroup<E>,
+): These<E, readonly [A, B]> {
+  return self.zipWith(that, (a, b) => [a, b], S);
+}
+
+/**
+ * @tsplus fluent fncts.These ap
+ */
+export function ap<E, A, B>(
+  self: These<E, (a: A) => B>,
+  that: These<E, A>,
+  /** @tsplus auto */ S: P.Semigroup<E>,
+): These<E, B> {
+  return self.zipWith(that, (f, a) => f(a), S);
+}
+
+/**
+ * @tsplus fluent fncts.These flatMap
+ */
+export function flatMap<E, A, B>(
+  self: These<E, A>,
+  f: (a: A) => These<E, B>,
+  /** @tsplus auto */ S: P.Semigroup<E>,
+): These<E, B> {
+  if (self._tag === TheseTag.Left) {
+    return self;
+  }
+  if (self._tag === TheseTag.Right) {
+    return f(self.right);
+  }
+  const that = f(self.right);
+  switch (that._tag) {
+    case TheseTag.Left:
+      return These.left(S.combine(self.left, that.left));
+    case TheseTag.Right:
+      return These.both(self.left, that.right);
+    case TheseTag.Both:
+      return These.both(S.combine(self.left, that.left), that.right);
+  }
+}
+
+/**
+ * @tsplus fluent fncts.These catchAll
+ */
+export function catchAll_<E, A, B>(self: These<E, A>, f: (e: E) => These<E, B>): These<E, A | B> {
+  if (self._tag === TheseTag.Left) {
+    return f(self.left);
+  }
+  return self;
+}
+
+/**
+ * @tsplus getter fncts.These condemn
+ */
+export function condemn<E, A>(self: These<E, A>): These<E, A> {
+  if (self._tag === TheseTag.Both) {
+    return These.left(self.left);
+  }
+  return self;
+}
+
+/**
+ * @tsplus fluent fncts.These condemnWhen
+ */
+export function condemnWhen<E, A>(self: These<E, A>, p: Predicate<E>): These<E, A> {
+  if(self._tag === TheseTag.Both && p(self.left)) {
+    return These.left(self.left);
+  }
+  return self;
+}

package/_src/data/These/constructors.ts

@@ -23,3 +23,13 @@ export function right<E = never, A = never>(a: A): These<E, A> {
 export function both<E = never, A = never>(e: E, a: A): These<E, A> {
   return new Both(e, a);
 }
+
+/**
+ * @tsplus static fncts.TheseOps rightOrBoth
+ */
+export function rightOrBoth<E = never, A = never>(e: Maybe<E>, a: A): These<E, A> {
+  return e.match(
+    () => These.right(a),
+    (e) => These.both(e, a)
+  );
+}

package/_src/data/These/definition.ts

@@ -45,3 +45,10 @@ export type These<E, A> = Left<E> | Right<A> | Both<E, A>;
 export interface TheseOps {}
 
 export const These: TheseOps = {};
+
+/**
+ * @tsplus static fncts.TheseOps isThese
+ */
+export function isThese(u: unknown): u is These<unknown, unknown> {
+  return hasTypeId(u, TheseTypeId);
+}

package/_src/data/These/destructors.ts

@@ -1,5 +1,33 @@
 import { TheseTag } from "./definition.js";
 
+/**
+ * @tsplus getter fncts.These right
+ */
+export function unsafeGetRight<E, A>(self: These<E, A>): A | undefined {
+  return self.isRight() || self.isBoth() ? self.right : undefined;
+}
+
+/**
+ * @tsplus getter fncts.These left
+ */
+export function unsafeGetLeft<E, A>(self: These<E, A>): E | undefined {
+  return self.isLeft() ? self.left : undefined;
+}
+
+/**
+ * @tsplus getter fncts.These rightMaybe
+ */
+export function rightMaybe<E, A>(self: These<E, A>): Maybe<A> {
+  return self.isRight() || self.isBoth() ? Just(self.right) : Nothing();
+}
+
+/**
+ * @tsplus getter fncts.These leftMaybe
+ */
+export function leftMaybe<E, A>(self: These<E, A>): Maybe<E> {
+  return self.isLeft() ? Just(self.left) : Nothing();
+}
+
 /**
  * @tsplus fluent fncts.These match
  */
@@ -18,3 +46,20 @@ export function match_<E, A, B, C, D>(
       return both(self.left, self.right);
   }
 }
+
+/**
+ * @tsplus fluent fncts.These match2
+ */
+export function match2<E, A, B, C>(
+  self: These<E, A>,
+  left: (e: E) => B,
+  right: (e: Maybe<E>, a: A) => C
+): B | C {
+  switch(self._tag) {
+    case TheseTag.Left:
+      return left(self.left);
+    case TheseTag.Right:
+    case TheseTag.Both:
+      return right(self.leftMaybe, self.right);
+  }
+}

package/_src/data/These/instances.ts

@@ -0,0 +1,43 @@
+import { TheseJson } from "@fncts/base/json/TheseJson";
+
+/**
+ * @tsplus derive fncts.Guard[fncts.These]<_> 10
+ */
+export function deriveGuard<A extends These<any, any>>(
+  ...[left, right]: [A] extends [These<infer E, infer A>] ? [left: Guard<E>, right: Guard<A>] : never
+): Guard<A> {
+  return Guard((u): u is A => {
+    if (These.isThese(u)) {
+      if (u.isLeft()) {
+        return left.is(u.left);
+      }
+      if (u.isRight()) {
+        return right.is(u.right);
+      }
+      return right.is(u.right) && left.is(u.left);
+    }
+    return false;
+  });
+}
+
+/**
+ * @tsplus derive fncts.Decoder[fncts.These]<_> 10
+ */
+export function deriveDecoder<A extends These<any, any>>(
+  ...[left, right]: [A] extends [These<infer E, infer A>] ? [left: Decoder<E>, right: Decoder<A>] : never
+): Decoder<A> {
+  const label = `These<${left.label}, ${right.label}>`;
+  return Decoder(
+    (input) =>
+      TheseJson.getDecoder(left, right)
+        .decode(input)
+        .map((result) =>
+          result._tag === "Left"
+            ? (These.left(result.left) as A)
+            : result._tag === "Right"
+            ? (These.right(result.right) as A)
+            : (These.both(result.left, result.right) as A),
+        ),
+    label,
+  );
+}

package/_src/data/These.ts

@@ -1,4 +1,5 @@
 // codegen:start {preset: barrel, include: These/*.ts}
+export * from "./These/api.js";
 export * from "./These/constructors.js";
 export * from "./These/definition.js";
 export * from "./These/destructors.js";

package/_src/data/bigint/definition.ts

@@ -0,0 +1,13 @@
+declare global {
+  /**
+   * @tsplus type fncts.BigInt
+   */
+  interface BigInt {}
+
+  /**
+   * @tsplus type fncts.BigIntOps
+   */
+  interface BigIntConstructor {}
+}
+
+export {};

package/_src/data/bigint/instances.ts

@@ -0,0 +1,8 @@
+import * as P from "@fncts/base/typeclass";
+import { isBigInt } from "@fncts/base/util/predicates";
+
+/**
+ * @tsplus static fncts.BigIntOps Guard
+ * @tsplus implicit
+ */
+export const Guard: P.Guard<bigint> = P.Guard(isBigInt);

package/_src/data/bigint.ts

@@ -0,0 +1,4 @@
+// codegen:start { preset: barrel, include: ./bigint/*.ts }
+export * from "./bigint/definition.js";
+export * from "./bigint/instances.js";
+// codegen:end

package/_src/data/boolean/definition.ts

@@ -0,0 +1,13 @@
+declare global {
+  /**
+   * @tsplus type fncts.Boolean
+   */
+  export interface Boolean {}
+
+  /**
+   * @tsplus type fncts.BooleanOps
+   */
+  export interface BooleanConstructor {}
+}
+
+export {};

package/_src/data/boolean/instances.ts

@@ -0,0 +1,8 @@
+import * as P from "@fncts/base/typeclass";
+import { isBoolean } from "@fncts/base/util/predicates";
+
+/**
+ * @tsplus static fncts.BooleanOps Guard
+ * @tsplus implicit
+ */
+export const Guard: P.Guard<boolean> = P.Guard(isBoolean);

package/_src/data/boolean.ts

@@ -0,0 +1,4 @@
+// codegen:start { preset: barrel, include: ./boolean/*.ts }
+export * from "./boolean/definition.js";
+export * from "./boolean/instances.js";
+// codegen:end

package/_src/data/number/instances.ts

@@ -1,15 +1,25 @@
+import { isNumber } from "@fncts/base/util/predicates";
+
 import * as P from "../../typeclass.js";
 import { EQ, GT, LT } from "../../typeclass.js";
 
 /**
  * @tsplus static fncts.NumberOps Eq
+ * @tsplus implicit
  */
-export const Eq: P.Eq<number> = P.Eq({ equals_: (x, y) => x === y });
+export const Eq: P.Eq<number> = P.Eq({ equals: (x, y) => x === y });
 
 /**
  * @tsplus static fncts.NumberOps Ord
+ * @tsplus implicit
  */
 export const Ord: P.Ord<number> = P.Ord({
-  compare_: (x, y) => (x < y ? LT : x > y ? GT : EQ),
-  equals_: (x, y) => x === y,
+  compare: (x, y) => (x < y ? LT : x > y ? GT : EQ),
+  equals: (x, y) => x === y,
 });
+
+/**
+ * @tsplus static fncts.NumberOps Guard
+ * @tsplus implicit
+ */
+export const Guard: P.Guard<number> = P.Guard(isNumber);

package/_src/data/object/instances.ts

@@ -0,0 +1,7 @@
+import * as P from "@fncts/base/typeclass";
+
+/**
+ * @tsplus implicit
+ * @tsplus static fncts.globalOps Guard
+ */
+export const Guard: P.Guard<{}> = P.Guard(isObject);

package/_src/data/string/instances.ts

@@ -1,24 +1,36 @@
+import { isString } from "@fncts/base/util/predicates";
+
 import * as P from "../../typeclass.js";
 
 /**
  * @tsplus static fncts.StringOps Eq
+ * @tsplus implicit
  */
-export const Eq: P.Eq<string> = P.Eq({ equals_: (x, y) => x === y });
+export const Eq: P.Eq<string> = P.Eq({ equals: (x, y) => x === y });
 
 /**
  * @tsplus static fncts.StringOps Semigroup
+ * @tsplus implicit
  */
-export const Semigroup: P.Semigroup<string> = P.Semigroup({ combine_: (x, y) => x + y });
+export const Semigroup: P.Semigroup<string> = P.Semigroup({ combine: (x, y) => x + y });
 
 /**
  * @tsplus static fncts.StringOps Monoid
+ * @tsplus implicit
  */
-export const Monoid: P.Monoid<string> = P.Monoid({ combine_: (x, y) => x + y, nat: "" });
+export const Monoid: P.Monoid<string> = P.Monoid({ combine: (x, y) => x + y, nat: "" });
 
 /**
  * @tsplus static fncts.StringOps Ord
+ * @tsplus implicit
  */
 export const Ord: P.Ord<string> = P.Ord({
-  compare_: (x, y) => (x < y ? -1 : x > y ? 1 : 0),
-  equals_: (x, y) => x === y,
+  ...Eq,
+  compare: (x, y) => (x < y ? -1 : x > y ? 1 : 0),
 });
+
+/**
+ * @tsplus static fncts.StringOps Guard
+ * @tsplus implicit
+ */
+export const Guard: P.Guard<string> = P.Guard(isString);

package/_src/internal/Stack.ts

@@ -13,6 +13,10 @@ export class Stack<A> {
     return !!this.node;
   }
 
+  get isEmpty(): boolean {
+    return !this.hasNext;
+  }
+
   peek(): A | undefined {
     if (this.node) {
       return this.node.value;

package/_src/json/EitherJson.ts

@@ -0,0 +1,28 @@
+export interface RightJson<A> {
+  readonly _tag: "Right";
+  readonly right: A;
+}
+
+export interface LeftJson<E> {
+  readonly _tag: "Left";
+  readonly left: E;
+}
+
+/**
+ * @tsplus type fncts.EitherJson
+ */
+export type EitherJson<E, A> = LeftJson<E> | RightJson<A>;
+
+/**
+ * @tsplus type fncts.EitherJsonOps
+ */
+export interface EitherJsonOps {}
+
+export const EitherJson: EitherJsonOps = {};
+
+/**
+ * @tsplus static fncts.EitherJsonOps getDecoder
+ */
+export function getDecoder<E, A>(left: Decoder<E>, right: Decoder<A>): Decoder<EitherJson<E, A>> {
+  return Derive();
+}

package/_src/json/MaybeJson.ts

@@ -0,0 +1,27 @@
+export interface NothingJson {
+  readonly _tag: "Nothing"
+}
+
+export interface JustJson<A> {
+  readonly _tag: "Just"
+  readonly value: A
+}
+
+/**
+ * @tsplus type fncts.MaybeJson
+ */
+export type MaybeJson<A> = NothingJson | JustJson<A>;
+
+/**
+ * @tsplus type fncts.MaybeJsonOps
+ */
+export interface MaybeJsonOps {}
+
+export const MaybeJson: MaybeJsonOps = {};
+
+/**
+ * @tsplus static fncts.MaybeJsonOps getDecoder
+ */
+export function getDecoder<A>(value: Decoder<A>): Decoder<MaybeJson<A>> {
+  return Derive();
+}

package/_src/json/TheseJson.ts

@@ -0,0 +1,31 @@
+export interface LeftJson<E> {
+  readonly _tag: "Left";
+  readonly left: E;
+}
+
+export interface RightJson<A> {
+  readonly _tag: "Right";
+  readonly right: A;
+}
+
+export interface BothJson<E, A> {
+  readonly _tag: "Both";
+  readonly left: E;
+  readonly right: A;
+}
+
+export type TheseJson<E, A> = LeftJson<E> | RightJson<A> | BothJson<E, A>;
+
+/**
+ * @tsplus type fncts.TheseJsonOps
+ */
+export interface TheseJsonOps {}
+
+export const TheseJson: TheseJsonOps = {};
+
+/**
+ * @tsplus static fncts.TheseJsonOps getDecoder
+ */
+export function getDecoder<E, A>(left: Decoder<E>, right: Decoder<A>): Decoder<TheseJson<E, A>> {
+  return Derive();
+}

package/_src/optics/Optional/definition.ts

@@ -37,10 +37,10 @@ export function mkPOptional<S, T, A, B>(F: POptionalMin<S, T, A, B>): POptional<
     modifyMaybe_,
     modifyMaybe: (f) => (s) => modifyMaybe_(s, f),
     ...PTraversal<S, T, A, B>({
-      modifyA_: (A) => (s, f) =>
+      modifyA: (s, f, A) =>
         F.getOrModify(s).match(
           (t) => A.pure(t),
-          (a) => A.map_(f(a), (b) => F.replace_(s, b)),
+          (a) => f(a).map((b) => F.replace_(s, b), A),
         ),
     }),
   };

package/_src/optics/Traversal/api/compose.ts

@@ -8,6 +8,6 @@ export function compose_<S, T, A, B, C, D>(
   that: PTraversal<A, B, C, D>,
 ): PTraversal<S, T, C, D> {
   return PTraversal<S, T, C, D>({
-    modifyA_: (F) => (s, f) => self.modifyA_(F)(s, (a) => that.modifyA_(F)(a, f)),
+    modifyA: (s, f, F) => self.modifyA(s, (a) => that.modifyA(a, f, F), F),
   });
 }

package/_src/optics/Traversal/api/fromTraversable.ts

@@ -5,46 +5,20 @@ import { PTraversal } from "@fncts/base/optics/Traversal/definition";
 /**
  * @tsplus static fncts.optics.PTraversalOps fromTraversable
  */
-export function fromTraversable<T extends HKT, C = HKT.None>(
-  T: P.Traversable<T, C>,
-): <
-  A,
-  B,
-  K = HKT.Low<T, "K">,
-  Q = HKT.Low<T, "Q">,
-  W = HKT.Low<T, "W">,
-  X = HKT.Low<T, "X">,
-  I = HKT.Low<T, "I">,
-  S = HKT.Low<T, "S">,
-  R = HKT.Low<T, "R">,
-  E = HKT.Low<T, "E">,
-  K1 = HKT.Low<T, "K">,
-  Q1 = HKT.Low<T, "Q">,
-  W1 = HKT.Low<T, "W">,
-  X1 = HKT.Low<T, "X">,
-  I1 = HKT.Low<T, "I">,
-  S1 = HKT.Low<T, "S">,
-  R1 = HKT.Low<T, "R">,
-  E1 = HKT.Low<T, "E">,
->() => PTraversal<HKT.Kind<T, C, K, Q, W, X, I, S, R, E, A>, HKT.Kind<T, C, K1, Q1, W1, X1, I1, S1, R1, E1, B>, A, B>;
-export function fromTraversable<T>(
-  T: P.Traversable<HKT.F<T>>,
-): <A, B>() => PTraversal<
-  HKT.FK<T, any, any, any, any, any, any, any, any, A>,
-  HKT.FK<T, any, any, any, any, any, any, any, any, B>,
-  A,
-  B
-> {
-  return <A, B>() =>
-    PTraversal<
-      HKT.FK<T, any, any, any, any, any, any, any, any, A>,
-      HKT.FK<T, any, any, any, any, any, any, any, any, B>,
-      A,
-      B
-    >({
-      modifyA_: (F) => {
-        const traverseF_ = T.traverse_(F);
-        return (s, f) => traverseF_(s, f);
-      },
+export function fromTraversable<T extends HKT>(T: P.Traversable<T>) {
+  return <
+    A,
+    B,
+    K = HKT.Low<"K">,
+    Q = HKT.Low<"Q">,
+    W = HKT.Low<"W">,
+    X = HKT.Low<"X">,
+    I = HKT.Low<"I">,
+    S = HKT.Low<"S">,
+    R = HKT.Low<"R">,
+    E = HKT.Low<"E">,
+  >() =>
+    PTraversal<HKT.Kind<T, K, Q, W, X, I, S, R, E, A>, HKT.Kind<T, K, Q, W, X, I, S, R, E, B>, A, B>({
+      modifyA: (s, f, F) => T.traverse(s, f, F),
     });
 }