[Haskell-beginners] Boilerplate Code

[Brent Yorgey]

On Tue, Aug 03, 2010 at 04:19:58PM +0300, Alex Rozenshteyn wrote:
> I have never used Data.Typeable, but maybe it could be made relevant here?

Not really.  Data.Typeable lets you pass (representations of) types
around at runtime, and thus do things like type-safe casts.  So it's
useful for things like serialization, extracting things out of
existential wrappers, and so on.  It isn't really relevant in this
situation, as Matt already has all the type information he could want.

-Brent

> 
> On Tue, Aug 3, 2010 at 4:18 PM, Brent Yorgey <byorgey at seas.upenn.edu> wrote:
> 
> > On Tue, Aug 03, 2010 at 09:51:45PM +1000, Matt Andrew wrote:
> > > Hi all,
> > >
> > > I am in the process of writing a Scheme interpreter/compiler in Haskell
> > as my first serious project after learning the basics of Haskell. The goal
> > is to really get a feel for Haskell. I am trying to accomplish this as much
> > as I can on my own, but am referring to Jonathan Tang's 'Write Yourself a
> > Scheme in 48 hours' whenever I get really stuck.
> > >
> > > I have a question regarding a pattern that I have found within my code
> > for which I cannot seem to find an abstraction.
> > >
> > > I am implementing some of the primitive Scheme type-checker functions
> > with the following code:
> > >
> > > numberP :: SchemeVal -> SchemeVal
> > > numberP (Number _) = Bool True
> > > numberP _          = Bool False
> > >
> > > boolP :: SchemeVal -> SchemeVal
> > > boolP (Bool _) = Bool True
> > > boolP _        = Bool False
> > >
> > > symbolP :: SchemeVal -> SchemeVal
> > > symbolP (Atom _) = Bool True
> > > symbolP _        = Bool False
> > >
> > > This is a pattern that I could easily provide an abstraction for with a
> > Lisp macro, but I'm having trouble discovering if/how it's possible to do so
> > elegantly in Haskell. The closest (but obviously incorrect) code to what I'm
> > trying to accomplish would be:
> >
> > It isn't really possible to abstract this any further in Haskell.
> > Constructors are rather magical functions, but they are still
> > functions, and like other functions cannot be compared for equality
> > directly.  Pattern-matching them is the only sort of equality
> > comparison you get.
> >
> > With that said, your intuition to use Lisp macros is a good one.
> > Haskell has a similar metaprogramming facility called Template
> > Haskell, which could easily be used to automatically generate these
> > sorts of functions.  Of course, it's a little more complicated than
> > Lisp macros since Haskell syntax is so much more complex than Lisp's
> > -- but given that, on the whole it's not so bad.  I wouldn't use TH to
> > generate just the three functions you showed -- but I would certainly
> > consider it for ten.
> >
> > -Brent
> > _______________________________________________
> > Beginners mailing list
> > Beginners at haskell.org
> > http://www.haskell.org/mailman/listinfo/beginners
> >
> 
> 
> 
> -- 
> ()  ascii ribbon campaign - against html e-mail
> /\  www.asciiribbon.org   - against proprietary attachments
> 
>           Alex R

> _______________________________________________
> Beginners mailing list
> Beginners at haskell.org
> http://www.haskell.org/mailman/listinfo/beginners