@fncts/base 0.0.3 → 0.0.6

package/_src/data/Either/instances.ts

@@ -1,80 +1,131 @@
+import type { Either1F, EitherF } from "@fncts/base/data/Either/definition.js";
+
+import { map_ } from "@fncts/base/data/Either/api";
+import { concrete, Either, EitherTag, Right } from "@fncts/base/data/Either/definition";
+import { EitherJson } from "@fncts/base/json/EitherJson";
+
 import * as P from "../../typeclass.js";
-import { map_ } from "./api.js";
-import { EitherTag, Left, Right } from "./definition.js";
 
-export interface EitherF extends HKT {
-  readonly type: Either<this["E"], this["A"]>;
-  readonly variance: {
-    E: "+";
-    A: "+";
-  };
-}
+/**
+ * @tsplus implicit
+ */
+export const Functor: P.Functor<EitherF> = {
+  map: map_,
+};
 
 /**
  * @tsplus static fncts.EitherOps getEq
  */
 export function getEq<E, A>(EE: P.Eq<E>, EA: P.Eq<A>): P.Eq<Either<E, A>> {
   return P.Eq({
-    equals_: (x, y) =>
+    equals: (x, y) =>
       x === y ||
       x.match(
         (e1) =>
           y.match(
-            (e2) => EE.equals_(e1, e2),
+            (e2) => EE.equals(e1, e2),
             () => false,
           ),
         (a1) =>
           y.match(
             () => false,
-            (a2) => EA.equals_(a1, a2),
+            (a2) => EA.equals(a1, a2),
           ),
       ),
   });
 }
 
 /**
- * @tsplus static fncts.EitherOps getEq
+ * @tsplus derive fncts.Eq[fncts.Either]<_> 10
  */
-export function getFilerable<E>(ME: P.Monoid<E>) {
-  type FixE = HKT.Fix<"E", E>;
-
-  const empty = Left(ME.nat);
+export function deriveEq<A extends Either<any, any>>(
+  ...[left, right]: [A] extends [Either<infer E, infer A>] ? [left: P.Eq<E>, right: P.Eq<A>] : never
+): P.Eq<A> {
+  return Either.getEq(left, right);
+}
 
-  const partitionMap_: P.partitionMap_<EitherF, FixE> = (fa, f) => {
-    if (fa._tag === EitherTag.Left) {
-      return [fa, fa];
-    }
-    const fb = f(fa.right);
-    switch (fb._tag) {
-      case EitherTag.Left:
-        return [Right(fb.left), empty];
-      case EitherTag.Right:
-        return [empty, fb];
-    }
+/**
+ * @tsplus static fncts.EitherOps getFilterable
+ */
+export function getFilerable<E>(/** @tsplus auto */ ME: P.Monoid<E>): P.Filterable<Either1F<E>> {
+  return <P.Filterable<Either1F<E>>>{
+    ...Functor,
+    partitionMap: (fa, f) => {
+      concrete(fa);
+      if (fa._tag === EitherTag.Left) {
+        return [fa, fa];
+      }
+      const fb = f(fa.right);
+      concrete(fb);
+      switch (fb._tag) {
+        case EitherTag.Left:
+          return [Right(fb.left), Either.left(ME.nat)];
+        case EitherTag.Right:
+          return [Either.left(ME.nat), fb];
+      }
+    },
+    filter: <A>(fa: Either<E, A>, p: Predicate<A>) => {
+      concrete(fa);
+      switch (fa._tag) {
+        case EitherTag.Left:
+          return fa;
+        case EitherTag.Right:
+          return p(fa.right) ? fa : Either.left(ME.nat);
+      }
+    },
+    filterMap: (fa, f) => {
+      concrete(fa);
+      if (fa._tag === EitherTag.Left) {
+        return fa;
+      }
+      return f(fa.right).match(
+        () => Either.left(ME.nat),
+        (b) => Either.right(b),
+      );
+    },
+    partition: <A>(fa: Either<E, A>, p: Predicate<A>): readonly [Either<E, A>, Either<E, A>] => {
+      concrete(fa);
+      if (fa._tag === EitherTag.Left) {
+        return [fa, fa];
+      }
+      return p(fa.right) ? [Either.left(ME.nat), fa] : [fa, Either.left(ME.nat)];
+    },
   };
+}
 
-  const partition_: P.partition_<EitherF, FixE> = <A>(
-    fa: Either<E, A>,
-    p: Predicate<A>,
-  ): readonly [Either<E, A>, Either<E, A>] =>
-    fa._tag === EitherTag.Left ? [fa, fa] : p(fa.right) ? [empty, fa] : [fa, empty];
-
-  const filterMap_: P.filterMap_<EitherF, FixE> = (fa, f) =>
-    fa._tag === EitherTag.Left
-      ? fa
-      : f(fa.right).match(
-          () => empty,
-          (b) => Right(b),
-        );
-
-  const filter_: P.filter_<EitherF, FixE> = <A>(fa: Either<E, A>, p: Predicate<A>): Either<E, A> =>
-    fa._tag === EitherTag.Left ? fa : p(fa.right) ? fa : empty;
-
-  return P.Filterable<EitherF, FixE>({
-    map_,
-    filter_,
-    filterMap_,
-    partition_,
-    partitionMap_,
+/**
+ * @tsplus derive fncts.Guard[fncts.Either]<_> 10
+ */
+export function deriveGuard<A extends Either<any, any>>(
+  ...[left, right]: [A] extends [Either<infer E, infer A>] ? [left: Guard<E>, right: Guard<A>] : never
+): Guard<A> {
+  return Guard((u): u is A => {
+    if (Either.isEither(u)) {
+      if (u.isLeft()) {
+        return left.is(u.left);
+      }
+      if (u.isRight()) {
+        return right.is(u.right);
+      }
+    }
+    return false;
   });
 }
+
+/**
+ * @tsplus derive fncts.Decoder[fncts.Either]<_> 10
+ */
+export function deriveDecoder<A extends Either<any, any>>(
+  ...[left, right]: [A] extends [Either<infer E, infer A>] ? [left: Decoder<E>, right: Decoder<A>] : never
+): Decoder<A> {
+  const jsonDecoder = EitherJson.getDecoder(left, right);
+  return Decoder(
+    (u) =>
+      jsonDecoder
+        .decode(u)
+        .map((result) =>
+          result._tag === "Left" ? (Either.left(result.left) as A) : (Either.right(result.right) as A),
+        ),
+    `Either<${left.label}, ${right.label}>`,
+  );
+}

package/_src/data/Environment/api.ts

@@ -2,7 +2,8 @@
  * @tsplus fluent fncts.Environment add
  */
 export function add<R, S, H extends S = S>(self: Environment<R>, service: H, tag: Tag<S>): Environment<R & Has<S>> {
-  return new Environment(self.map.set(tag, [service, self.index]), self.index + 1);
+  const self0 = self.index === Number.MAX_SAFE_INTEGER ? self.clean : self;
+  return new Environment(self0.map.set(tag, [service, self0.index]), self0.index + 1);
 }
 
 /**
@@ -36,12 +37,27 @@ export function make(): Environment<unknown> {
  * @tsplus fluent fncts.Environment union
  */
 export function union<R, R1>(self: Environment<R>, that: Environment<R1>): Environment<R & R1> {
+  const [self0, that0] = self.index + that.index < self.index ? [self.clean, that.clean] : [self, that];
   return new Environment(
-    self.map.union(that.map.map(([service, index]) => [service, self.index + index] as const)),
-    self.index + that.index,
+    self0.map.union(that0.map.map(([service, index]) => [service, self0.index + index] as const)),
+    self0.index + that0.index,
   );
 }
 
+/**
+ * @tsplus getter fncts.Environment clean
+ */
+export function clean<R>(self: Environment<R>): Environment<R> {
+  const [map, index] = self.map.toList
+    .sort(Number.Ord.contramap(([, [, idx]]) => idx))
+    .foldLeft(
+      [HashMap.makeDefault<Tag<unknown>, readonly [unknown, number]>(), 0],
+      ([map, index], [tag, [service]]) => [map.set(tag, [service, index] as const), index + 1],
+    );
+
+  return new Environment(map, index);
+}
+
 /**
  * @tsplus fluent fncts.Environment unsafeGet
  */
@@ -67,7 +83,6 @@ export function unsafeGet<R, S>(self: Environment<R>, tag: Tag<S>): S {
     },
     (a) => a as S,
   );
-  // return self.cache.unsafeGet(tag) as S;
 }
 
 /**

package/_src/data/Identity/api.ts

@@ -2,14 +2,14 @@
  * @tsplus fluent fncts.Identity ap
  */
 export function ap_<A, B>(fab: Identity<(a: A) => B>, fa: Identity<A>): Identity<B> {
-  return fab(fa);
+  return Identity.get(Identity.reverseGet(fab)(Identity.reverseGet(fa)));
 }
 
 /**
  * @tsplus fluent fncts.Identity map
  */
 export function map_<A, B>(fa: Identity<A>, f: (a: A) => B): Identity<B> {
-  return f(fa);
+  return Identity.get(f(Identity.reverseGet(fa)));
 }
 
 /**
@@ -17,12 +17,27 @@ export function map_<A, B>(fa: Identity<A>, f: (a: A) => B): Identity<B> {
  * @tsplus static fncts.IdentityOps __call
  */
 export function pure<A>(a: A): Identity<A> {
-  return a;
+  return Identity.get(a);
 }
 
 /**
  * @tsplus fluent fncts.Identity zipWith
  */
 export function zipWith_<A, B, C>(fa: Identity<A>, fb: Identity<B>, f: (a: A, b: B) => C): Identity<C> {
-  return f(fa, fb);
+  return Identity.get(f(Identity.reverseGet(fa), Identity.reverseGet(fb)));
 }
+
+/**
+ * @tsplus fluent fncts.Identity zip
+ */
+export function zip_<A, B>(fa: Identity<A>, fb: Identity<B>): Identity<readonly [A, B]> {
+  return fa.zipWith(fb, (a, b) => [a, b]);
+}
+
+/**
+ * @tsplus getter fncts.Identity getIdentity
+ * @tsplus macro identity
+ */
+export function getIdentity<A>(self: Identity<A>): A {
+  return Identity.reverseGet(self);
+}

package/_src/data/Identity/definition.ts

@@ -1,11 +1,15 @@
+export interface IdentityN {
+  readonly [HKT.T]: Identity<HKT._A<this>>
+}
+
 /**
  * @tsplus type fncts.Identity
  */
-export type Identity<A> = A;
+export interface Identity<A> extends Newtype<"Identity", A> {}
 
 /**
  * @tsplus type fncts.IdentityOps
  */
-export interface IdentityOps {}
+export interface IdentityOps extends NewtypeIso<IdentityN> {}
 
-export const Identity: IdentityOps = {};
+export const Identity: IdentityOps = Newtype<IdentityN>();

package/_src/data/Identity/instances.ts

@@ -1,21 +1,28 @@
-import * as P from "../../typeclass.js";
-import { ap_, map_, pure, zipWith_ } from "./api.js";
+import type * as P from "../../typeclass.js";
+import type { IdentityN } from "@fncts/base/data/Identity/definition";
 
-export interface IdentityF extends HKT {
-  readonly type: Identity<this["A"]>;
-}
+import { ap_, map_, pure, zip_, zipWith_ } from "./api.js";
 
 /**
  * @tsplus static fncts.IdentityOps Functor
  */
-export const Functor = P.Functor<IdentityF>({ map_ });
+export const Functor: P.Functor<IdentityN> = {
+  map: map_,
+};
 
 /**
  * @tsplus static fncts.IdentityOps Apply
  */
-export const Apply = P.Apply<IdentityF>({ map_, ap_, zipWith_ });
+export const Apply: P.Apply<IdentityN> = {
+  ...Functor,
+  zip: zip_,
+  zipWith: zipWith_,
+};
 
 /**
  * @tsplus static fncts.IdentityOps Applicative
  */
-export const Applicative = P.Applicative<IdentityF>({ map_, ap_, zipWith_, pure });
+export const Applicative: P.Applicative<IdentityN> = {
+  ...Apply,
+  pure,
+};

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 {
+  //
+}