export interface Logger<M, A> {
  (a: A): HKT<M, void>
}

export interface Logger1<M extends URIS, A> {
  (a: A): Kind<M, void>
}

export interface Logger2<M extends URIS2, E, A> {
  (a: A): Kind2<M, E, void>
}

export interface LoggerM<M> {
  readonly contramap: <A, B>(fa: Logger<M, A>, f: (b: B) => A) => Logger<M, B>
  readonly filter: <A>(logger: Logger<M, A>, predicate: Predicate<A>) => Logger<M, A>
  readonly getMonoid: <A = never>() => Monoid<Logger<M, A>>
}

export interface LoggerM1<M extends URIS> {
  readonly contramap: <A, B>(fa: Logger1<M, A>, f: (b: B) => A) => Logger1<M, B>
  readonly filter: <A>(logger: Logger1<M, A>, predicate: Predicate<A>) => Logger1<M, A>
  readonly getMonoid: <A = never>() => Monoid<Logger1<M, A>>
}

export interface LoggerM2<M extends URIS2> {
  readonly contramap: <E, A, B>(fa: Logger2<M, E, A>, f: (b: B) => A) => Logger2<M, E, B>
  readonly filter: <E, A>(logger: Logger2<M, E, A>, predicate: Predicate<A>) => Logger2<M, E, A>
  readonly getMonoid: <E, A>() => Monoid<Logger2<M, E, A>>
}

export function getLoggerM<M extends URIS2>(M: Applicative2<M>): LoggerM2<M>
export function getLoggerM<M extends URIS>(M: Applicative1<M>): LoggerM1<M>
export function getLoggerM<M>(M: Applicative<M>): LoggerM<M> { ... }