I thought I was getting pretty good at Haskell, until I ran into this
problem. It's basically a way of maintaining encapsulation of data
and functions while being able to have a container, such as a list,
hold these items without worrying about their differences. In OO this
would be pretty easy. You'd have an interface of some sort and the
container would hold objects of the interface type. Then you could
write the individual classes that implement that interface in their
own files and the main program wouldn't have to know about the
details.
I'm trying to write a silly little life simulator. We've got a world
where many different entities exist. These entities are all
different, but for a start we'll use fish and shark. The fish like to
swim around in the sea, and will manage to eat some amount of the
overall food supply. The amount they consume from year to year varies
and they have to consume a minimum amount every year or they die.
When they've eaten enough food and have build up a surplus, they'll
reproduce, but if they're starving they can't. Sharks are similar,
except their food supply is the fish. The two are very similar, but
do slightly different things. And every fish or shark has to keep
track of its own amount of consumed food.
If I wanted to define these separately, the best I've come up with is
to create a data type that has all the information necessary, then
somewhere maintain a master algebraic data type which wraps each of
these in a type constructor. I can then write another head for a
general function that will match that type constructor and describe
the behavior.
I tried something clever with closures, but it turned out to be too
clever for me and I couldn't avoid infinite types.
Thoughts?
Drew Haven
drew.haven(a)gmail.com
