I was going to argue this point but then it occurred to me that writing a whole bunch of functions like:<br><br>isAFoo :: FooBarBaz -&gt; FooBarBaz -&gt; Bool<br>isAFoo x = typeChecker (Foo undefined) x<br><br>isn&#39;t really in any way better than:<br>
<br>isAFoo :: FooBarBaz -&gt; FooBarBaz -&gt; Bool<br>
isAFoo (Foo _) = True<br>isAFoo _ = False<br><br>Although it did give me a chance to play around with Data and Typeable a bit.<br><br clear="all">-R. Kyle Murphy<br>--<br>Curiosity was framed, Ignorance killed the cat.<br>

<br><br><div class="gmail_quote">On Tue, Aug 3, 2010 at 15:25, Brent Yorgey <span dir="ltr">&lt;<a href="mailto:byorgey@seas.upenn.edu">byorgey@seas.upenn.edu</a>&gt;</span> wrote:<br><blockquote class="gmail_quote" style="margin: 0pt 0pt 0pt 0.8ex; border-left: 1px solid rgb(204, 204, 204); padding-left: 1ex;">
<div class="im">On Tue, Aug 03, 2010 at 04:19:58PM +0300, Alex Rozenshteyn wrote:<br>
&gt; I have never used Data.Typeable, but maybe it could be made relevant here?<br>
<br>
</div>Not really.  Data.Typeable lets you pass (representations of) types<br>
around at runtime, and thus do things like type-safe casts.  So it&#39;s<br>
useful for things like serialization, extracting things out of<br>
existential wrappers, and so on.  It isn&#39;t really relevant in this<br>
situation, as Matt already has all the type information he could want.<br>
<font color="#888888"><br>
-Brent<br>
</font><div><div></div><div class="h5"><br>
&gt;<br>
&gt; On Tue, Aug 3, 2010 at 4:18 PM, Brent Yorgey &lt;<a href="mailto:byorgey@seas.upenn.edu">byorgey@seas.upenn.edu</a>&gt; wrote:<br>
&gt;<br>
&gt; &gt; On Tue, Aug 03, 2010 at 09:51:45PM +1000, Matt Andrew wrote:<br>
&gt; &gt; &gt; Hi all,<br>
&gt; &gt; &gt;<br>
&gt; &gt; &gt; I am in the process of writing a Scheme interpreter/compiler in Haskell<br>
&gt; &gt; as my first serious project after learning the basics of Haskell. The goal<br>
&gt; &gt; is to really get a feel for Haskell. I am trying to accomplish this as much<br>
&gt; &gt; as I can on my own, but am referring to Jonathan Tang&#39;s &#39;Write Yourself a<br>
&gt; &gt; Scheme in 48 hours&#39; whenever I get really stuck.<br>
&gt; &gt; &gt;<br>
&gt; &gt; &gt; I have a question regarding a pattern that I have found within my code<br>
&gt; &gt; for which I cannot seem to find an abstraction.<br>
&gt; &gt; &gt;<br>
&gt; &gt; &gt; I am implementing some of the primitive Scheme type-checker functions<br>
&gt; &gt; with the following code:<br>
&gt; &gt; &gt;<br>
&gt; &gt; &gt; numberP :: SchemeVal -&gt; SchemeVal<br>
&gt; &gt; &gt; numberP (Number _) = Bool True<br>
&gt; &gt; &gt; numberP _          = Bool False<br>
&gt; &gt; &gt;<br>
&gt; &gt; &gt; boolP :: SchemeVal -&gt; SchemeVal<br>
&gt; &gt; &gt; boolP (Bool _) = Bool True<br>
&gt; &gt; &gt; boolP _        = Bool False<br>
&gt; &gt; &gt;<br>
&gt; &gt; &gt; symbolP :: SchemeVal -&gt; SchemeVal<br>
&gt; &gt; &gt; symbolP (Atom _) = Bool True<br>
&gt; &gt; &gt; symbolP _        = Bool False<br>
&gt; &gt; &gt;<br>
&gt; &gt; &gt; This is a pattern that I could easily provide an abstraction for with a<br>
&gt; &gt; Lisp macro, but I&#39;m having trouble discovering if/how it&#39;s possible to do so<br>
&gt; &gt; elegantly in Haskell. The closest (but obviously incorrect) code to what I&#39;m<br>
&gt; &gt; trying to accomplish would be:<br>
&gt; &gt;<br>
&gt; &gt; It isn&#39;t really possible to abstract this any further in Haskell.<br>
&gt; &gt; Constructors are rather magical functions, but they are still<br>
&gt; &gt; functions, and like other functions cannot be compared for equality<br>
&gt; &gt; directly.  Pattern-matching them is the only sort of equality<br>
&gt; &gt; comparison you get.<br>
&gt; &gt;<br>
&gt; &gt; With that said, your intuition to use Lisp macros is a good one.<br>
&gt; &gt; Haskell has a similar metaprogramming facility called Template<br>
&gt; &gt; Haskell, which could easily be used to automatically generate these<br>
&gt; &gt; sorts of functions.  Of course, it&#39;s a little more complicated than<br>
&gt; &gt; Lisp macros since Haskell syntax is so much more complex than Lisp&#39;s<br>
&gt; &gt; -- but given that, on the whole it&#39;s not so bad.  I wouldn&#39;t use TH to<br>
&gt; &gt; generate just the three functions you showed -- but I would certainly<br>
&gt; &gt; consider it for ten.<br>
&gt; &gt;<br>
&gt; &gt; -Brent<br>
&gt; &gt; _______________________________________________<br>
&gt; &gt; Beginners mailing list<br>
&gt; &gt; <a href="mailto:Beginners@haskell.org">Beginners@haskell.org</a><br>
&gt; &gt; <a href="http://www.haskell.org/mailman/listinfo/beginners" target="_blank">http://www.haskell.org/mailman/listinfo/beginners</a><br>
&gt; &gt;<br>
&gt;<br>
&gt;<br>
&gt;<br>
&gt; --<br>
&gt; ()  ascii ribbon campaign - against html e-mail<br>
&gt; /\  <a href="http://www.asciiribbon.org" target="_blank">www.asciiribbon.org</a>   - against proprietary attachments<br>
&gt;<br>
&gt;           Alex R<br>
<br>
&gt; _______________________________________________<br>
&gt; Beginners mailing list<br>
&gt; <a href="mailto:Beginners@haskell.org">Beginners@haskell.org</a><br>
&gt; <a href="http://www.haskell.org/mailman/listinfo/beginners" target="_blank">http://www.haskell.org/mailman/listinfo/beginners</a><br>
<br>
_______________________________________________<br>
Beginners mailing list<br>
<a href="mailto:Beginners@haskell.org">Beginners@haskell.org</a><br>
<a href="http://www.haskell.org/mailman/listinfo/beginners" target="_blank">http://www.haskell.org/mailman/listinfo/beginners</a><br>
</div></div></blockquote></div><br>