@fncts/base 0.0.1 → 0.0.4

package/_src/data/Interval.ts

@@ -0,0 +1,103 @@
+/**
+ * @tsplus type fncts.io.Schedule.Interval
+ * @tsplus companion fncts.io.Schedule.IntervalOps
+ */
+export class Interval {
+  constructor(readonly startMilliseconds: number, readonly endMilliseconds: number) {}
+}
+
+/**
+ * @tsplus static fncts.io.Schedule.IntervalOps after
+ */
+export function after(start: number): Interval {
+  return Interval(start, Number.MAX_SAFE_INTEGER);
+}
+
+/**
+ * @tsplus static fncts.io.Schedule.IntervalOps before
+ */
+export function before(end: number): Interval {
+  return Interval(Number.MIN_SAFE_INTEGER, end);
+}
+
+/**
+ * @tsplus static fncts.io.Schedule.IntervalOps empty
+ */
+export const empty: Interval = new Interval(Number.MIN_SAFE_INTEGER, Number.MIN_SAFE_INTEGER);
+
+/**
+ * @tsplus getter fncts.io.Schedule.Interval isEmpty
+ */
+export function isEmpty(self: Interval): boolean {
+  return self.startMilliseconds >= self.endMilliseconds;
+}
+
+/**
+ * @tsplus fluent fncts.io.Schedule.Interval intersect
+ */
+export function intersect_(self: Interval, that: Interval): Interval {
+  const start = Math.max(self.startMilliseconds, that.startMilliseconds);
+  const end   = Math.min(self.endMilliseconds, that.endMilliseconds);
+  return Interval(start, end);
+}
+
+/**
+ * @tsplus fluent fncts.io.Schedule.Interval lt
+ * @tsplus operator fncts.io.Schedule.Interval <
+ */
+export function lt_(self: Interval, that: Interval): boolean {
+  return self.min(that) === self;
+}
+
+/**
+ * @tsplus static fncts.io.Schedule.IntervalOps __call
+ */
+export function makeInterval(start: number, end: number): Interval {
+  if (start <= end) return Interval(start, end);
+  else return Interval.empty;
+}
+
+/**
+ * @tsplus fluent fncts.io.Schedule.Interval max
+ */
+export function max_(self: Interval, that: Interval): Interval {
+  const m = self.min(that);
+  if (m === self) return that;
+  else return self;
+}
+
+/**
+ * @tsplus fluent fncts.io.Schedule.Interval min
+ */
+export function min_(self: Interval, that: Interval): Interval {
+  if (self.endMilliseconds <= that.startMilliseconds) return self;
+  if (that.endMilliseconds <= self.startMilliseconds) return that;
+  if (self.startMilliseconds < that.startMilliseconds) return self;
+  if (that.startMilliseconds < self.startMilliseconds) return that;
+  if (self.endMilliseconds <= that.endMilliseconds) return self;
+  return that;
+}
+
+/**
+ * @tsplus getter fncts.io.Schedule.Interval isNonEmpty
+ */
+export function isNonEmpty(self: Interval): boolean {
+  return !self.isEmpty;
+}
+
+/**
+ * @tsplus getter fncts.io.Schedule.Interval size
+ */
+export function size(self: Interval): number {
+  return self.endMilliseconds - self.startMilliseconds;
+}
+
+/**
+ * @tsplus fluent fncts.io.Schedule.Interval union
+ */
+export function union_(self: Interval, that: Interval): Maybe<Interval> {
+  const istart = Math.max(self.startMilliseconds, that.startMilliseconds);
+  const iend   = Math.min(self.endMilliseconds, that.endMilliseconds);
+  if (istart <= iend) return Nothing();
+  else return Just(Interval(istart, iend));
+}

package/_src/data/Maybe/api.ts

@@ -1,9 +1,6 @@
-import type { MaybeF } from "./instances.js";
 import type { Eq, Monoid } from "@fncts/base/typeclass";
 import type { Nullable } from "@fncts/base/types";
 
-import { Apply } from "@fncts/base/typeclass";
-
 import { identity } from "../function.js";
 import { MaybeTag } from "./definition.js";
 
@@ -11,14 +8,11 @@ import { MaybeTag } from "./definition.js";
  * @tsplus fluent fncts.Maybe ap
  */
 export function ap_<A, B>(self: Maybe<(a: A) => B>, fa: Maybe<A>): Maybe<B> {
+  self.concrete();
+  fa.concrete();
   return self._tag === MaybeTag.Just && fa._tag === MaybeTag.Just ? Just(self.value(fa.value)) : Nothing();
 }
 
-/**
- * @tsplus static fncts.MaybeOps sequenceS
- */
-export const sequenceS = Apply.sequenceSF<MaybeF>({ map_, ap_, zipWith_ });
-
 /**
  * Applies `f` to the value contained in `Maybe` if it is `Just` and returns the result,
  * otherwise returns `Nothing`.
@@ -26,23 +20,16 @@ export const sequenceS = Apply.sequenceSF<MaybeF>({ map_, ap_, zipWith_ });
  * @tsplus fluent fncts.Maybe flatMap
  */
 export function flatMap_<A, B>(self: Maybe<A>, f: (a: A) => Maybe<B>): Maybe<B> {
+  self.concrete();
   return self._tag === MaybeTag.Just ? f(self.value) : (self as Nothing);
 }
 
-/**
- * @constrained
- */
-export function elem_<A>(E: Eq<A>) {
-  return (self: Maybe<A>, elem: A): boolean => (self._tag === MaybeTag.Just ? E.equals_(self.value, elem) : false);
-}
-
 /**
  * @tsplus fluent fncts.Maybe elem
  */
-export function elemSelf<A>(self: Maybe<A>) {
-  return (E: Eq<A>) =>
-    (elem: A): boolean =>
-      elem_(E)(self, elem);
+export function elem_<A>(self: Maybe<A>, elem: A, E: Eq<A>): boolean {
+  self.concrete();
+  return self._tag === MaybeTag.Just ? E.equals(self.value, elem) : false;
 }
 
 /**
@@ -50,6 +37,7 @@ export function elemSelf<A>(self: Maybe<A>) {
  * @tsplus fluent fncts.Maybe exists
  */
 export function exists_<A>(self: Maybe<A>, p: Predicate<A>): boolean {
+  self.concrete();
   return self._tag === MaybeTag.Just ? p(self.value) : false;
 }
 
@@ -59,6 +47,7 @@ export function exists_<A>(self: Maybe<A>, p: Predicate<A>): boolean {
 export function filter_<A, B>(self: Maybe<A>, p: Predicate<A>): Maybe<A>;
 export function filter_<A, B extends A>(self: Maybe<A>, p: Refinement<A, B>): Maybe<B>;
 export function filter_<A, B>(self: Maybe<A>, p: Predicate<A>): Maybe<A> {
+  self.concrete();
   return self._tag === MaybeTag.Just && p(self.value) ? self : Nothing();
 }
 
@@ -82,6 +71,7 @@ export function flatten<A>(self: Maybe<Maybe<A>>): Maybe<A> {
 export function partition_<A>(self: Maybe<A>, p: Predicate<A>): readonly [Maybe<A>, Maybe<A>];
 export function partition_<A, B extends A>(self: Maybe<A>, p: Refinement<A, B>): readonly [Maybe<A>, Maybe<B>];
 export function partition_<A>(self: Maybe<A>, p: Predicate<A>): readonly [Maybe<A>, Maybe<A>] {
+  self.concrete();
   return self._tag === MaybeTag.Just && p(self.value) ? [Nothing(), self] : [self, Nothing()];
 }
 
@@ -89,6 +79,7 @@ export function partition_<A>(self: Maybe<A>, p: Predicate<A>): readonly [Maybe<
  * @tsplus fluent fncts.Maybe partitionMap
  */
 export function partitionMap_<A, B, C>(self: Maybe<A>, f: (a: A) => Either<B, C>): readonly [Maybe<B>, Maybe<C>] {
+  self.concrete();
   if (self._tag === MaybeTag.Just) {
     return f(self.value).match(
       (b) => [Just(b), Nothing()],
@@ -103,6 +94,7 @@ export function partitionMap_<A, B, C>(self: Maybe<A>, f: (a: A) => Either<B, C>
  * @tsplus fluent fncts.Maybe foldLeft
  */
 export function foldLeft_<A, B>(self: Maybe<A>, b: B, f: (b: B, a: A) => B): B {
+  self.concrete();
   return self._tag === MaybeTag.Just ? f(b, self.value) : b;
 }
 
@@ -110,23 +102,16 @@ export function foldLeft_<A, B>(self: Maybe<A>, b: B, f: (b: B, a: A) => B): B {
  * @tsplus fluent fncts.Maybe foldRight
  */
 export function foldRight_<A, B>(self: Maybe<A>, b: B, f: (a: A, b: B) => B): B {
+  self.concrete();
   return self._tag === MaybeTag.Just ? f(self.value, b) : b;
 }
 
 /**
- * @constrained
- */
-export function foldMap_<M>(M: Monoid<M>) {
-  return <A>(self: Maybe<A>, f: (a: A) => M): M => (self._tag === MaybeTag.Just ? f(self.value) : M.nat);
-}
-
-/**
- * @tsplus getter fncts.Maybe foldMap
+ * @tsplus fluent fncts.Maybe foldMap
  */
-export function foldMapSelf<A>(self: Maybe<A>) {
-  return <M>(M: Monoid<M>) =>
-    (f: (a: A) => M): M =>
-      foldMap_(M)(self, f);
+export function foldMap_<A, M>(self: Maybe<A>, f: (a: A) => M, /** @tsplus auto */ M: Monoid<M>): M {
+  self.concrete();
+  return self._tag === MaybeTag.Just ? f(self.value) : M.nat;
 }
 
 /**
@@ -135,6 +120,7 @@ export function foldMapSelf<A>(self: Maybe<A>) {
  * @tsplus fluent fncts.Maybe getOrElse
  */
 export function getOrElse_<A, B>(self: Maybe<A>, orElse: Lazy<B>): A | B {
+  self.concrete();
   return self._tag === MaybeTag.Just ? self.value : orElse();
 }
 
@@ -144,6 +130,7 @@ export function getOrElse_<A, B>(self: Maybe<A>, orElse: Lazy<B>): A | B {
  * @tsplus fluent fncts.Maybe map
  */
 export function map_<A, B>(self: Maybe<A>, f: (a: A) => B): Maybe<B> {
+  self.concrete();
   return self._tag === MaybeTag.Just ? Just(f(self.value)) : (self as Nothing);
 }
 
@@ -160,6 +147,7 @@ export function mapNullable_<A, B>(self: Maybe<A>, f: (a: A) => Nullable<B>): Ma
  * @tsplus fluent fncts.Maybe orElse
  */
 export function orElse_<A, B>(self: Maybe<A>, fb: Lazy<Maybe<B>>): Maybe<A | B> {
+  self.concrete();
   return self._tag === MaybeTag.Nothing ? fb() : self;
 }
 
@@ -176,6 +164,8 @@ export function toUndefined<A>(self: Maybe<A>): A | undefined {
  * @tsplus fluent fncts.Maybe zipWith
  */
 export function zipWith_<A, B, C>(self: Maybe<A>, fb: Maybe<B>, f: (a: A, b: B) => C): Maybe<C> {
+  self.concrete();
+  fb.concrete();
   return self._tag === MaybeTag.Just && fb._tag === MaybeTag.Just ? Just(f(self.value, fb.value)) : Nothing();
 }
 

package/_src/data/Maybe/definition.ts

@@ -8,17 +8,31 @@ export const enum MaybeTag {
 export const MaybeTypeId = Symbol.for("fncts.Maybe");
 export type MaybeTypdId = typeof MaybeTypeId;
 
+export type MaybeF = Maybe<any>;
+
 const _justHash    = Hashable.string("fncts.Just");
 const _nothingHash = Hashable.string("fncts.Nothing");
 
+/**
+ * @tsplus type fncts.Maybe
+ * @tsplus companion fncts.MaybeOps
+ */
+export class Maybe<A> {
+  readonly _typeId: MaybeTypdId = MaybeTypeId;
+  readonly [HKT.F]!: MaybeF;
+  readonly [HKT.A]!: () => A;
+  readonly [HKT.T]!: Maybe<HKT._A<this>>;
+}
+
 /**
  * @tsplus type fncts.Just
  * @tsplus companion fncts.JustOps
  */
-export class Just<A> {
-  readonly _typeId: MaybeTypdId = MaybeTypeId;
-  readonly _tag                 = MaybeTag.Just;
-  constructor(readonly value: A) {}
+export class Just<A> extends Maybe<A> {
+  readonly _tag = MaybeTag.Just;
+  constructor(readonly value: A) {
+    super();
+  }
   [Symbol.equals](that: unknown): boolean {
     return isMaybe(that) && that.isJust() && Equatable.strictEquals(this.value, that.value);
   }
@@ -31,9 +45,8 @@ export class Just<A> {
  * @tsplus type fncts.Nothing
  * @tsplus companion fncts.NothingOps
  */
-export class Nothing {
-  readonly _typeId: MaybeTypdId = MaybeTypeId;
-  readonly _tag                 = MaybeTag.Nothing;
+export class Nothing extends Maybe<never> {
+  readonly _tag = MaybeTag.Nothing;
   [Symbol.equals](that: unknown): boolean {
     return isMaybe(that) && that.isNothing();
   }
@@ -42,18 +55,6 @@ export class Nothing {
   }
 }
 
-/**
- * @tsplus type fncts.Maybe
- */
-export type Maybe<A> = Just<A> | Nothing;
-
-/**
- * @tsplus type fncts.MaybeOps
- */
-export interface MaybeOps {}
-
-export const Maybe: MaybeOps = {};
-
 /**
  * @tsplus unify fncts.Maybe
  */
@@ -78,6 +79,7 @@ export function isMaybe(u: unknown): u is Maybe<unknown> {
  * @tsplus fluent fncts.Maybe isJust
  */
 export function isJust<A>(self: Maybe<A>): self is Just<A> {
+  self.concrete();
   return self._tag === MaybeTag.Just;
 }
 
@@ -87,5 +89,15 @@ export function isJust<A>(self: Maybe<A>): self is Just<A> {
  * @tsplus fluent fncts.Maybe isNothing
  */
 export function isNothing<A>(self: Maybe<A>): self is Nothing {
+  self.concrete();
   return self._tag === MaybeTag.Nothing;
 }
+
+/**
+ * @tsplus fluent fncts.Maybe concrete
+ * @tsplus static fncts.MaybeOps concrete
+ * @tsplus macro remove
+ */
+export function concrete<A>(self: Maybe<A>): asserts self is Just<A> | Nothing {
+  //
+}

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>>;
 }
 
 /**