Hi all,
I've been trying to get a feel for the space of programming languages,
and in particular, different sorts of type systems. In hopes of
clarifying and correcting my thoughts, please bear with me while I
ramble for a while, and correct and direct me towards enlightening
resources.
Abstraction is good, boilerplate is bad, and we'd like to write
general code that works for different "sorts" of things. Parametric
polymorphism and interfaces are 2 common ways to do this, and fit
together well with current strong, static type systems.
Parametric polymorphism enables abstraction by allowing functions to
operate on a particular "containing" type, but arbitrary "contained"
types, exemplified by the many well-known list functions. Abstraction
is achieved because the desired functionality only depends on the
specific structure (interface?) of the "outer" type. This is
essentially exactly what generics in Java are.
Interfaces (I use the term in the Java sense, though I'm not fully
comfortable with the details) allow one to write code that works with
any type, as long as that type provides the functionality specified in
an interface. So, type classes in Haskell provide similar
functionality to interfaces in Java.
It seems like parametric polymorphism is a more restricted case of
type classes. Map could perhaps be something like:
map :: (Consable xs x, Consable ys y) => (x -> y) -> xs -> ys
class Consable xs x where
cons :: (x, xs) -> xs
decons :: xs -> (x, xs)
(I think functional dependencies could be used to link xs and x in the
type system?) The Functor class seems similar, but I'm not sure if I
see that it's exactly the same.
Clojure's "seq" abstraction (implemented for most (all?) of its
built-in collection types as well as Java Iterables, etc.) requires
"first", "rest", and "cons". Through this interface, Clojure
implements map, filter, reverse, etc. once, but they work for all its
collections.
Thanks for your patience!
-John
