[Haskell-beginners] Re: Boilerplate Code

[Kyle Murphy]

Actually looking at the original question I'm not sure my code does what was
intended. I was looking at does some type (a b) == (a c), which wasn't
exactly the question. Oh well, back to the drawing board.

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


On Tue, Aug 3, 2010 at 14:38, Kyle Murphy <orclev at gmail.com> wrote:

> 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/c98bc450/attachment.html