My wife has been put in charge of scheduling lectors and ministers at our
church, so of course she needs a Haskell program to do the schedules for
her! While I've been working on it, I wrote something that I thought was a
pretty cool trick.
Each Mass requires a variety of different type and number of participants,
so when defining the "Mass" data structure I put a function in which selects
participants for that type of Mass from a given list:
data MassTime = MassTime {
...
selectParticipants :: (Participants -> Maybe Participants), -- Picks
participants for this mass
... }
Each mass has particular requirements. Notice the 'selectParticipants'
function does not take a mass definition as an argument.
Here's the trick I thought was neat. When creating the MassTime value, I
capture it in a closure and bind it to the selector function, as below:
makeMass :: Day -> MassTime
makeMass day =
mass
where
-- Use trick here to capture mass defined and pass to our selection
function.
mass = MassTime ... (weekendMassSelector mass) ...
'weekendMassSelector' is defined elsewhere, and basically knows how to count
up the right number of participants based on the mass definition given. It's
signature is:
weekendMassSelector :: MassTime -> Participants -> Maybe Participants
So weekendMassSelector gets the MassTime value it needs, before it is even
constructed. Partial evaluation then gives a function with the (Participants
-> Maybe Participants) signature required by the data constructor. I love
Haskell - this just seems too cool.
Since I really doubt this is something new - is this a technique that's
commonly used? Does it have a name? It looks a lot like passing a "this"
argument to a function - have I re-invented OOP encapsulation? :)
Justin
_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe
