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;
  };
}