@fncts/base 0.0.3 → 0.0.6

package/_src/data/Maybe/destructors.ts

@@ -7,5 +7,6 @@ import { MaybeTag } from "./definition.js";
  * @tsplus fluent fncts.Maybe match
  */
 export function match_<A, B, C>(self: Maybe<A>, nothing: () => B, just: (a: A) => C): B | C {
+  self.concrete();
   return self._tag === MaybeTag.Just ? just(self.value) : nothing();
 }

package/_src/data/Maybe/instances.ts

@@ -1,6 +1,9 @@
-import * as P from "../../typeclass.js";
+import type * as P from "../../typeclass.js";
+import type { MaybeF } from "@fncts/base/data/Maybe/definition";
+
+import { MaybeJson } from "@fncts/base/json/MaybeJson";
+
 import {
-  ap_,
   filter_,
   filterMap_,
   flatMap_,
@@ -9,45 +12,69 @@ import {
   map_,
   partition_,
   partitionMap_,
+  zip_,
   zipWith_,
 } from "./api.js";
 import { just } from "./constructors.js";
 
-export interface MaybeF extends HKT {
-  readonly type: Maybe<this["A"]>;
-  readonly variance: {
-    readonly A: "-";
-  };
-}
+export const Functor: P.Functor<MaybeF> = { map: map_ };
 
-export const Functor: P.Functor<MaybeF> = P.Functor({ map_ });
+export const Apply: P.Apply<MaybeF> = { ...Functor, zip: zip_, zipWith: zipWith_ };
 
-export const Apply: P.Apply<MaybeF> = P.Apply({ map_, ap_, zipWith_ });
-
-export const Applicative: P.Applicative<MaybeF> = P.Applicative({
-  map_,
-  ap_,
-  zipWith_,
+export const Applicative: P.Applicative<MaybeF> = {
+  ...Apply,
   pure: just,
-});
+};
 
-export const Monad: P.Monad<MaybeF> = P.Monad({
-  map_,
-  ap_,
-  zipWith_,
-  pure: just,
-  flatMap_: flatMap_,
-});
+export const Monad: P.Monad<MaybeF> = {
+  ...Applicative,
+  flatMap: flatMap_,
+};
 
-export const Foldable: P.Foldable<MaybeF> = P.Foldable({
-  foldLeft_,
-  foldRight_,
-});
+export const Foldable: P.Foldable<MaybeF> = {
+  foldLeft: foldLeft_,
+  foldRight: foldRight_,
+};
 
-export const Filterable: P.Filterable<MaybeF> = P.Filterable({
-  map_,
-  filter_,
-  filterMap_,
-  partition_,
-  partitionMap_,
-});
+export const Filterable: P.Filterable<MaybeF> = {
+  ...Functor,
+  filter: filter_,
+  filterMap: filterMap_,
+  partition: partition_,
+  partitionMap: partitionMap_,
+};
+
+/**
+ * @tsplus derive fncts.Guard[fncts.Maybe]<_> 10
+ */
+export function deriveGuard<A extends Maybe<any>>(
+  ...[guard]: [A] extends [Maybe<infer A>] ? [guard: Guard<A>] : never
+): Guard<A> {
+  return Guard((u): u is A => {
+    if (Maybe.isMaybe(u)) {
+      if (u.isNothing()) {
+        return true;
+      }
+      if (u.isJust()) {
+        return guard.is(u.value);
+      }
+    }
+    return false;
+  });
+}
+
+/**
+ * @tsplus derive fncts.Decoder[fncts.Maybe]<_> 10
+ */
+export function deriveDecoder<A extends Maybe<any>>(
+  ...[value]: [A] extends [Maybe<infer A>] ? [value: Decoder<A>] : never
+): Decoder<A> {
+  const label = `Maybe<${value.label}>`;
+  return Decoder(
+    (input) =>
+      MaybeJson.getDecoder(value)
+        .decode(input)
+        .map((decoded) => (decoded._tag === "Nothing" ? (Nothing() as A) : (Just(decoded.value) as A))),
+    label,
+  );
+}

package/_src/data/Newtype.ts

@@ -1,14 +1,13 @@
 /**
  * @tsplus type fncts.Newtype
  */
-export interface Newtype<URI, A, C = HKT.None> {
+export interface Newtype<URI, A> {
   readonly _URI: URI;
-  readonly _A: A;
-  readonly _C: C;
+  readonly [HKT.A]: A;
 }
 
 export declare namespace Newtype {
-  export type Iso<N extends NewtypeHKT, C = N["type"]["_C"]> = NewtypeIso<N, C>;
+  export type Iso<N extends NewtypeHKT> = NewtypeIso<N>;
 }
 
 /**
@@ -19,42 +18,22 @@ export interface NewtypeOps {}
 export const Newtype: NewtypeOps = {};
 
 export interface NewtypeHKT extends HKT {
-  readonly type: Newtype<any, any>;
+  readonly [HKT.T]: Newtype<any, any>;
 }
 
-export interface NewtypeIso<N extends NewtypeHKT, C = N["type"]["_C"]> {
+export interface NewtypeIso<N extends NewtypeHKT> {
   /**
    * @tsplus macro identity
    */
-  get: <
-    K extends HKT.GetExtends<C, "K", any>,
-    Q extends HKT.GetExtends<C, "Q", any>,
-    W extends HKT.GetExtends<C, "W", any>,
-    X extends HKT.GetExtends<C, "X", any>,
-    I extends HKT.GetExtends<C, "I", any>,
-    S extends HKT.GetExtends<C, "S", any>,
-    R extends HKT.GetExtends<C, "E", any>,
-    E extends HKT.GetExtends<C, "E", any>,
-    A extends HKT.GetExtends<C, "A", any>,
-  >(
-    _: HKT.Kind<N, N["type"]["_C"], K, Q, W, X, I, S, R, E, A>["_A"],
-  ) => HKT.Kind<N, HKT.None, K, Q, W, X, I, S, R, E, A>;
+  get: <K, Q, W, X, I, S, R, E, A>(
+    _: HKT.Kind<N, K, Q, W, X, I, S, R, E, A>[HKT.A],
+  ) => HKT.Kind<N, K, Q, W, X, I, S, R, E, A>;
   /**
    * @tsplus macro identity
    */
-  reverseGet: <
-    K extends HKT.GetExtends<C, "K", any>,
-    Q extends HKT.GetExtends<C, "Q", any>,
-    W extends HKT.GetExtends<C, "W", any>,
-    X extends HKT.GetExtends<C, "X", any>,
-    I extends HKT.GetExtends<C, "I", any>,
-    S extends HKT.GetExtends<C, "S", any>,
-    R extends HKT.GetExtends<C, "E", any>,
-    E extends HKT.GetExtends<C, "E", any>,
-    A extends HKT.GetExtends<C, "A", any>,
-  >(
-    _: HKT.Kind<N, HKT.None, K, Q, W, X, I, S, R, E, A>,
-  ) => HKT.Kind<N, HKT.None, K, Q, W, X, I, S, R, E, A>["_A"];
+  reverseGet: <K, Q, W, X, I, S, R, E, A>(
+    _: HKT.Kind<N, K, Q, W, X, I, S, R, E, A>,
+  ) => HKT.Kind<N, K, Q, W, X, I, S, R, E, A>[HKT.A];
 }
 
 /**

package/_src/data/Patch/api.ts

@@ -49,7 +49,7 @@ const OrdEnvironmentMap = Number.Ord.contramap((_: readonly [Tag<unknown>, reado
  * @tsplus static fncts.Environment.PatchOps diff
  */
 export function diff<In, Out>(oldValue: Environment<In>, newValue: Environment<Out>): Patch<In, Out> {
-  const sorted                   = newValue.map.toArray.sort(OrdEnvironmentMap.compare_);
+  const sorted                   = newValue.map.toArray.sort(OrdEnvironmentMap.compare);
   const [missingServices, patch] = sorted.foldLeft(
     [oldValue.map.beginMutation, Patch.empty() as Patch<any, any>],
     ([map, patch], [tag, [newService, newIndex]]) =>

package/_src/data/Refinement/api.ts

@@ -2,8 +2,10 @@
  * @tsplus fluent fncts.Refinement and
  * @tsplus operator fncts.Refinement &&
  */
-export function and<A, B extends A, C extends B>(self: Refinement<A, B>, that: Refinement<B, C>): Refinement<A, C> {
-  return (a): a is C => self(a) && that(a);
+export function and<A, B extends A, C extends B>(self: Refinement<A, B>, that: Refinement<B, C>): Refinement<A, C>;
+export function and<A, B extends A>(self: Refinement<A, B>, that: Predicate<B>): Refinement<A, B>;
+export function and<A, B extends A>(self: Refinement<A, B>, that: Predicate<B>): Refinement<A, B> {
+  return (a): a is B => self(a) && that(a);
 }
 
 /**

package/_src/data/Struct/definition.ts

@@ -1,5 +1,5 @@
 interface StructN extends HKT {
-  readonly type: Struct<this["A"]>;
+  readonly [HKT.T]: Struct<HKT._A<this>>;
 }
 
 /**

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