@fncts/base 0.0.39 → 0.0.41

package/_src/data/DatumEither/api.ts

@@ -9,50 +9,8 @@ import { EitherT } from "../EitherT/definition.js";
 
 const _Initial: DatumEither<never, never> = Datum.initial();
 
-/**
- * @tsplus static fncts.DatumEitherOps initial
- */
-export function initial<E = never, A = never>(): DatumEither<E, A> {
-  return _Initial;
-}
-
 const _Pending: DatumEither<never, never> = Datum.pending();
 
-/**
- * @tsplus static fncts.DatumEitherOps pending
- */
-export function pending<E = never, A = never>(): DatumEither<E, A> {
-  return _Pending;
-}
-
-/**
- * @tsplus static fncts.DatumEitherOps refreshLeft
- */
-export function refreshLeft<E, A = never>(e: E): DatumEither<E, A> {
-  return Datum.refresh(Either.left(e));
-}
-
-/**
- * @tsplus static fncts.DatumEitherOps refreshRight
- */
-export function refreshRight<E = never, A = never>(a: A): DatumEither<E, A> {
-  return Datum.replete(Either.right(a));
-}
-
-/**
- * @tsplus static fncts.DatumEitherOps repleteLeft
- */
-export function repleteLeft<E, A = never>(e: E): DatumEither<E, A> {
-  return Datum.replete(Either.left(e));
-}
-
-/**
- * @tsplus static fncts.DatumEitherOps repleteRight
- */
-export function repleteRight<E = never, A = never>(a: A): DatumEither<E, A> {
-  return Datum.replete(Either.right(a));
-}
-
 /**
  * @tsplus pipeable fncts.DatumEither bimap
  */
@@ -116,6 +74,39 @@ export function filterMap<A, B>(f: (a: A) => Maybe<B>) {
   };
 }
 
+/**
+ * @tsplus static fncts.DatumEitherOps pending
+ */
+export function pending<E = never, A = never>(): DatumEither<E, A> {
+  return _Pending;
+}
+
+/**
+ * @tsplus static fncts.DatumEitherOps refreshLeft
+ */
+export function refreshLeft<E, A = never>(e: E): DatumEither<E, A> {
+  return Datum.refresh(Either.left(e));
+}
+/**
+ * @tsplus static fncts.DatumEitherOps refreshRight
+ */
+export function refreshRight<E = never, A = never>(a: A): DatumEither<E, A> {
+  return Datum.replete(Either.right(a));
+}
+/**
+ * @tsplus static fncts.DatumEitherOps repleteLeft
+ */
+export function repleteLeft<E, A = never>(e: E): DatumEither<E, A> {
+  return Datum.replete(Either.left(e));
+}
+
+/**
+ * @tsplus static fncts.DatumEitherOps repleteRight
+ */
+export function repleteRight<E = never, A = never>(a: A): DatumEither<E, A> {
+  return Datum.replete(Either.right(a));
+}
+
 /**
  * @tsplus pipeable fncts.DatumEither flatMap
  */
@@ -171,6 +162,13 @@ export function getOrElse<E, B, C>(onEmpty: () => B, onLeft: (e: E) => C) {
   };
 }
 
+/**
+ * @tsplus static fncts.DatumEitherOps initial
+ */
+export function initial<E = never, A = never>(): DatumEither<E, A> {
+  return _Initial;
+}
+
 /**
  * @tsplus pipeable fncts.DatumEither map
  */
@@ -328,7 +326,7 @@ export const toReplete: <E, A>(self: DatumEither<E, A>) => DatumEither<E, A> = _
 /**
  * @tsplus getter fncts.DatumEither traverse
  */
-export function _traverse<E, A>(self: DatumEither<E, A>) {
+export function traverse_<E, A>(self: DatumEither<E, A>) {
   return <G extends HKT, GC = HKT.None>(G: P.Applicative<G, GC>) =>
     <K, Q, W, X, I, S, R, E1, B>(
       f: (a: A) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, B>,

package/_src/data/Either/api.ts

@@ -74,22 +74,22 @@ export function foldLeft<A, B>(b: B, f: (b: B, a: A) => B) {
 }
 
 /**
- * @tsplus pipeable fncts.Either foldRight
+ * @tsplus pipeable fncts.Either foldMap
  */
-export function foldRight<A, B>(b: B, f: (a: A, b: B) => B) {
-  return <E>(self: Either<E, A>): B => {
+export function foldMap<A, M>(f: (a: A) => M, /** @tsplus auto */ M: P.Monoid<M>) {
+  return <E>(self: Either<E, A>): M => {
     self.concrete();
-    return self._tag === EitherTag.Left ? b : f(self.right, b);
+    return self._tag === EitherTag.Left ? M.nat : f(self.right);
   };
 }
 
 /**
- * @tsplus pipeable fncts.Either foldMap
+ * @tsplus pipeable fncts.Either foldRight
  */
-export function foldMap<A, M>(f: (a: A) => M, /** @tsplus auto */ M: P.Monoid<M>) {
-  return <E>(self: Either<E, A>): M => {
+export function foldRight<A, B>(b: B, f: (a: A, b: B) => B) {
+  return <E>(self: Either<E, A>): B => {
     self.concrete();
-    return self._tag === EitherTag.Left ? M.nat : f(self.right);
+    return self._tag === EitherTag.Left ? b : f(self.right, b);
   };
 }
 
@@ -103,6 +103,15 @@ export function getLeft<E, A>(self: Either<E, A>): Maybe<E> {
   );
 }
 
+/**
+ * @tsplus pipeable fncts.Either getOrElse
+ */
+export function getOrElse<E, B>(orElse: (e: E) => B) {
+  return <A>(self: Either<E, A>): A | B => {
+    return self.match(orElse, identity);
+  };
+}
+
 /**
  * @tsplus getter fncts.Either getRight
  */
@@ -113,15 +122,6 @@ export function getRight<E, A>(self: Either<E, A>): Maybe<A> {
   );
 }
 
-/**
- * @tsplus pipeable fncts.Either getOrElse
- */
-export function getOrElse<E, B>(orElse: (e: E) => B) {
-  return <A>(self: Either<E, A>): A | B => {
-    return self.match(orElse, identity);
-  };
-}
-
 /**
  * @tsplus static fncts.EitherOps isEither
  */
@@ -196,7 +196,7 @@ export function swap<E, A>(self: Either<E, A>): Either<A, E> {
 /**
  * @tsplus getter fncts.Either traverse
  */
-export function _traverse<E, A>(self: Either<E, A>) {
+export function traverse_<E, A>(self: Either<E, A>) {
   return <G extends HKT, GC = HKT.None>(G: P.Applicative<G, GC>) =>
     <K, Q, W, X, I, S, R, E1, B>(
       f: (a: A) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, B>,
@@ -207,25 +207,15 @@ export function _traverse<E, A>(self: Either<E, A>) {
       );
 }
 
-export const traverse_: P.Traversable<EitherF>["traverse"] = (A) => (f) => (self) => self.traverse(A)(f);
+export const traverse: P.Traversable<EitherF>["traverse"] = (A) => (f) => (self) => self.traverse(A)(f);
 
 /**
- * @tsplus pipeable fncts.Either zipWith
+ * @tsplus pipeable fncts.Either filter
  */
-export function zipWith<A, E2, B, C>(fb: Either<E2, B>, f: (a: A, b: B) => C) {
-  return <E1>(self: Either<E1, A>): Either<E1 | E2, C> => {
+export function filter<E, A>(f: Predicate<A>, /** @tsplus auto */ M: P.Monoid<E>) {
+  return (self: Either<E, A>): Either<E, A> => {
     self.concrete();
-    fb.concrete();
-    return self._tag === EitherTag.Left ? self : fb._tag === EitherTag.Left ? fb : Right(f(self.right, fb.right));
-  };
-}
-
-/**
- * @tsplus pipeable fncts.Either zip
- */
-export function zip<E1, B>(that: Either<E1, B>) {
-  return <E, A>(self: Either<E, A>): Either<E | E1, Zipped.Make<A, B>> => {
-    return self.zipWith(that, (a, b) => Zipped(a, b));
+    return self._tag === EitherTag.Left ? self : f(self.right) ? self : Left(M.nat);
   };
 }
 
@@ -245,12 +235,12 @@ export function filterMap<E, A, B>(f: (a: A) => Maybe<B>, /** @tsplus auto */ M:
 }
 
 /**
- * @tsplus pipeable fncts.Either filter
+ * @tsplus pipeable fncts.Either partition
  */
-export function filter<E, A>(f: Predicate<A>, /** @tsplus auto */ M: P.Monoid<E>) {
-  return (self: Either<E, A>): Either<E, A> => {
+export function partition<E, A>(p: Predicate<A>, /** @tsplus auto */ M: P.Monoid<E>) {
+  return (self: Either<E, A>): readonly [Either<E, A>, Either<E, A>] => {
     self.concrete();
-    return self._tag === EitherTag.Left ? self : f(self.right) ? self : Left(M.nat);
+    return self._tag === EitherTag.Left ? [self, self] : p(self.right) ? [Left(M.nat), self] : [self, Left(M.nat)];
   };
 }
 
@@ -274,16 +264,6 @@ export function partitionMap<E, A, B, C>(f: (a: A) => Either<B, C>, /** @tsplus
   };
 }
 
-/**
- * @tsplus pipeable fncts.Either partition
- */
-export function partition<E, A>(p: Predicate<A>, /** @tsplus auto */ M: P.Monoid<E>) {
-  return (self: Either<E, A>): readonly [Either<E, A>, Either<E, A>] => {
-    self.concrete();
-    return self._tag === EitherTag.Left ? [self, self] : p(self.right) ? [Left(M.nat), self] : [self, Left(M.nat)];
-  };
-}
-
 /**
  * @tsplus getter fncts.Either toMaybe
  */
@@ -294,6 +274,26 @@ export function toMaybe<E, A>(self: Either<E, A>): Maybe<A> {
   );
 }
 
+/**
+ * @tsplus pipeable fncts.Either zip
+ */
+export function zip<E1, B>(that: Either<E1, B>) {
+  return <E, A>(self: Either<E, A>): Either<E | E1, Zipped.Make<A, B>> => {
+    return self.zipWith(that, (a, b) => Zipped(a, b));
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.Either zipWith
+ */
+export function zipWith<A, E2, B, C>(fb: Either<E2, B>, f: (a: A, b: B) => C) {
+  return <E1>(self: Either<E1, A>): Either<E1 | E2, C> => {
+    self.concrete();
+    fb.concrete();
+    return self._tag === EitherTag.Left ? self : fb._tag === EitherTag.Left ? fb : Right(f(self.right, fb.right));
+  };
+}
+
 // codegen:start { preset: barrel, include: api/*.ts }
 export * from "./api/align.js";
 export * from "./api/alignWith.js";

package/_src/data/Either/constructors.ts

@@ -2,22 +2,6 @@ import type { Nullable } from "@fncts/base/types";
 
 import { Either, Left, Right } from "./definition.js";
 
-/**
- * @tsplus static fncts.EitherOps left
- * @tsplus static fncts.Either.LeftOps __call
- */
-export function left<E = never, A = never>(e: E, __tsplusTrace?: string): Either<E, A> {
-  return new Left(e, __tsplusTrace);
-}
-
-/**
- * @tsplus static fncts.EitherOps right
- * @tsplus static fncts.Either.RightOps __call
- */
-export function right<E = never, A = never>(a: A, __tsplusTrace?: string): Either<E, A> {
-  return new Right(a, __tsplusTrace);
-}
-
 /**
  * @tsplus static fncts.EitherOps fromMaybe
  * @tsplus pipeable fncts.Maybe toEither
@@ -56,6 +40,20 @@ export function fromPredicate<E, A>(value: A, p: Predicate<A>, otherwise: (a: A)
 export function fromPredicate<E, A>(value: A, p: Predicate<A>, otherwise: (a: A) => E): Either<E, A> {
   return p(value) ? Right(value) : left(otherwise(value));
 }
+/**
+ * @tsplus static fncts.EitherOps left
+ * @tsplus static fncts.Either.LeftOps __call
+ */
+export function left<E = never, A = never>(e: E, __tsplusTrace?: string): Either<E, A> {
+  return new Left(e, __tsplusTrace);
+}
+/**
+ * @tsplus static fncts.EitherOps right
+ * @tsplus static fncts.Either.RightOps __call
+ */
+export function right<E = never, A = never>(a: A, __tsplusTrace?: string): Either<E, A> {
+  return new Right(a, __tsplusTrace);
+}
 
 /**
  * @tsplus static fncts.EitherOps tryCatch

package/_src/data/EitherT/api.ts

@@ -1,77 +1,6 @@
 import type { EitherT } from "./definition.js";
 import type * as P from "@fncts/base/typeclass";
 
-/**
- * @tsplus static fncts.EitherTOps __call
- */
-export function make<F extends HKT, FC, K, Q, W, X, I, S, R, FE, E, A>(
-  self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, Either<E, A>>,
-): EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A> {
-  return self;
-}
-
-/**
- * @tsplus static fncts.EitherTOps right
- */
-export function right<F extends HKT, FC>(
-  F: P.Pointed<F, FC>,
-): <K, Q, W, X, I, S, R, FE, E = never, A = never>(a: A) => EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A> {
-  return (a) => F.pure(Either.right(a));
-}
-
-/**
- * @tsplus static fncts.EitherTOps left
- */
-export function left<F extends HKT, FC>(
-  F: P.Pointed<F, FC>,
-): <K, Q, W, X, I, S, R, FE, E, A = never>(e: E) => EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A> {
-  return (e) => F.pure(Either.left(e));
-}
-
-/**
- * @tsplus static fncts.EitherTOps rightF
- */
-export function rightF<F extends HKT, FC>(
-  F: P.Functor<F, FC>,
-): <K, Q, W, X, I, S, R, FE, E = never, A = never>(
-  self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, A>,
-) => EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A> {
-  return F.map(Either.right);
-}
-
-/**
- * @tsplus static fncts.EitherTOps leftF
- */
-export function leftF<F extends HKT, FC>(
-  F: P.Functor<F, FC>,
-): <K, Q, W, X, I, S, R, FE, E = never, A = never>(
-  self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, E>,
-) => EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A> {
-  return F.map(Either.left);
-}
-
-/**
- * @tsplus static fncts.EitherTOps map
- */
-export function map<F extends HKT, FC>(F: P.Functor<F, FC>) {
-  return <A, B>(
-    f: (a: A) => B,
-  ): (<K, Q, W, X, I, S, R, FE, E>(
-    self: EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A>,
-  ) => EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, B>) => F.map((either) => either.map(f));
-}
-
-/**
- * @tsplus static fncts.EitherTOps mapLeft
- */
-export function mapLeft<F extends HKT, FC = HKT.None>(F: P.Functor<F, FC>) {
-  return <E, E1>(
-    f: (e: E) => E1,
-  ): (<K, Q, W, X, I, S, R, FE, A>(
-    self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, Either<E, A>>,
-  ) => HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, Either<E1, A>>) => F.map((either) => either.mapLeft(f));
-}
-
 /**
  * @tsplus static fncts.EitherTOps bimap
  */
@@ -142,46 +71,54 @@ export function flatMap<F extends HKT, FC>(F: P.Monad<F, FC>) {
 }
 
 /**
- * @tsplus static fncts.EitherTOps zipWith
+ * @tsplus static fncts.EitherTOps left
  */
-export function zipWith<F extends HKT, FC = HKT.None>(
-  F: P.Apply<F, FC>,
-): <K, Q, W, X, I, S, R, EF, A, K1, Q1, W1, X1, I1, S1, R1, EF1, E1, B, C>(
-  that: HKT.Kind<
-    F,
-    FC,
-    HKT.Intro<F, "K", K, K1>,
-    HKT.Intro<F, "Q", Q, Q1>,
-    HKT.Intro<F, "W", W, W1>,
-    HKT.Intro<F, "X", X, X1>,
-    HKT.Intro<F, "I", I, I1>,
-    HKT.Intro<F, "S", S, S1>,
-    HKT.Intro<F, "R", R, R1>,
-    HKT.Intro<F, "E", EF, EF1>,
-    Either<E1, B>
-  >,
-  f: (a: A, b: B) => C,
-) => <E>(
-  self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, EF, Either<E, A>>,
-) => HKT.Kind<
-  F,
-  FC,
-  HKT.Intro<F, "K", K, K1>,
-  HKT.Intro<F, "Q", Q, Q1>,
-  HKT.Intro<F, "W", W, W1>,
-  HKT.Intro<F, "X", X, X1>,
-  HKT.Intro<F, "I", I, I1>,
-  HKT.Intro<F, "S", S, S1>,
-  HKT.Intro<F, "R", R, R1>,
-  HKT.Intro<F, "E", EF, EF1>,
-  Either<E | E1, C>
->;
-export function zipWith<F extends HKT>(F: P.Apply<HKT.F<F>>) {
-  return <A, E1, B, C>(
-    that: HKT.FK1<F, Either<E1, B>>,
-    f: (a: A, b: B) => C,
-  ): (<E>(self: HKT.FK1<F, Either<E, A>>) => HKT.FK1<F, Either<E | E1, C>>) =>
-    F.zipWith(that, (a, b) => a.zipWith(b, f));
+export function left<F extends HKT, FC>(
+  F: P.Pointed<F, FC>,
+): <K, Q, W, X, I, S, R, FE, E, A = never>(e: E) => EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A> {
+  return (e) => F.pure(Either.left(e));
+}
+
+/**
+ * @tsplus static fncts.EitherTOps leftF
+ */
+export function leftF<F extends HKT, FC>(
+  F: P.Functor<F, FC>,
+): <K, Q, W, X, I, S, R, FE, E = never, A = never>(
+  self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, E>,
+) => EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A> {
+  return F.map(Either.left);
+}
+
+/**
+ * @tsplus static fncts.EitherTOps __call
+ */
+export function make<F extends HKT, FC, K, Q, W, X, I, S, R, FE, E, A>(
+  self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, Either<E, A>>,
+): EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A> {
+  return self;
+}
+
+/**
+ * @tsplus static fncts.EitherTOps map
+ */
+export function map<F extends HKT, FC>(F: P.Functor<F, FC>) {
+  return <A, B>(
+    f: (a: A) => B,
+  ): (<K, Q, W, X, I, S, R, FE, E>(
+    self: EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A>,
+  ) => EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, B>) => F.map((either) => either.map(f));
+}
+
+/**
+ * @tsplus static fncts.EitherTOps mapLeft
+ */
+export function mapLeft<F extends HKT, FC = HKT.None>(F: P.Functor<F, FC>) {
+  return <E, E1>(
+    f: (e: E) => E1,
+  ): (<K, Q, W, X, I, S, R, FE, A>(
+    self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, Either<E, A>>,
+  ) => HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, Either<E1, A>>) => F.map((either) => either.mapLeft(f));
 }
 
 /**
@@ -220,6 +157,7 @@ export function orElse<F extends HKT, FC = HKT.None>(
   HKT.Mix<F, "E", [EF, EF1]>,
   Either<E | E1, A | B>
 >;
+
 export function orElse<F>(F: P.Monad<HKT.F1<F>>) {
   return <E, A, E1, B>(
     that: Lazy<HKT.FK1<F, Either<E1, B>>>,
@@ -231,3 +169,66 @@ export function orElse<F>(F: P.Monad<HKT.F1<F>>) {
       ),
     );
 }
+
+/**
+ * @tsplus static fncts.EitherTOps right
+ */
+export function right<F extends HKT, FC>(
+  F: P.Pointed<F, FC>,
+): <K, Q, W, X, I, S, R, FE, E = never, A = never>(a: A) => EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A> {
+  return (a) => F.pure(Either.right(a));
+}
+
+/**
+ * @tsplus static fncts.EitherTOps rightF
+ */
+export function rightF<F extends HKT, FC>(
+  F: P.Functor<F, FC>,
+): <K, Q, W, X, I, S, R, FE, E = never, A = never>(
+  self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, A>,
+) => EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A> {
+  return F.map(Either.right);
+}
+
+/**
+ * @tsplus static fncts.EitherTOps zipWith
+ */
+export function zipWith<F extends HKT, FC = HKT.None>(
+  F: P.Apply<F, FC>,
+): <K, Q, W, X, I, S, R, EF, A, K1, Q1, W1, X1, I1, S1, R1, EF1, E1, B, C>(
+  that: HKT.Kind<
+    F,
+    FC,
+    HKT.Intro<F, "K", K, K1>,
+    HKT.Intro<F, "Q", Q, Q1>,
+    HKT.Intro<F, "W", W, W1>,
+    HKT.Intro<F, "X", X, X1>,
+    HKT.Intro<F, "I", I, I1>,
+    HKT.Intro<F, "S", S, S1>,
+    HKT.Intro<F, "R", R, R1>,
+    HKT.Intro<F, "E", EF, EF1>,
+    Either<E1, B>
+  >,
+  f: (a: A, b: B) => C,
+) => <E>(
+  self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, EF, Either<E, A>>,
+) => HKT.Kind<
+  F,
+  FC,
+  HKT.Intro<F, "K", K, K1>,
+  HKT.Intro<F, "Q", Q, Q1>,
+  HKT.Intro<F, "W", W, W1>,
+  HKT.Intro<F, "X", X, X1>,
+  HKT.Intro<F, "I", I, I1>,
+  HKT.Intro<F, "S", S, S1>,
+  HKT.Intro<F, "R", R, R1>,
+  HKT.Intro<F, "E", EF, EF1>,
+  Either<E | E1, C>
+>;
+export function zipWith<F extends HKT>(F: P.Apply<HKT.F<F>>) {
+  return <A, E1, B, C>(
+    that: HKT.FK1<F, Either<E1, B>>,
+    f: (a: A, b: B) => C,
+  ): (<E>(self: HKT.FK1<F, Either<E, A>>) => HKT.FK1<F, Either<E | E1, C>>) =>
+    F.zipWith(that, (a, b) => a.zipWith(b, f));
+}

package/_src/data/Environment/api.ts

@@ -3,10 +3,13 @@ import { ServiceNotFoundError } from "@fncts/base/data/Environment/ServiceNotFou
 /**
  * @tsplus pipeable fncts.Environment add
  */
-export function add<H extends S, S = H>(service: H, tag: Tag<S>): <R>(self: Environment<R>) => Environment<R | S>;
+export function add<H extends S, S = H>(
+  service: H,
+  /** @tsplus auto */ tag: Tag<S>,
+): <R>(self: Environment<R>) => Environment<R | S>;
 export function add<H extends S, S = H, I = S>(
   service: H,
-  tag: Tag<S, I>,
+  /** @tsplus auto */ tag: Tag<S, I>,
 ): <R>(self: Environment<R>) => Environment<R | I>;
 export function add<H extends S, S = H>(service: H, tag: Tag<S>) {
   return <R>(self: Environment<R>): Environment<R | S> => {
@@ -35,7 +38,7 @@ export function get<R, T extends Tags<R>>(tag: T) {
  */
 export function getMaybe<S, I>(tag: Tag<S, I>) {
   return <R>(self: Environment<R>): Maybe<S> => {
-    return self.cache.get(tag) as Maybe<S>;
+    return unsafeCoerce(self.cache.get(tag));
   };
 }