Add Profunctor about fp-ts HOT 2 CLOSED

import { HKT2, HKT2S } from './HKT'
import { StaticFunctor, FantasyFunctor } from './Functor'
import { identity } from './function'

export interface StaticProfunctor<F extends HKT2S> extends StaticFunctor<F> {
  promap<A, B, C, D>(ab: (a: A) => B, cd: (c: C) => D, fbc: HKT2<B, C>[F]): HKT2<A, D>[F]
}

export interface FantasyProfunctor<F extends HKT2S, B, C> extends FantasyFunctor<F, C> {
  promap<A, D>(ab: (a: A) => B, cd: (c: C) => D): HKT2<A, D>[F]
}

export function lmap<F extends HKT2S, A, B, C>(profunctor: StaticProfunctor<F>, f: (a: A) => B, fbc: HKT2<B, C>[F]): HKT2<A, C>[F] {
  return profunctor.promap<A, B, C, C>(f, identity, fbc)
}

// this is just the functor map
export function rmap<F extends HKT2S, A, B, C>(profunctor: StaticProfunctor<F>, f: (a: B) => C, fab: HKT2<A, B>[F]): HKT2<A, C>[F] {
  return profunctor.map(f, fab)
}

declare module './HKT' {
  interface HKT<A> {
    '->': Fun<any, A>
  }
  interface HKT2<A, B> {
    '->': Fun<A, B>
  }
}

export const URI = '->'

export type URI = typeof URI

export class Fun<B, A> implements FantasyProfunctor<URI, B, A> {
  readonly _B: B
  readonly _A: A
  readonly _URI: URI
  constructor(public readonly value: (b: B) => A) {}
  run(b: B): A {
    return this.value(b)
  }
  map<C>(f: (a: A) => C): Fun<B, C> {
    return this.promap<B, C>(identity, f)
  }
  promap<C, D>(cb: (c: C) => B, ad: (a: A) => D): Fun<C, D> {
    return new Fun<C, D>(c => ad(this.run(cb(c))))
  }
}