feat: extended type constructer lengths to 4

In order to support Middleware<I, O, E, A> as an indexed monad
I needed to handle type classes with constructors of length 4.
Added the length and squashed all the type bugs.

Also, added a few static-land modules to array.ts

array.ts

@@ -79,11 +79,20 @@ export const getMonoid = <A = never>(): TC.Monoid<ReadonlyArray<A>> => ({
  * @section Modules
  **************************************************************************************************/
 
+export const Functor: TC.Functor<ReadonlyArray<_>> = {
+  map: (fab, ta) => _map(ta, (a) => fab(a)),
+};
+
 export const Monad = D.createMonad<ReadonlyArray<_>>({
   of: (a) => [a],
-  chain: (fatb, ta) => _map(ta, fatb).flat(),
+  chain: (fatb, ta) => _map(ta, (b) => fatb(b)).flat(1),
 });
 
+export const Apply: TC.Apply<ReadonlyArray<_>> = {
+  ap: Monad.ap,
+  map: Functor.map,
+};
+
 export const IndexedFoldable: TC.IndexedFoldable<ReadonlyArray<_>> = {
   reduce: (faba, a, tb) => _reduce(tb, faba, a),
 };

derivations.ts

@@ -14,6 +14,7 @@ type CreateMonad = {
   <T, L extends 1>(M: Pick<TC.Monad<T, L>, "of" | "chain">): TC.Monad<T, L>;
   <T, L extends 2>(M: Pick<TC.Monad<T, L>, "of" | "chain">): TC.Monad<T, L>;
   <T, L extends 3>(M: Pick<TC.Monad<T, L>, "of" | "chain">): TC.Monad<T, L>;
+  <T, L extends 4>(M: Pick<TC.Monad<T, L>, "of" | "chain">): TC.Monad<T, L>;
 };
 
 export const createMonad: CreateMonad = <T>({
@@ -39,6 +40,7 @@ type CreateBifunctor = {
   <T, L extends 1>(M: Pick<TC.Bifunctor<T, L>, "bimap">): TC.Bifunctor<T, L>;
   <T, L extends 2>(M: Pick<TC.Bifunctor<T, L>, "bimap">): TC.Bifunctor<T, L>;
   <T, L extends 3>(M: Pick<TC.Bifunctor<T, L>, "bimap">): TC.Bifunctor<T, L>;
+  <T, L extends 4>(M: Pick<TC.Bifunctor<T, L>, "bimap">): TC.Bifunctor<T, L>;
 };
 
 export const createBifunctor: CreateBifunctor = <T>({
@@ -60,6 +62,7 @@ type CreatePipeableMonad = {
   <T, L extends 1>(M: TC.Monad<T>): TC.MonadP<T, L>;
   <T, L extends 2>(M: TC.Monad<T, L>): TC.MonadP<T, L>;
   <T, L extends 3>(M: TC.Monad<T, L>): TC.MonadP<T, L>;
+  <T, L extends 4>(M: TC.Monad<T, L>): TC.MonadP<T, L>;
 };
 
 export const createPipeableMonad: CreatePipeableMonad = <T>(
@@ -80,6 +83,7 @@ type CreatePipeableTraversable = {
   <T, L extends 1>(M: TC.Traversable<T, L>): TC.TraversableP<T, L>;
   <T, L extends 2>(M: TC.Traversable<T, L>): TC.TraversableP<T, L>;
   <T, L extends 3>(M: TC.Traversable<T, L>): TC.TraversableP<T, L>;
+  <T, L extends 4>(M: TC.Traversable<T, L>): TC.TraversableP<T, L>;
 };
 
 export const createPipeableTraversable: CreatePipeableTraversable = <T>(
@@ -104,6 +108,9 @@ type CreatePipeableIndexedTraversable = {
   <T, L extends 3, I>(
     M: TC.IndexedTraversable<T, L, I>,
   ): TC.IndexedTraversableP<T, L, I>;
+  <T, L extends 4, I>(
+    M: TC.IndexedTraversable<T, L, I>,
+  ): TC.IndexedTraversableP<T, L, I>;
 };
 
 export const createPipeableIndexedTraversable:
@@ -128,6 +135,9 @@ type CreatePipeableBifunctor = {
   <T, L extends 3>(
     M: TC.Bifunctor<T, L>,
   ): TC.BifunctorP<T, L>;
+  <T, L extends 4>(
+    M: TC.Bifunctor<T, L>,
+  ): TC.BifunctorP<T, L>;
 };
 
 export const createPipeableBifunctor: CreatePipeableBifunctor = <T>({

either.ts

@@ -94,6 +94,7 @@ export const stringifyJSON = <E>(
  **************************************************************************************************/
 
 export const isLeft = <L, R>(m: Either<L, R>): m is Left<L> => m.tag === "Left";
+
 export const isRight = <L, R>(m: Either<L, R>): m is Right<R> =>
   m.tag === "Right";
 

sequence.ts

@@ -50,6 +50,12 @@ type SequenceTuple<T, R extends NonEmptyArray<$<T, any[]>>, L extends LS = 1> =
     { [K in keyof R]: R[K] extends $<T, [infer R, infer E, infer A]> ? E : never }[number],
     { [K in keyof R]: R[K] extends $<T, [infer R, infer E, infer A]> ? A : never },
   ]>;
+  4: $<T, [
+    { [K in keyof R]: R[K] extends $<T, [infer S, infer R, infer E, infer A]> ? S : never }[number],
+    { [K in keyof R]: R[K] extends $<T, [infer S, infer R, infer E, infer A]> ? R : never }[number],
+    { [K in keyof R]: R[K] extends $<T, [infer S, infer R, infer E, infer A]> ? E : never }[number],
+    { [K in keyof R]: R[K] extends $<T, [infer S, infer R, infer E, infer A]> ? A : never },
+  ]>;
 }[L];
 
 // deno-fmt-ignore
@@ -94,6 +100,12 @@ type SequenceStruct<T, R extends Record<string, $<T, any[]>>, L extends LS = 1>
     { [K in keyof R]: R[K] extends $<T, [infer R, infer E, infer A]> ? E : never }[keyof R],
     { [K in keyof R]: R[K] extends $<T, [infer R, infer E, infer A]> ? A : never },
   ]>;
+  4: $<T, [
+    { [K in keyof R]: R[K] extends $<T, [infer S, infer R, infer E, infer A]> ? S : never }[keyof R],
+    { [K in keyof R]: R[K] extends $<T, [infer S, infer R, infer E, infer A]> ? R : never }[keyof R],
+    { [K in keyof R]: R[K] extends $<T, [infer S, infer R, infer E, infer A]> ? E : never }[keyof R],
+    { [K in keyof R]: R[K] extends $<T, [infer S, infer R, infer E, infer A]> ? A : never },
+  ]>;
 }[L];
 
 // deno-fmt-ignore