feat: minor either and reader_either changes

* renamed either getMonoid and getSemigroup to getRightMonoid
  and getRightSemigroup
* implemented getLeftSemigroup in either.ts
* reverse compose in fns.ts to make it pipeable
* implemented compose for reader_either.ts
* added Guard type to types.ts

either.ts

@@ -172,17 +172,24 @@ export const getOrd = <E, A>(
   },
 });
 
-export const getSemigroup = <E, A>(
+export const getLeftSemigroup = <E, A>(
+  SE: TC.Semigroup<E>,
+): TC.Semigroup<Either<E, A>> => ({
+  concat: (x, y) =>
+    isRight(x) ? x : isRight(y) ? y : left(SE.concat(x.left, y.left)),
+});
+
+export const getRightSemigroup = <E, A>(
   SA: TC.Semigroup<A>,
 ): TC.Semigroup<Either<E, A>> => ({
   concat: (x, y) =>
     isLeft(x) ? x : isLeft(y) ? y : right(SA.concat(x.right, y.right)),
 });
 
-export const getMonoid = <E, A>(
+export const getRightMonoid = <E, A>(
   MA: TC.Monoid<A>,
 ): TC.Monoid<Either<E, A>> => ({
-  ...getSemigroup(MA),
+  ...getRightSemigroup(MA),
   empty: () => right(MA.empty()),
 });
 

fns.ts

@@ -31,8 +31,8 @@ export const flip = <A, B, C>(f: Fn<[A], Fn<[B], C>>): Fn<[B], Fn<[A], C>> =>
 export const swap = <A, B, C>(fn: Fn<[A, B], C>): Fn<[B, A], C> =>
   (b, a) => fn(a, b);
 
-export const compose = <A, B>(fab: Fn<[A], B>) =>
-  <C>(fbc: Fn<[B], C>): Fn<[A], C> => (a) => fbc(fab(a));
+export const compose = <B, C>(fbc: Fn<[B], C>) =>
+  <A>(fab: Fn<[A], B>): Fn<[A], C> => (a) => fbc(fab(a));
 
 export const constant = <A>(a: A): Lazy<A> => () => a;
 

reader_either.ts

@@ -102,7 +102,7 @@ export const getRightMonad = <F>(
   return {
     of: right,
     ap: (tfab) => (ta) => (r) => M.ap(tfab(r))(ta(r)),
-    map: (fab) => (ta) => (r) => M.map(fab)(ta(r)),
+    map: (fab) => (ta) => flow(ta, M.map(fab)),
     join: (tta) =>
       (r) =>
         pipe(
@@ -127,6 +127,10 @@ export const { of, ap, map, join, chain } = Monad;
 
 export const { bimap, mapLeft } = Bifunctor;
 
+export const compose = <E, B, C>(rbc: ReaderEither<B, E, C>) =>
+  <A>(rab: ReaderEither<A, E, B>): ReaderEither<A, E, C> =>
+    flow(rab, E.chain(rbc));
+
 /***************************************************************************************************
  * @section Sequence
  **************************************************************************************************/

types.ts

@@ -18,6 +18,10 @@ export interface Predicate<A> {
   (a: A): boolean;
 }
 
+export interface Guard<A> {
+  (a: unknown): a is A;
+}
+
 export interface Refinement<A, B extends A> {
   (a: A): a is B;
 }