@fncts/base 0.0.11 → 0.0.14

package/_src/typeclass/MonadExcept.ts

@@ -4,7 +4,7 @@ import type { Monad } from "@fncts/base/typeclass/Monad";
 /**
  * @tsplus type fncts.MonadExcept
  */
-export interface MonadExcept<F extends HKT> extends Monad<F>, ApplicativeExcept<F> {}
+export interface MonadExcept<F extends HKT, FC = HKT.None> extends Monad<F, FC>, ApplicativeExcept<F, FC> {}
 
 /**
  * @tsplus type fncts.MonadExceptOps
@@ -14,11 +14,15 @@ export interface MonadExceptOps {}
 export const MonadExcept: MonadExceptOps = {};
 
 /**
- * @tsplus fluent fncts.Kind absolve
+ * @tsplus static fncts.MonadExceptOps absolve
  */
-export function absolve<F extends HKT, K, Q, W, X, I, S, R, E, E1, A>(
-  fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, Either<E1, A>>,
-  /** @tsplus auto */ F: MonadExcept<F>,
-): HKT.Kind<F, K, Q, W, X, I, S, R, HKT.Mix<"E", [E, E1]>, A> {
-  return fa.flatMap((r) => r.match(F.fail, F.pure), F);
+export function absolve<F extends HKT, FC = HKT.None>(
+  F: MonadExcept<F, FC>,
+): <K, Q, W, X, I, S, R, E, E1, A>(
+  fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, Either<E1, A>>,
+) => HKT.Kind<F, FC, K, Q, W, X, I, S, R, HKT.Mix<F, "E", [E, E1]>, A>;
+export function absolve<F>(
+  F: MonadExcept<HKT.F<F>>,
+): <E, A, E1>(fa: HKT.FK2<F, E, Either<E1, A>>) => HKT.FK2<F, HKT.Mix<HKT.F<F>, "E", [E, E1]>, A> {
+  return (fa) => F.flatMap(fa, (r) => r.match(F.fail, F.pure));
 }

package/_src/typeclass/Nil.ts

@@ -1,32 +1,15 @@
 /**
  * @tsplus type fncts.Nil
  */
-export interface Nil<F extends HKT> extends HKT.Typeclass<F> {
+export interface Nil<F extends HKT, FC = HKT.None> extends HKT.Typeclass<F, FC> {
   nil<
-    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">,
-  >(): HKT.Kind<F, K, Q, W, X, I, S, R, E, never>;
-}
-
-/**
- * @tsplus fluent fncts.Kind nil
- */
-export function nil<
-  F extends HKT,
-  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">,
->(/** @tsplus auto */ F: Nil<F>): HKT.Kind<F, K, Q, W, X, I, S, R, E, never> {
-  return F.nil();
+    K = HKT.Low<F, "K">,
+    Q = HKT.Low<F, "Q">,
+    W = HKT.Low<F, "W">,
+    X = HKT.Low<F, "X">,
+    I = HKT.Low<F, "I">,
+    S = HKT.Low<F, "S">,
+    R = HKT.Low<F, "R">,
+    E = HKT.Low<F, "E">,
+  >(): HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, never>;
 }

package/_src/typeclass/Pointed.ts

@@ -1,17 +1,17 @@
-export interface Pointed<F extends HKT> extends HKT.Typeclass<F> {
-  pure<
+export interface Pointed<F extends HKT, FC = HKT.None> extends HKT.Typeclass<F, FC> {
+  pure: <
     A,
-    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">,
+    K = HKT.Low<F, "K">,
+    Q = HKT.Low<F, "Q">,
+    W = HKT.Low<F, "W">,
+    X = HKT.Low<F, "X">,
+    I = HKT.Low<F, "I">,
+    S = HKT.Low<F, "S">,
+    R = HKT.Low<F, "R">,
+    E = HKT.Low<F, "E">,
   >(
     a: A,
-  ): HKT.Kind<F, K, Q, W, X, I, S, R, E, A>;
+  ) => HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>;
 }
 
 /**
@@ -20,22 +20,3 @@ export interface Pointed<F extends HKT> extends HKT.Typeclass<F> {
 export interface PointedOps {}
 
 export const Pointed: PointedOps = {};
-
-/**
- * @tsplus static fncts.PointedOps pure
- */
-export function pure<
-  F extends HKT,
-  C,
-  A,
-  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">,
->(a: A, /** @tsplus auto */ F: Pointed<F>): HKT.Kind<F, K, Q, W, X, I, S, R, E, A> {
-  return F.pure(a);
-}