The advantage of functors shows up when you need to have multiple
implementations of a module for a type. For instance, suppose you
want to implement a set, and you write the functors (OCaml below):
...
Now, suppose you want two kinds of sets of string, one of which is
case-sensitive and one of which is not. You can easily do this with
functors like so
module SensitiveCase =
struct
type t = string
let eq s s' = (s = s')
end
module InsensitiveCase =
struct
type t = string
let eq s s' = (String.lowercase s) = (String.lowercase s')
end
module SensitiveSet = Set(SensitiveCase)
module InsensitiveSet = Set(InsensitiveCase)
Each of these Set types takes a string, but the membership test is
different. This is an annoying case in Haskell, because you can make a
String a member of the Eq typeclass in only one way.
Of course, you can always define
newtype CaseInsensitiveString = CaseInsensitive String
whereupon you can define an Eq instance that ignores case. Maybe this isn't
common Haskell style, but it does have many advantages. In particular, the
type-checker now checks that you don't pass a case sensitive string where an
insensitive one is expected, or vice versa, and this should help catch bugs.
I've begun to use this style more, particularly when using QuickCheck. There I
define a new type when I want a different distribution of test data from the
default. I've found it's error-prone to specify which distribution to use
explicitly; much better to let the type-checker figure it out.
John
