[Caml-list] Re: What is an applicative functor?

[Dawid Toton <d0@wp.pl>]

Thanks for the very quick answer.
Does it mean that I can render a module to be not applicative by adding 
a record type to it? This would break some existing code which relies on 
equality of some other types?

On 2011-04-07 23:49, Gerd Stolpmann wrote:
> Am Donnerstag, den 07.04.2011, 23:12 +0200 schrieb Dawid Toton:
>> What does it mean that a functor is applicative?
> Roughly: If you apply a functor twice with the same input modules, the
> opaque types in the output remain compatible. For instance:
>
> module S1 = Set.Make(String)
> module S2 = Set.Make(String)
>
> Now, S1.t and S2.t are type-compatible, although this type is opaque.
> (E.g. you can do S1.empty = S2.empty.)
But sometimes it doesn't work this way:

module Make2(X : sig end) = struct type s end
module M1 = Make2(struct end)
module M2 = Make2(struct end)
let g (a : M1.s) (b : M2.s) = a = b;;

Error: This expression has type M2.s but an expression was expected of 
type M1.s

> Compare this with:
>
> module Make(X : sig end) = struct type t = Variant end
> module M1 = Make(struct end)
> module M2 = Make(struct end)
>
> Now, M1.t and M2.t are incompatible - for nominal types like variants
> the functors aren't applicative, and each instance is a thing of its
> own:
>
> # M1.Variant = M2.Variant;;
> Error: This expression has type M2.t but an expression was expected of
> type M1.t
>
Honestly, I don't get it:

module Make(X : sig end) = struct type t = Variant end
module Empty = struct end
module M1 = Make(Empty)
module M2 = Make(Empty)
     ;;
M1.Variant = M2.Variant
     ;;

Toplevel responds with:

module Make : functor (X : sig  end) -> sig type t = Variant end
module Empty : sig  end
module M1 : sig type t = Make(Empty).t = Variant end
module M2 : sig type t = Make(Empty).t = Variant end
#   - : bool = true

So I get applicative functor with a nominal type?

>> Is there any analogy between applicative functors in OCaml and the
>> Applicative type class of Haskell?
I have some idea of it: we consider two types that play nicely together. 
I pass them through a functor. If the functor is applicative, the two 
resulting types also play nicely the same way as the original ones.
Dawid