Send Beginners mailing list submissions to beginners@haskell.org To subscribe or unsubscribe via the World Wide Web, visit http://www.haskell.org/mailman/listinfo/beginners or, via email, send a message with subject or body 'help' to [EMAIL PROTECTED]
You can reach the person managing the list at [EMAIL PROTECTED] When replying, please edit your Subject line so it is more specific than "Re: Contents of Beginners digest..." Today's Topics: 1. help ([EMAIL PROTECTED]) 2. Re: Type polymorphism with size (Brent Yorgey) 3. Re: Type polymorphism with size (David Frey) ---------------------------------------------------------------------- Message: 1 Date: Tue, 18 Nov 2008 16:20:47 -0600 From: [EMAIL PROTECTED] Subject: [Haskell-beginners] help To: beginners@haskell.org Message-ID: <[EMAIL PROTECTED]> Content-Type: text/plain; charset="ISO-8859-1" On Tue, 18 Nov 2008 17:12:57 -0500 (EST), [EMAIL PROTECTED] said: > Send Beginners mailing list submissions to > beginners@haskell.org > > To subscribe or unsubscribe via the World Wide Web, visit > http://www.haskell.org/mailman/listinfo/beginners > or, via email, send a message with subject or body 'help' to > [EMAIL PROTECTED] > > You can reach the person managing the list at > [EMAIL PROTECTED] > > When replying, please edit your Subject line so it is more specific > than "Re: Contents of Beginners digest..." > > > Today's Topics: > > 1. Re: Profiling haskell code (Brent Yorgey) > 2. Parsing arithmentic expressions (Glurk) > 3. Re: Parsing arithmentic expressions (Bernie Pope) > 4. RE: Profiling haskell code (Sayali Kulkarni) > 5. Re: Profiling haskell code (Brent Yorgey) > 6. Type polymorphism with size (Michael Snoyman) > 7. Re: Type polymorphism with size (Brent Yorgey) > 8. Re: Type polymorphism with size (Michael Snoyman) > > > ---------------------------------------------------------------------- > > Message: 1 > Date: Fri, 14 Nov 2008 15:53:34 -0500 > From: Brent Yorgey <[EMAIL PROTECTED]> > Subject: Re: [Haskell-beginners] Profiling haskell code > To: beginners@haskell.org > Message-ID: <[EMAIL PROTECTED]> > Content-Type: text/plain; charset=us-ascii > > > > > quicksort [ ] = [ ] > > > > quicksort (x : xs) = quicksort larger ++ [x ] ++ quicksort smaller > > > > > > where > > > > > > smaller = [a | a <- xs, a <= x ] > > > > > > larger = [b | b <- xs, b > x ] > > > > > > > > > > > > When I compile the code with the following command : > > > > > > > > $ ghc --make Project.hs -prof -auto-all > > > > Then I tested it with the following command : > > > > $ Project +RTS -p > > > > It generates the .hi and the .o file but I cannot get the .prof file. > > > > Please let me know if any of the steps is missing or where could I check > > my profiling info. > > > > Hi Sayali, > > Is the code shown above *everything* in your Project.hs file? You > will also need a main function for it to actually do anything. If > there is more to your Project.hs file that you have not shown, could > you send the complete version? > > Do you get any errors? Does Project produce the output that you expect? > > -Brent > > > ------------------------------ > > Message: 2 > Date: Sun, 16 Nov 2008 00:15:29 +0000 (UTC) > From: Glurk <[EMAIL PROTECTED]> > Subject: [Haskell-beginners] Parsing arithmentic expressions > To: beginners@haskell.org > Message-ID: <[EMAIL PROTECTED]> > Content-Type: text/plain; charset=us-ascii > > Hi, > > I'm just trying to learn how to use Parsec and am experimenting with > parsing > arithmetic expressions. > > This article gives a good example -> > http://www.haskell.org/haskellwiki/Parsing_expressions_and_statements > > However, like most other examples I could find, the grammar for the > expression > doesn't take operator precedence into account, and allows for expressions > of > any size by defining expr recursively, eg :- > > expr ::= var | const | ( expr ) | unop expr | expr duop expr > > So, you can keep extending the expression by adding another operator and > expression. > > The data to hold the expression is then very easily derived :- > > data Expr = Var String | Con Bool | Uno Unop Expr | Duo Duop Expr Expr > > The grammar I want to parse is slightly different in that it allows for > operator precendence. Part of the grammar is something like :- > > expression = SimpleExpression {relation SimpleExpression}. > SimpleExpression = ["+"|"-"] term {AddOperator term}. > > So, instead of recursively defining expression, it is made up of > multiples > occurrences of SimpleExpression joined together with Relation operators. > > Where I am confused is how I should best represent this stucture in my > data. > Should I have something like :- > > data Expr = Expr SimpleExpr [(RelOp, SimpleExpression)] > > ie, an initial SimpleExpr, followed by a list of operator and > SimpleExpression > pairs. > > I haven't seen any example similar to this, so I was wondering if I'm > going > down the wrong track ? > > Perhaps another alternative is to modify the grammar somehow ? > > I guess, the question is, in general how do you handle such repeated > elements > as definied in an EBNF grammar, in structuring your data ? > > Any advice appreciated ! > > Thanks :) > > > > ------------------------------ > > Message: 3 > Date: Mon, 17 Nov 2008 16:35:02 +1100 > From: Bernie Pope <[EMAIL PROTECTED]> > Subject: Re: [Haskell-beginners] Parsing arithmentic expressions > To: Glurk <[EMAIL PROTECTED]> > Cc: beginners@haskell.org > Message-ID: <[EMAIL PROTECTED]> > Content-Type: text/plain; charset=US-ASCII; format=flowed; delsp=yes > > Hi, > > Have you seen the buildExpressionParser combinator in Parsec? > > > http://legacy.cs.uu.nl/daan/download/parsec/parsec.html#buildExpressionParser > > It allows you to specify precedence and associativity for operator > parsers declaratively, and it generally saves you from lots of > refactoring in the grammar. > > You could probably stick with the straightforward data representation > of expressions. > > Cheers, > Bernie. > > On 16/11/2008, at 11:15 AM, Glurk wrote: > > > Hi, > > > > I'm just trying to learn how to use Parsec and am experimenting with > > parsing > > arithmetic expressions. > > > > This article gives a good example -> > > http://www.haskell.org/haskellwiki/Parsing_expressions_and_statements > > > > However, like most other examples I could find, the grammar for the > > expression > > doesn't take operator precedence into account, and allows for > > expressions of > > any size by defining expr recursively, eg :- > > > > expr ::= var | const | ( expr ) | unop expr | expr duop expr > > > > So, you can keep extending the expression by adding another operator > > and > > expression. > > > > The data to hold the expression is then very easily derived :- > > > > data Expr = Var String | Con Bool | Uno Unop Expr | Duo Duop Expr Expr > > > > The grammar I want to parse is slightly different in that it allows > > for > > operator precendence. Part of the grammar is something like :- > > > > expression = SimpleExpression {relation SimpleExpression}. > > SimpleExpression = ["+"|"-"] term {AddOperator term}. > > > > So, instead of recursively defining expression, it is made up of > > multiples > > occurrences of SimpleExpression joined together with Relation > > operators. > > > > Where I am confused is how I should best represent this stucture in > > my data. > > Should I have something like :- > > > > data Expr = Expr SimpleExpr [(RelOp, SimpleExpression)] > > > > ie, an initial SimpleExpr, followed by a list of operator and > > SimpleExpression > > pairs. > > > > I haven't seen any example similar to this, so I was wondering if > > I'm going > > down the wrong track ? > > > > Perhaps another alternative is to modify the grammar somehow ? > > > > I guess, the question is, in general how do you handle such repeated > > elements > > as definied in an EBNF grammar, in structuring your data ? > > > > Any advice appreciated ! > > > > Thanks :) > > > > _______________________________________________ > > Beginners mailing list > > Beginners@haskell.org > > http://www.haskell.org/mailman/listinfo/beginners > > > > ------------------------------ > > Message: 4 > Date: Mon, 17 Nov 2008 09:35:26 +0530 > From: "Sayali Kulkarni" <[EMAIL PROTECTED]> > Subject: RE: [Haskell-beginners] Profiling haskell code > To: "Brent Yorgey" <[EMAIL PROTECTED]>, <beginners@haskell.org> > Message-ID: <[EMAIL PROTECTED]> > Content-Type: text/plain; charset="us-ascii" > > Hello Brent, > > I just have written a quick sort program. > There is nothing more in the code than that I have shown. > > What is it about the main function? > What do I need to do in the main function? > > I do not get any errors. > And I get the expected output. The only thing that I am stuck at is that > I do not get the ".prof" file which will give me the profile details of > the code. > > Also it would be great if you could through a light on whether there is > any other method to profile a code in Haskell? > > Regards, > Sayali. > > -----Original Message----- > From: [EMAIL PROTECTED] > [mailto:[EMAIL PROTECTED] On Behalf Of Brent Yorgey > Sent: Saturday, November 15, 2008 2:24 AM > To: beginners@haskell.org > Subject: Re: [Haskell-beginners] Profiling haskell code > > > > > quicksort [ ] = [ ] > > > > quicksort (x : xs) = quicksort larger ++ [x ] ++ quicksort smaller > > > > > > where > > > > > > smaller = [a | a <- xs, a <= x ] > > > > > > larger = [b | b <- xs, b > x ] > > > > > > > > > > > > When I compile the code with the following command : > > > > > > > > $ ghc --make Project.hs -prof -auto-all > > > > Then I tested it with the following command : > > > > $ Project +RTS -p > > > > It generates the .hi and the .o file but I cannot get the .prof file. > > > > Please let me know if any of the steps is missing or where could I > check > > my profiling info. > > > > Hi Sayali, > > Is the code shown above *everything* in your Project.hs file? You > will also need a main function for it to actually do anything. If > there is more to your Project.hs file that you have not shown, could > you send the complete version? > > Do you get any errors? Does Project produce the output that you expect? > > -Brent > _______________________________________________ > Beginners mailing list > Beginners@haskell.org > http://www.haskell.org/mailman/listinfo/beginners > > > ------------------------------ > > Message: 5 > Date: Mon, 17 Nov 2008 09:07:57 -0500 > From: Brent Yorgey <[EMAIL PROTECTED]> > Subject: Re: [Haskell-beginners] Profiling haskell code > To: beginners@haskell.org > Message-ID: <[EMAIL PROTECTED]> > Content-Type: text/plain; charset=us-ascii > > On Mon, Nov 17, 2008 at 09:35:26AM +0530, Sayali Kulkarni wrote: > > Hello Brent, > > > > I just have written a quick sort program. > > There is nothing more in the code than that I have shown. > > > > What is it about the main function? > > What do I need to do in the main function? > > > > I do not get any errors. > > And I get the expected output. The only thing that I am stuck at is that > > I do not get the ".prof" file which will give me the profile details of > > the code. > > > > Also it would be great if you could through a light on whether there is > > any other method to profile a code in Haskell? > > > > Regards, > > Sayali. > > Hi Sayali, > > Just writing a quicksort function by itself is fine if you want to > test it interactively in ghci. But if you want to profile it you will > have to make an executable, which means you will need a 'main' > function which says what to do when the program is run. Your main > function might look something like this: > > main = do print "Sorting..." > print (length (quicksort (reverse [1..1000000]))) > print "Done!" > > Of course, sorting a list in reverse order might not be a very > representative task; you might also want to look into the > System.Random module to generate a list of a million random elements > and sort that. > > -Brent > > > > > -----Original Message----- > > From: [EMAIL PROTECTED] > > [mailto:[EMAIL PROTECTED] On Behalf Of Brent Yorgey > > Sent: Saturday, November 15, 2008 2:24 AM > > To: beginners@haskell.org > > Subject: Re: [Haskell-beginners] Profiling haskell code > > > > > > > > quicksort [ ] = [ ] > > > > > > quicksort (x : xs) = quicksort larger ++ [x ] ++ quicksort smaller > > > > > > > > > where > > > > > > > > > smaller = [a | a <- xs, a <= x ] > > > > > > > > > larger = [b | b <- xs, b > x ] > > > > > > > > > > > > > > > > > > When I compile the code with the following command : > > > > > > > > > > > > $ ghc --make Project.hs -prof -auto-all > > > > > > Then I tested it with the following command : > > > > > > $ Project +RTS -p > > > > > > It generates the .hi and the .o file but I cannot get the .prof file. > > > > > > Please let me know if any of the steps is missing or where could I > > check > > > my profiling info. > > > > > > > Hi Sayali, > > > > Is the code shown above *everything* in your Project.hs file? You > > will also need a main function for it to actually do anything. If > > there is more to your Project.hs file that you have not shown, could > > you send the complete version? > > > > Do you get any errors? Does Project produce the output that you expect? > > > > -Brent > > _______________________________________________ > > Beginners mailing list > > Beginners@haskell.org > > http://www.haskell.org/mailman/listinfo/beginners > > > > > ------------------------------ > > Message: 6 > Date: Tue, 18 Nov 2008 10:02:20 -0800 > From: "Michael Snoyman" <[EMAIL PROTECTED]> > Subject: [Haskell-beginners] Type polymorphism with size > To: beginners@haskell.org > Message-ID: > <[EMAIL PROTECTED]> > Content-Type: text/plain; charset="utf-8" > > I am trying to write some code to read flat files from a mainframe > system. > This includes some character fields. This is a fixed width file, so each > field will have a consistent length between records, but there are fields > of > different length within a record. For example, I might have a "name" > field > length 20 and an eye color field length 5. > > I am trying to use the binary library to read in this file. I've written > a > binary type, MFChar2, for reading in a 2-length character field. It is > defined as such (you can safely ignore the ebcdicToAscii piece, it is > just > doing character conversion): > > data MFChar2 = MFChar2 [Word8] > instance Binary MFChar2 where > put = undefined > get = do ebcdic <- replicateM 2 getWord8 > return $ MFChar2 $ map ebcdicToAscii ebcdic > > What I would like to do is have some kind of generic "MFChar" data type > which could take any character length, but I can't figure out how to do > it. > Any help would be appreciated. > > Thanks, > Michael > -------------- next part -------------- > An HTML attachment was scrubbed... > URL: > http://www.haskell.org/pipermail/beginners/attachments/20081118/3349841f/attachment-0001.htm > > ------------------------------ > > Message: 7 > Date: Tue, 18 Nov 2008 14:18:22 -0500 > From: Brent Yorgey <[EMAIL PROTECTED]> > Subject: Re: [Haskell-beginners] Type polymorphism with size > To: beginners@haskell.org > Message-ID: <[EMAIL PROTECTED]> > Content-Type: text/plain; charset=us-ascii > > On Tue, Nov 18, 2008 at 10:02:20AM -0800, Michael Snoyman wrote: > > I am trying to write some code to read flat files from a mainframe system. > > This includes some character fields. This is a fixed width file, so each > > field will have a consistent length between records, but there are fields of > > different length within a record. For example, I might have a "name" field > > length 20 and an eye color field length 5. > > > > I am trying to use the binary library to read in this file. I've written a > > binary type, MFChar2, for reading in a 2-length character field. It is > > defined as such (you can safely ignore the ebcdicToAscii piece, it is just > > doing character conversion): > > > > data MFChar2 = MFChar2 [Word8] > > instance Binary MFChar2 where > > put = undefined > > get = do ebcdic <- replicateM 2 getWord8 > > return $ MFChar2 $ map ebcdicToAscii ebcdic > > > > What I would like to do is have some kind of generic "MFChar" data type > > which could take any character length, but I can't figure out how to do it. > > Any help would be appreciated. > > Hm, interesting! The problem is that 'get' does not take any > arguments, so must determine what to do from the type at which it is > called. So the number of words to be read needs to be in the type. > We can't put actual Int values in a type -- but there is actually a > way to do what you want, by encoding natural numbers at the type > level! I don't know whether this really belongs on a 'beginners' list > but I couldn't resist. =) > > > data Z -- the type representing zero > data S n -- the type representing the successor of another natural > > -- for example, Z, S Z, and S (S Z) are types representing > -- zero, one, and two. > > -- the n is for a type-level natural representing the length of the list. > data MFChar n = MFChar [Word8] > > -- add a Word8 to the beginning of an MFChar, resulting in an MFChar > -- one word longer > mfCons :: Word8 -> MFChar n -> MFChar (S n) > mfCons w (MFChar ws) = MFChar (w:ws) > > instance Binary (MFChar Z) where > get = return $ MFChar [] > > instance (Binary (MFChar n)) => Binary (MFChar (S n)) where > get = do ebcdic <- getWord8 > rest <- get -- the correct type of get is > -- inferred due to the use of mfCons below > return $ mfCons (ebcdicToAscii ebcdic) rest > > > Now if you wanted to read a field with 20 chars, you can use > > get :: Get (MFChar (S (S (S ... 20 S's ... Z)))) > > Ugly, I know. You could make it slightly more bearable by defining > some type synonyms at the top of your program like > > type Five = S (S (S (S (S Z)))) > type Ten = S (S (S (S (S Five)))) > > and so on. Then you can just say get :: Get (MFChar Ten) or whatever. > > This is untested but it (or something close to it) ought to work. Of > course, you may well ask yourself whether this contortion is really > worth it. Maybe it is, maybe it isn't, but I can't think of a better > way to do it in Haskell. In a dependently typed language such as > Agda, we could just put regular old natural numbers in the types, > instead of going through contortions to encode natural numbers as > types as we have to do here. So I guess the real answer to your > question is "use a dependently typed language". =) > > If you have problems getting this to work or more questions, feel free > to ask! > > -Brent > > > ------------------------------ > > Message: 8 > Date: Tue, 18 Nov 2008 14:18:46 -0800 > From: "Michael Snoyman" <[EMAIL PROTECTED]> > Subject: Re: [Haskell-beginners] Type polymorphism with size > To: "Brent Yorgey" <[EMAIL PROTECTED]> > Cc: beginners@haskell.org > Message-ID: > <[EMAIL PROTECTED]> > Content-Type: text/plain; charset="utf-8" > > On Tue, Nov 18, 2008 at 11:18 AM, Brent Yorgey > <[EMAIL PROTECTED]>wrote: > > > Hm, interesting! The problem is that 'get' does not take any > > arguments, so must determine what to do from the type at which it is > > called. So the number of words to be read needs to be in the type. > > We can't put actual Int values in a type -- but there is actually a > > way to do what you want, by encoding natural numbers at the type > > level! I don't know whether this really belongs on a 'beginners' list > > but I couldn't resist. =) > > > > > > data Z -- the type representing zero > > data S n -- the type representing the successor of another natural > > > > -- for example, Z, S Z, and S (S Z) are types representing > > -- zero, one, and two. > > > > -- the n is for a type-level natural representing the length of the list. > > data MFChar n = MFChar [Word8] > > > > -- add a Word8 to the beginning of an MFChar, resulting in an MFChar > > -- one word longer > > mfCons :: Word8 -> MFChar n -> MFChar (S n) > > mfCons w (MFChar ws) = MFChar (w:ws) > > > > instance Binary (MFChar Z) where > > get = return $ MFChar [] > > > > instance (Binary (MFChar n)) => Binary (MFChar (S n)) where > > get = do ebcdic <- getWord8 > > rest <- get -- the correct type of get is > > -- inferred due to the use of mfCons below > > return $ mfCons (ebcdicToAscii ebcdic) rest > > > > > > Now if you wanted to read a field with 20 chars, you can use > > > > get :: Get (MFChar (S (S (S ... 20 S's ... Z)))) > > > > Ugly, I know. You could make it slightly more bearable by defining > > some type synonyms at the top of your program like > > > > type Five = S (S (S (S (S Z)))) > > type Ten = S (S (S (S (S Five)))) > > > > and so on. Then you can just say get :: Get (MFChar Ten) or whatever. > > > > This is untested but it (or something close to it) ought to work. Of > > course, you may well ask yourself whether this contortion is really > > worth it. Maybe it is, maybe it isn't, but I can't think of a better > > way to do it in Haskell. In a dependently typed language such as > > Agda, we could just put regular old natural numbers in the types, > > instead of going through contortions to encode natural numbers as > > types as we have to do here. So I guess the real answer to your > > question is "use a dependently typed language". =) > > > > If you have problems getting this to work or more questions, feel free > > to ask! > > > > Very interesting solution to the problem. I tried it out and it works > perfectly... but it's just too much of a hack for my tastes (no offense; > I > think it was very cool). I thought about it a bit and realized what I > really > want is a way to deal with tuples of the same type, which led to this > kind > of implementation. > > class RepTuple a b | a -> b where > toList :: a -> [b] > tMap :: (b -> b) -> a -> a > > instance RepTuple (a, a) a where > toList (a, b) = [a, b] > tMap f (a, b) = (f a, f b) > > And so on and so forth for every kind of tuple. Of course, this runs into > the issue of the single case, for which I used the OneTuple library > (actually, I wrote my own right now, but I intend to just use the > OneTuple > library). > > I can then do something like this (which I have tested and works): > > data MFChar w = MFChar w > deriving Eq > instance (RepTuple w a, Integral a) => Show (MFChar w) where > show (MFChar ws) = map (chr . fromIntegral) $ toList ws > instance (Integral a, Binary w, RepTuple w a) => Binary (MFChar w) where > put = undefined > get = do ebcdic <- get > let ascii = tMap ebcdicToAscii ebcdic > return $ MFChar ascii > > type MFChar1 = MFChar (OneTuple Word8) > type MFChar2 = MFChar (Word8, Word8) > type MFChar4 = MFChar (Word8, Word8, Word8, Word8) > type MFChar5 = MFChar (Word8, Word8, Word8, Word8, Word8) > type MFChar10 = MFChar (Word8, Word8, Word8, Word8, Word8, > Word8, Word8, Word8, Word8, Word8) > > If I wanted, I could do away with the tMap function and just include the > ebcdicToAscii step in the show instance. > > Michael > -------------- next part -------------- > An HTML attachment was scrubbed... > URL: > http://www.haskell.org/pipermail/beginners/attachments/20081118/8a75bca1/attachment.htm > > ------------------------------ > > _______________________________________________ > Beginners mailing list > Beginners@haskell.org > http://www.haskell.org/mailman/listinfo/beginners > > > End of Beginners Digest, Vol 5, Issue 10 > **************************************** -- israel orange [EMAIL PROTECTED] ------------------------------ Message: 2 Date: Tue, 18 Nov 2008 20:16:37 -0500 From: Brent Yorgey <[EMAIL PROTECTED]> Subject: Re: [Haskell-beginners] Type polymorphism with size To: beginners@haskell.org Message-ID: <[EMAIL PROTECTED]> Content-Type: text/plain; charset=us-ascii On Tue, Nov 18, 2008 at 02:18:46PM -0800, Michael Snoyman wrote: > > Very interesting solution to the problem. I tried it out and it works > perfectly... but it's just too much of a hack for my tastes (no offense; I None taken. =) > > class RepTuple a b | a -> b where > toList :: a -> [b] > tMap :: (b -> b) -> a -> a > > instance RepTuple (a, a) a where > toList (a, b) = [a, b] > tMap f (a, b) = (f a, f b) > > And so on and so forth for every kind of tuple. Of course, this runs into > the issue of the single case, for which I used the OneTuple library > (actually, I wrote my own right now, but I intend to just use the OneTuple > library). > This is reasonable too. It's just a tradeoff of hackishness vs. code length/tediousness. I.e. in the solution with type-level naturals, you don't need a separate instance like this for every number you're going to use. And no one really likes writing things like tMap f (a,b,c,d,e,g,h,i,j) = ... =) -Brent ------------------------------ Message: 3 Date: Tue, 18 Nov 2008 19:58:24 -0800 From: "David Frey" <[EMAIL PROTECTED]> Subject: Re: [Haskell-beginners] Type polymorphism with size To: "beginners@haskell.org" <beginners@haskell.org> Message-ID: <[EMAIL PROTECTED]> Content-Type: text/plain; charset=ISO-8859-1 On 11/18/2008, "Michael Snoyman" <[EMAIL PROTECTED]> wrote: >I am trying to write some code to read flat files from a mainframe system. >This includes some character fields. This is a fixed width file, so each >field will have a consistent length between records, but there are fields of >different length within a record. For example, I might have a "name" field >length 20 and an eye color field length 5. > >I am trying to use the binary library to read in this file. I've written a >binary type, MFChar2, for reading in a 2-length character field. It is >defined as such (you can safely ignore the ebcdicToAscii piece, it is just >doing character conversion): > >data MFChar2 = MFChar2 [Word8] >instance Binary MFChar2 where > put = undefined > get = do ebcdic <- replicateM 2 getWord8 > return $ MFChar2 $ map ebcdicToAscii ebcdic > >What I would like to do is have some kind of generic "MFChar" data type >which could take any character length, but I can't figure out how to do it. >Any help would be appreciated. > >Thanks, >Michael Is this something that could be accomplished using template Haskell? I don't know anything about template Haskell, but maybe someone else on the list can comment on this suggestion. ------------------------------ _______________________________________________ Beginners mailing list Beginners@haskell.org http://www.haskell.org/mailman/listinfo/beginners End of Beginners Digest, Vol 5, Issue 11 ****************************************