50 lines
No EOL
2.9 KiB
Text
50 lines
No EOL
2.9 KiB
Text
# Functors and Applicatives for Free[^falsehood]
|
|
|
|
It's usually possible to derive implementations of general structures from those of more specific ones, e.g. `Applicative` from `Monad` and `Functor` from `Applicative`. Here's how to do it and and why it's probably best avoided.
|
|
|
|
```ocaml
|
|
module type Functor = sig
|
|
type 'a t
|
|
val map : ('a -> 'b) -> 'a t -> 'b t
|
|
end
|
|
|
|
module type Applicative = sig
|
|
type 'a t
|
|
val pure : 'a -> 'a t
|
|
val apply : ('a -> 'b) t -> 'a t -> 'b t
|
|
end
|
|
|
|
module type Monad = sig
|
|
type 'a t
|
|
val return : 'a -> 'a t
|
|
val bind : ('a -> 'b t) -> 'a t -> 'b t
|
|
end
|
|
|
|
module ApplicativeOfMonad (M : Monad) :
|
|
Applicative with type 'a t = 'a M.t = struct
|
|
type 'a t = 'a M.t
|
|
let pure = M.return
|
|
let apply f x = M.(bind (fun y -> bind (fun g -> return (g y)) f) x)
|
|
end
|
|
|
|
module FunctorOfApplicative (A : Applicative) :
|
|
Functor with type 'a t = 'a A.t = struct
|
|
type 'a t = 'a A.t
|
|
let map f x = A.(apply (pure f) x)
|
|
end
|
|
|
|
module FunctorOfMonad (M : Monad) :
|
|
Functor with type 'a t = 'a M.t = struct
|
|
include FunctorOfApplicative(ApplicativeOfMonad(M))
|
|
end
|
|
```
|
|
|
|
It turns out that there are multiple ways to implement the derivation functors--- also multiple ways to implement a particular monad ---and they don't all behave the same, which means it's hard to predict whether the more-general, derived implementations are the "natural" ones that you expected to get without _ad hoc_ testing, which obviously rather defeats the point of "free". On the other hand, the derivations here can be performed pretty mechanically, with little insight, by following the types in much the same way one might mechanically prove an easy proposition.
|
|
|
|
***
|
|
|
|
The modules above that seem to have parameters, do; these modules are called "functors". A functor in OCaml parlance is distinct from anything called a "functor" elsewhere, being essentially a function from modules to modules. For practical reasons, modules and value-level programs are stratified from one another in OCaml, so a functor does not literally have a function type, but the mental model is still basically correct.
|
|
|
|
A subtlety of the OCaml module system is that if a module is defined with a particular `module type` a.k.a. signature attached, e.g. `module M : S = struct...`, all the types that are abstract in the signature `S` will _also_ be abstract in the module itself. This means that the compiler can't see or be convinced that for some `F (M)` with `type t = M.t` in `F`, `M.t` and `(F (M)).t` are equal. This is because both types are abstract, meaning the underlying type is not available. To fix this, we can explicitly expose the equality by using the `with type` construct. In the above, `Functor with type 'a t = 'a M.t`--- for example ---exposes the equality of the two types, so that functions defined as expecting arguments of `'a t` can accepts `'a M.t`, and _vice versa_.
|
|
|
|
[^falsehood]: Unsurprisingly, that's a lie. You have to buy a `Monad` first. |