- Beginners - Haskell.org

help
by haskell-beginners＠iorange.fastmail.fm 18 Nov '08

18 Nov '08

On Tue, 18 Nov 2008 17:12:57 -0500 (EST), beginners-request(a)haskell.org said: > Send Beginners mailing list submissions to > beginners(a)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 > beginners-request(a)haskell.org > > You can reach the person managing the list at > beginners-owner(a)haskell.org > > 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 <byorgey(a)seas.upenn.edu> > Subject: Re: [Haskell-beginners] Profiling haskell code > To: beginners(a)haskell.org > Message-ID: <20081114205334.GA30261(a)seas.upenn.edu> > 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 <streborg(a)hotmail.com> > Subject: [Haskell-beginners] Parsing arithmentic expressions > To: beginners(a)haskell.org > Message-ID: <loom.20081115T235851-940(a)post.gmane.org> > 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 <bjpop(a)csse.unimelb.edu.au> > Subject: Re: [Haskell-beginners] Parsing arithmentic expressions > To: Glurk <streborg(a)hotmail.com> > Cc: beginners(a)haskell.org > Message-ID: <57383C16-16DD-4032-9CBC-5D6CC27A6E6E(a)csse.unimelb.edu.au> > 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#buildExpressionPars… > > 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(a)haskell.org > > http://www.haskell.org/mailman/listinfo/beginners > > > > ------------------------------ > > Message: 4 > Date: Mon, 17 Nov 2008 09:35:26 +0530 > From: "Sayali Kulkarni" <Sayali.Kulkarni(a)kpitcummins.com> > Subject: RE: [Haskell-beginners] Profiling haskell code > To: "Brent Yorgey" <byorgey(a)seas.upenn.edu>, <beginners(a)haskell.org> > Message-ID: <82C3BC9106BCE149B63464D79D0A22FD0761A60E(a)sohm.kpit.com> > 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: beginners-bounces(a)haskell.org > [mailto:beginners-bounces@haskell.org] On Behalf Of Brent Yorgey > Sent: Saturday, November 15, 2008 2:24 AM > To: beginners(a)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(a)haskell.org > http://www.haskell.org/mailman/listinfo/beginners > > > ------------------------------ > > Message: 5 > Date: Mon, 17 Nov 2008 09:07:57 -0500 > From: Brent Yorgey <byorgey(a)seas.upenn.edu> > Subject: Re: [Haskell-beginners] Profiling haskell code > To: beginners(a)haskell.org > Message-ID: <20081117140757.GA13235(a)seas.upenn.edu> > 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: beginners-bounces(a)haskell.org > > [mailto:beginners-bounces@haskell.org] On Behalf Of Brent Yorgey > > Sent: Saturday, November 15, 2008 2:24 AM > > To: beginners(a)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(a)haskell.org > > http://www.haskell.org/mailman/listinfo/beginners > > > > > ------------------------------ > > Message: 6 > Date: Tue, 18 Nov 2008 10:02:20 -0800 > From: "Michael Snoyman" <michael(a)snoyman.com> > Subject: [Haskell-beginners] Type polymorphism with size > To: beginners(a)haskell.org > Message-ID: > <29bf512f0811181002k7ea715f3o8d797aae6a4b3855(a)mail.gmail.com> > 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 >

1 0

Profiling haskell code
by Sayali Kulkarni 17 Nov '08

17 Nov '08

Hello, I am new to Haskell. I have written a small quicksort function in Haskell. I want to profile it for time. I have GHC 6.10.1 version and I have also installed the extra-libs that it has on the Haskell home page. I followed the following steps for installing the extra-libs: $ cd /to/the/library/source $ runghc Setup.hs configure --enable-library-profiling $ runghc Setup.hs build $ runghc Setup.hs install Following is the quicksort code that I'm using: 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. Regards, Sayali.

2 3

Parsing arithmentic expressions
by Glurk 17 Nov '08

17 Nov '08

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 :)

2 1

Unicode in GHCi
by Christos Chryssochoidis 13 Nov '08

13 Nov '08

Hello, I'd like to type in GHCi some non-latin characters, but when I try it, no characters are inserted at all. Latin characters though are typed in fine, and in any other shell except GHCi I try non-Latin characters get typed without problem. I mean I'm not able to type in GHCi an expression like 'ᾶ' == 'ᾶ' (can't type in the ᾶ) Is this a known GHCi restriction on the character set it accepts, or something is wrong with my setup of GHCi/terminal? I'm using GHC 6.10.1 in Mac OS X Terminal. Thank you very much, Christos

4 4

[Fwd: Re: [Hat] How to use Control.Monad.State?]
by Larry Evans 12 Nov '08

12 Nov '08

Since the hat mailing list seems a bit unresponsive, (or I seem to be impatient), I'm forwarding the attached post here. I've also attached the Makefile that produced the error message shown in the attachment. When the Makefile target is run, it works. However, with target=hat, It produces the error shown in the forwarded msg: Hat/tickSimple.hs:4:0: Bad interface file: /usr/lib/haskell-packages/ghc6/lib/hat-2.05/ghc-6.8.2/Hat/Prelude.hi Something is amiss; requested module main:Prelude differs from name found in the interface file hat-2.5:Hat.Prelude Please, how should the Makefile be modified to avoid this error? -Hopefully, Larry MAIN=Insort MAIN=tickSimple INCS=/usr/lib/haskell-packages/ghc6/lib/hat-2.05/ghc-6.8.2/Hat GHC.FLAGS=-P$(INCS) GHC.LANG=-XMultiParamTypeClasses -XFunctionalDependencies -XFlexibleInstances GHC.OPTS=$(GHC.FLAGS) $(GHC.LANG) run: runghc $(GHC.LANG) $(MAIN).hs hat: hmake -hat $(GHC.OPTS) $(MAIN)

1 0

Pointfree style
by Bas van Gijzel 11 Nov '08

11 Nov '08

Hi, I'm trying to understand pointfree style better, but it's not coming along as well as I'd like it to. The thing I can't get to work is to reduce an argument that is used more than once in a function. My function looks like this now (which works like it should): f x = g ((h . i) x) x But I'd like to reduce the last argument x. I've looked at the wiki[1] but I couldn't find a systematic way to obtain pointfree functions when they get more complicated. Any pointers to pages or papers with more examples of obtaining pointfree functions are appreciated. Thanks, Bas van Gijzel [1]http://www.haskell.org/haskellwiki/Pointfree

3 3

Parsing Revisited
by Jeffrey Drake 11 Nov '08

11 Nov '08

I believe it might be beneficial for me to ask a more general question than I asked in 'Parsing Custom TeX': Given a set of combinators that parse specific parts of a document, how can you string them together so that you can get the whole document parsed? Within this, a consideration for extraneous whitespace should be considered - where you might have specific rules for when to drop whitespace. Thank you again. Jeff.

3 5

should function composition operators affect memory use?
by Logesh Pillay 09 Nov '08

09 Nov '08

I wrote the following program a while ago :- > import List > > sumFacDigits 0 = 0 > sumFacDigits n = product [1 .. mod n 10] + sumFacDigits (div n 10) > > lenFacCycle n = length (nub (take 60 (iterate sumFacDigits n))) > > main = do > print ( sum [ 1 | n <- [1 .. ((10^6) - 1)], lenFacCycle n == 60 ] ) It compiles and runs fine. To get rid of the brackets, I used the function composition operators . and $. (Incidentally why does nobody tell you that you can use . provided the last composition operator is $?) It now reads:- > import List > > sumFacDigits 0 = 0 > sumFacDigits n = product [1 .. mod n 10] + sumFacDigits n `div` 10 > > lenFacCycle n = length . nub . take 60 $ iterate sumFacDigits n > > main = do > print ( sum [ 1 | n <- [1 .. ((10^6) - 1)], lenFacCycle n == 60 ] ) This compiles. When I run it however, it exits with the stack exceeded message. Why? Are the function composition operators more than syntactic sugar for the brackets?

2 1

Parsing Custom TeX
by Jeffrey Drake 08 Nov '08

08 Nov '08

I am getting frustrated when trying to implement a parser for a minimal TeX subset. I am essentially trying to implement something that recognizes \commands (no parameters yet), paragraphs (two newlines), and text (almost anything else). The code I have so far is: module UnTeX where import Text.ParserCombinators.Parsec import Text.ParserCombinators.Parsec.Prim import Text.ParserCombinators.Parsec.Language import qualified Text.ParserCombinators.Parsec.Token as T data UnTeX = Command String | Text String | Paragraph deriving Show command :: Parser UnTeX command = do char '\\' cmd <- many1 (letter <|> digit) <?> "command" return $ Command cmd paragraph :: Parser UnTeX paragraph = do newline newline return $ Paragraph text :: Parser UnTeX text = do txt <- many1 (alphaNum <|> space) return $ Text txt I have no illusions that this is probably far from what I actually need to be doing. But I am finding documentation on all this to be spotty. The 'parsec.pdf' is 7 years old and code doesn't always work. Can anyone point me in the right direction? I just want something to able to do this simply. After an initial version works, I would like to have commands with parameters - something like \command[param][param]{body} but need to have something working first. Thank you for any help you can provide. Jeffrey.

3 3

Lost in binary input
by Moritz Tacke 08 Nov '08

08 Nov '08

Hi! I'm desperately trying to read a binary file into a list of Word16s. After heavily borrowing from the http://www.haskell.org/haskellwiki/DealingWithBinaryData - tutorial (which accounts for the only few working lines of my code), I am still left totally lost. What I need is a piece of code that reads these Word16s and gives them to me in a way that I can apply usual functions on it - should be easy, was my first thought some hours ago... Here is my code: module BinFileReader where import qualified Data.ByteString.Lazy as ByteString import Data.Binary.Get import Data.Word data FileData = FileData { source_filename::String, data = [Word16] } deriving (Show) readBinaryString::FilePath -> IO ByteString.ByteString readBinaryString filename = do input_string <- ByteString.readFile filename putStrLn ((show (ByteString.length input_string) ) ++ " Bytes read") return input_string -- Problems start here: Why the hell does the next function know where its -- data come from? There are no parameters; if I wanted -- to apply another function inside readAsWord that takes the bytestring as well as -- other items, how would I do that? readAsWords::Get [Word16] readAsWords = do empty <- isEmpty if empty then return [] else do v <- getWord16be rest <- readAsWords return (v : rest) readBinaryFile::FilePath -> IO FileData readBinaryFile filename = (FileData filename raw_data) where raw_data = readBinaryString filename word_list = runGet readAsWords raw_data string_length = length word_list -- And here, it ends... I've been trying my best to find a function -- that glues all of the above together, but without any success. -- It should be so trivial, but, somehow, it isn't Any hints? Greetings! Moritz

2 1