Foldable

declare function combineMap<F extends TypeLambda>(F: Foldable<F>): <M>(M: Monoid<M>) => {
  <A>(f: (a: A) => M): <R, O, E>(self: Kind<F, R, O, E, A>) => M;
  <R, O, E, A>(self: Kind<F, R, O, E, A>, f: (a: A) => M): M;
}

declare function coproductMapKind<F extends TypeLambda>(F: Foldable<F>): <G extends TypeLambda>(G: Coproduct<G>) => {
  <A, R, O, E, B>(f: (a: A) => Kind<G, R, O, E, B>): <FR, FO, FE>(self: Kind<F, FR, FO, FE, A>) => Kind<G, R, O, E, B>;
  <FR, FO, FE, A, R, O, E, B>(self: Kind<F, FR, FO, FE, A>, f: (a: A) => Kind<G, R, O, E, B>): Kind<G, R, O, E, B>;
}

declare function reduceComposition<F extends TypeLambda, G extends TypeLambda>(F: Foldable<F>, G: Foldable<G>): <FR, FO, FE, GR, GO, GE, A, B>(self: Kind<F, FR, FO, FE, Kind<G, GR, GO, GE, A>>, b: B, f: (b: B, a: A) => B) => B

declare function reduceKind<F extends TypeLambda>(F: Foldable<F>): <G extends TypeLambda>(G: Monad<G>) => {
  <B, A, R, O, E>(b: B, f: (b: B, a: A) => Kind<G, R, O, E, B>): <FR, FO, FE>(self: Kind<F, FR, FO, FE, A>) => Kind<G, R, O, E, B>;
  <FR, FO, FE, A, B, R, O, E>(self: Kind<F, FR, FO, FE, A>, b: B, f: (b: B, a: A) => Kind<G, R, O, E, B>): Kind<G, R, O, E, B>;
}

declare function toArray<F extends TypeLambda>(F: Foldable<F>): <R, O, E, A>(self: Kind<F, R, O, E, A>) => Array<A>

declare function toArrayMap<F extends TypeLambda>(F: Foldable<F>): {
  <A, B>(f: (a: A) => B): <R, O, E>(self: Kind<F, R, O, E, A>) => Array<B>;
  <R, O, E, A, B>(self: Kind<F, R, O, E, A>, f: (a: A) => B): Array<B>;
}

interface Foldable<F extends TypeLambda> extends TypeClass<F> {
  readonly reduce: {
    <A, B>(b: B, f: (b: B, a: A) => B): <R, O, E>(self: Kind<F, R, O, E, A>) => B;
    <R, O, E, A, B>(self: Kind<F, R, O, E, A>, b: B, f: (b: B, a: A) => B): B;
  };
}