Higher kinded types with Flow

Flow doesn’t support higher kinded types: https://github.com/facebook/flow/issues/30.

What does it means in practice?

Here’s a functor in PureScript

class Functor f where
  map :: forall a b. (a -> b) -> f a -> f b

Let’s try to translate the concept to Flow

interface Functor<F> {
  map<A, B>(f: (a: A) => B, fa: F<A>): F<B>
}

Unfortunately Flow raises the following error

map<A, B>(f: (a: A) => B, fa: F<A>): F<B>
                              ^^^^ Incorrect number of type parameters (expected 0)

There’s no way to define F as a unary type constructor, see Kind (type theory)

interface Functor<F<*>> {
  map<A, B>(f: (a: A) => B, fa: F<A>): F<B>
}
interface Functor<F<*>> {
                   ^ Unexpected token <

Here I present a way of faking higher kinded types based on the paper Lightweight higher-kinded polymorphism and inspired by elm-brands.

The recipe

First let’s define an helper class HKT that represents a unary type constructor

class HKT<F, A> {}

Note that F and A are phantom types.

Now I can define the functor type class without Flow complaining

interface Functor<F> {
  map<A, B>(f: (a: A) => B, fa: HKT<F, A>): HKT<F, B>
}

As an example, let’s implement the Maybe functor, we need

• a nominal type for F (let’s call it IsMaybe)
• a way to put a value of type ?A into Maybe<A> (let’s call it inj)
• a way to get back the value from Maybe<A> (let’s call it prj)

class IsMaybe {}
type Maybe<A> = HKT<IsMaybe, A>;
function inj<A>(a: ?A): Maybe<A> {
  return ((a: any): Maybe<A>)
}
function prj<A>(fa: Maybe<A>): ?A {
  return ((fa: any): ?A)
}

Finally we can implement the functor instance

const Nothing: Maybe<any> = inj(null)
function map<A, B>(f: (a: A) => B, fa: Maybe<A>): Maybe<B> {
  const a = prj(fa)
  return a == null ? Nothing : inj(f(a))
}
map(n => n + 1, Nothing) // => null
map(n => n + 1, inj(3))  // => 4

Using this trick I wrote an implementation of common algebraic types: flow-static-land