[Haskell-beginners] Re: Boilerplate Code

[Kyle Murphy]

Less of a dirty dirty hack (requires that SchemeVal be an instance of
Typeable):

import Data.Typeable
import Data.Maybe

typeChecker :: (Typeable a, Typeable b) => a -> b -> Bool
typeChecker a b = f a == f b
        where
                f :: (Typeable a) => a -> Maybe TypeRep
                f = listToMaybe . typeRepArgs . typeOf


-R. Kyle Murphy
--
Curiosity was framed, Ignorance killed the cat.


On Tue, Aug 3, 2010 at 13:51, Alex Rozenshteyn <rpglover64 at gmail.com> wrote:

> That is a dirty, dirty hack.
>
>
> On Tue, Aug 3, 2010 at 8:45 PM, Christian Maeder <Christian.Maeder at dfki.de
> > wrote:
>
>> Matt Andrew schrieb:
>> > 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:
>> >
>> > typeChecker :: SchemeVal -> SchemeVal -> SchemeVal
>> > typeChecker (cons _) (cons2 _) = Bool $ cons == cons2
>> >
>> > I understand this code drastically misunderstands how pattern matching
>> works, but (hopefully) it expresses what I'm trying to accomplish. Anyone
>> have any suggestions?
>>
>> typeChecker s1 s2 = let f = takeWhile isAlphaNum . show in
>>   Bool $ f s1 == f s2
>>
>> hoping that my "f" just extracts the constructor as string.
>>
>> C.
>>
>> > I do realise that such an abstraction is barely worth it for the amount
>> of code it will save, but this exercise is about learning the ins and outs
>> of Haskell.
>> >
>> > Appreciate you taking the time to read this,
>> >
>> > Matt Andrew
>> _______________________________________________
>> 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
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://www.haskell.org/pipermail/beginners/attachments/20100803/d867932a/attachment-0001.html