export interface Filterable<F extends TypeLambda> extends TypeClass<F> {
  readonly partitionMap: {
    <A, B, C>(
      f: (a: A) => Either.Either<C, B>
    ): <R, O, E>(self: Kind<F, R, O, E, A>) => [Kind<F, R, O, E, B>, Kind<F, R, O, E, C>]
    <R, O, E, A, B, C>(
      self: Kind<F, R, O, E, A>,
      f: (a: A) => Either.Either<C, B>
    ): [Kind<F, R, O, E, B>, Kind<F, R, O, E, C>]
  }

  readonly filterMap: {
    <A, B>(f: (a: A) => Option.Option<B>): <R, O, E>(self: Kind<F, R, O, E, A>) => Kind<F, R, O, E, B>
    <R, O, E, A, B>(self: Kind<F, R, O, E, A>, f: (a: A) => Option.Option<B>): Kind<F, R, O, E, B>
  }
}

export declare const compact: <F extends TypeLambda>(
  F: Filterable<F>
) => <R, O, E, A>(self: Kind<F, R, O, E, Option.Option<A>>) => Kind<F, R, O, E, A>

export declare const filter: <F extends TypeLambda>(
  F: Filterable<F>
) => {
  <C extends A, B extends A, A = C>(
    refinement: (a: A) => a is B
  ): <R, O, E>(self: Kind<F, R, O, E, C>) => Kind<F, R, O, E, B>
  <B extends A, A = B>(predicate: (a: A) => boolean): <R, O, E>(self: Kind<F, R, O, E, B>) => Kind<F, R, O, E, B>
  <R, O, E, C extends A, B extends A, A = C>(
    self: Kind<F, R, O, E, C>,
    refinement: (a: A) => a is B
  ): Kind<F, R, O, E, B>
  <R, O, E, B extends A, A = B>(self: Kind<F, R, O, E, B>, predicate: (a: A) => boolean): Kind<F, R, O, E, B>
}

export declare const filterMapComposition: <F extends TypeLambda, G extends TypeLambda>(
  F: Covariant<F>,
  G: Filterable<G>
) => <FR, FO, FE, GR, GO, GE, A, B>(
  self: Kind<F, FR, FO, FE, Kind<G, GR, GO, GE, A>>,
  f: (a: A) => Option.Option<B>
) => Kind<F, FR, FO, FE, Kind<G, GR, GO, GE, B>>

export declare const partition: <F extends TypeLambda>(
  F: Filterable<F>
) => {
  <C extends A, B extends A, A = C>(
    refinement: (a: A) => a is B
  ): <R, O, E>(self: Kind<F, R, O, E, C>) => [Kind<F, R, O, E, C>, Kind<F, R, O, E, B>]
  <B extends A, A = B>(
    predicate: (a: A) => boolean
  ): <R, O, E>(self: Kind<F, R, O, E, B>) => [Kind<F, R, O, E, B>, Kind<F, R, O, E, B>]
  <R, O, E, C extends A, B extends A, A = C>(
    self: Kind<F, R, O, E, C>,
    refinement: (a: A) => a is B
  ): [Kind<F, R, O, E, C>, Kind<F, R, O, E, B>]
  <R, O, E, B extends A, A = B>(
    self: Kind<F, R, O, E, B>,
    predicate: (a: A) => boolean
  ): [Kind<F, R, O, E, B>, Kind<F, R, O, E, B>]
}

export declare const partitionMapComposition: <F extends TypeLambda, G extends TypeLambda>(
  F: Covariant<F>,
  G: Filterable<G>
) => <FR, FO, FE, GR, GO, GE, A, B, C>(
  self: Kind<F, FR, FO, FE, Kind<G, GR, GO, GE, A>>,
  f: (a: A) => Either.Either<C, B>
) => [Kind<F, FR, FO, FE, Kind<G, GR, GO, GE, B>>, Kind<F, FR, FO, FE, Kind<G, GR, GO, GE, C>>]

export declare const separate: <F extends TypeLambda>(
  F: Filterable<F>
) => <R, O, E, A, B>(self: Kind<F, R, O, E, Either.Either<B, A>>) => [Kind<F, R, O, E, A>, Kind<F, R, O, E, B>]