- Beginners - Haskell.org

A Quantity Type - Integer without the Negative #'s
by aditya siram 11 May '09

11 May '09

Hi all, Is there a datatype in Haskell that can be used to represent only quantities >= 0? I got bitten by a bug because I forgot to reject an amount that was below zero after applying a decrementing operator. A simple unit test would have caught this, but I was wondering if there was some way of getting the type system to ensure this. thanks ... -deech

7 9

Performance of function defined in a 'where' clause
by Kevin Haines 11 May '09

11 May '09

Hi All, I'm trying to write a bit of code that maps each byte in a block of Word8's to 3xWord8 using an array; i.e. mapping from 8 bit to 24 bit colour (this is an OpenGL application, and I'm using textures). I should point out that this is experimental code, and I'm still learning Haskell (and *loving* it, by the way!), so it probably looks a little unpolished. First, some data: data Palette = Palette { palRed :: Word8, palGrn :: Word8, palBlu :: Word8 } palette = listArray (0,49) paletteList paletteList = [ Palette 0 0 0, Palette 0 0 0, Palette 0 0 0, ..... Then, my first implementation, which took 57% time under profiling, was: loadTile :: Int -> Int -> IO (Ptr Word8) loadTile lat lon = do terrainBytes <- readTile lat lon -- implementation #1 mapM_ (paletteMapper terrainBytes rgbBytes) [0..tileSize^2-1] free terrainBytes return rgbBytes where tileSize = 128 paletteMapper :: Ptr Word8 -> Ptr Word8 -> Int -> IO () paletteMapper tb rgb idx = do v <- peekElemOff tb idx pokeByteOff rgb (idx*3) (palRed (palette!v)) pokeByteOff rgb (idx*3+1) (palGrn (palette!v)) pokeByteOff rgb (idx*3+2) (palBlu (palette!v)) I tried moving paletterMapper out of the 'where' clause and into the top level, which then took only 26% of time - i.e. half the time: paletteMapper :: Ptr Word8 -> Ptr Word8 -> Int -> IO () paletteMapper tb rgb idx = do v <- peekElemOff tb idx pokeByteOff rgb (idx*3) (palRed (palette!v)) pokeByteOff rgb (idx*3+1) (palGrn (palette!v)) pokeByteOff rgb (idx*3+2) (palBlu (palette!v)) loadTile :: Int -> Int -> IO (Ptr Word8) loadTile lat lon = do terrainBytes <- readTile lat lon -- implementation #1 mapM_ (paletteMapper terrainBytes rgbBytes) [0..tileSize^2-1] free terrainBytes return rgbBytes where tileSize = 128 I don't understand why - the functions are the same, except for the scope they're in. Can anyone elaborate on what's happening? Incidentally, I now realise a faster way (14%) is: loadTile :: Int -> Int -> IO (Ptr Word8) loadTile lat lon = do terrainBytes <- readTile lat lon rgbBytes <- mallocBytes (3*(tileSize^2)) mapM_ (\x -> do v <- peekElemOff terrainBytes x pokeByteOff rgbBytes (x*3) (palRed (palette!v)) pokeByteOff rgbBytes (x*3+1) (palGrn (palette!v)) pokeByteOff rgbBytes (x*3+2) (palBlu (palette!v)) ) [0..tileSize^2-1] free terrainBytes return rgbBytes where tileSize = 128 (There may be faster/better ways still, I'm all ears :-) Cheers Kevin

3 4

SQL Lexer
by Patrick LeBoutillier 11 May '09

11 May '09

Hi all, In the process of writing an SQL parser I started by writing a lexer. The code can be found here: http://hpaste.org/fastcgi/hpaste.fcgi/view?id=4736#a4736 You can run it like this in ghci: Prelude SQL.Lexer> runLexer "select * from TABLE order by FIELD" [Token Reserved "select",Token Space " ",Token Operator "*",Token Space " ",Token Reserved "from",Token Space " ",Token Identifier "TABLE",Token Space " ",Token Reserved "order",Token Space " ",Token Reserved "by",Token Space " ",Token Identifier "FIELD"] Since this is pretty much my first Haskell project over 10 lines long, I'm looking for some feedback of any kind. Ultimately I would like to use this lexer to build a functional SQL parser using Parsec. Thanks, Patrick -- ===================== Patrick LeBoutillier Rosemère, Québec, Canada

6 6

Pros and Cons of Haskell libsndfile packages?
by Charles Turner 08 May '09

08 May '09

Hi all- I noticed that there were two different packages that provided a Haskell interface to the libsndfile library: HSoundFile: <http://hackage.haskell.org/cgi-bin/hackage-scripts/package/HSoundFile > hsoundfile: <http://hackage.haskell.org/cgi-bin/hackage-scripts/package/hsndfile > Does anyone have any comments of the relative merits of either of these? Thanks! Charles

2 2

How to wait till a process is finished before invoking the next one?
by Thomas Friedrich 07 May '09

07 May '09

Hi everyone, I have the following problem, and I hope that someone of yours might be able to help me. The Haskell program I am writing has the following setup: writeData :: [String] -> IO () writeData cs = ... runProgram:: [String] -> IO () runProgram cs = ... writeFeatures :: [String] -> IO () writeFeatures cs = ... runTestOnFeatures :: IO () runTestOnFeatures = ... main :: IO () main = do cs <- getArgs writeData cs runProgram cs writeFeatures cs runTestOnFeatures Each of the above function take a list of filenames, run certain command-line programs on them, which I invoke by runCommand, and each of them produce multiple output-files. Each function in main needs a couple of those output-files that are produced by the function directly above it. How do I get Haskell to wait, till all the data is written to the disk, before invoking the next command. The way the program is currently written, Haskell doesn't see that the input of one function depends on the output of another, and tries to run them all at the same time. Any ideas? Thanks everyone for your help. Cheers, Thomas

3 3

Real World Haskell Chapter 5
by PJ Fitzpatrick 07 May '09

07 May '09

Hi, I have compiled the SimpleJSON.hs file from chapter 5 and from another file attempted to import it. I am getting a could not find module error and the prelude tells me that the locations searched were SimpleJSON.hs and SimpleJSON.lhs. I am running Vista, GHC 6.10.2 Any ideas? tks, PJ

2 1

Re: [Haskell-beginners] How to wait till a process is finished before invoking the next one?
by Daniel Fischer 07 May '09

07 May '09

Am Donnerstag 07 Mai 2009 20:53:11 schrieb Thomas Friedrich: > Hi Daniel and everyone, > > Thanks for the reply! > > I thought of using waitForProcess, and in fact an earlier version of the > program did. However, as the program got more complex, I don't really > see how this is still possible. > > For example the runProgram function looks like this: > > runProgram :: [String] -> IO () > runProgram [] = return () > runProgram (c:cs) = do > runCommand ("lalala " ++ c) > runProgram cs You could have runCommand ("lalala " ++ c) >>= waitForProcess in the penultimate line. That would ensure that the command has finished before its results are requested, but of course destroy all possibilities of parallelism :-( Another option would be runProgram [] = return [] runProgram (c:cs) = unsafeInterleaveIO $ do ph <- runCommand ("lalala " ++ c) phs <- runProgram cs return (ph:phs) and then, processHandles <- runProgram blah mapM_ waitForProcess (processHandles) next step that should work (I hope) and would allow the commands to be run in parallel while making sure all have finished before the next step is started. > > It might be possible to write the function runProgram in a way, so that > it returns an expression of type [IO ProcessHandle] and then try to work > from there. But I have the feeling, that this will become messy very > quickly, and there must be some more elegant way of doing this. The > other thing is that actually not all functions are able to return > ProcessHandles, e.g. > > writeFeatures :: [String] -> IO () > writeFeatures cs = Exc.bracket (openFile training AppendMode) hClose (\h > -> goo h) > where > goo h = go 1 cs > where > go :: Int -> [String] -> IO () > go n [] = putStrLn "Features written." > go n (c:cs) = do > features <- makeFeatures n c -- makeFeatures :: Int -> > String -> IO String > hPutStr h features > go (n+1) cs > > And the file that is produced here is needed in the next function. That can't appear in runProgram, though. I'm not sure it would work, but you coud give {-# LANGUAGE BangPatterns #-} ... !a <- writeFeatures blah more or go n (c:cs) = do features <- makeFeatures n c !a <- hPutStr h features go (n+1) cs a try. > > I hoped to do something with forkIO, as I would like to parallelize the > whole program at the end. Especially the function runProgram would > benefit hugely from this (I so don't have a clue how to do this yet;). I > tried for example the following: > > main :: IO () > main = do > cs <- getArgs > p1 <- forkIO $ writeData cs > p2 <- forkIO $ runProgram cs > p3 <- forkIO $ writeFeatures cs > p4 <- forkIO $ runTestOnFeatures > seq p1 (seq p2 (seq p3 (seq p4 (putStrLn "Done")))) > > But that of course doesn't work, because now I am not actually > requesting anything. The program does in fact nothing, apart from > printing out "Done". Huh. There doesn't seem to be a wait function for ThreadIds, so I guess you would have to communicate via MVars, QSemNs or some such means to signal that one task has been completed and the next can be started. > > Any ideas? > > Cheers, > Thomas

1 0

parallel program in haskell in 5 steps
by Jack Kennedy 06 May '09

06 May '09

In step 4 of Haskell in 5 Steps [ http://haskell.org/haskellwiki/Haskell_in_5_steps] a parallel program is given. I changed it very slightly so it would run a long time (see below). It compiles and runs but my CPU meter is barely above 50%. I have a dual core processor. What in the world would keep this program from completely saturating the CPU? import Control.Parallel main = a `par` b `pseq` print (a + b) where a = ack 4 10 b = ack 4 10 fac 0 = 1 fac n = n * fac (n-1) ack 0 n = n+1 ack m 0 = ack (m-1) 1 ack m n = ack (m-1) (ack m (n-1)) fib 0 = 0 fib 1 = 1 fib n = fib (n-1) + fib (n-2)

4 5

Context reducion Stack overflow
by Marco Túlio Gontijo e Silva 06 May '09

06 May '09

Hello, I'm trying to compile the following code: > import Data.IORef > class F f where > m :: (a -> a) -> f a -> f a > class M m a where > mm :: (a -> a) -> m -> IO () > instance (F f, M m (f a)) => M m a where > mm f v = mm (m f) v And I'm getting: $ ghci teste.lhs -XMultiParamTypeClasses -XFlexibleInstances -XFlexibleContexts -XUndecidableInstances -XIncoherentInstances GHCi, version 6.10.1: http://www.haskell.org/ghc/ :? for help Loading package ghc-prim ... linking ... done. Loading package integer ... linking ... done. Loading package base ... linking ... done. Failed, modules loaded: none. Prelude> ^DLeaving GHCi. GHCi, version 6.10.1: http://www.haskell.org/ghc/ :? for help Loading package ghc-prim ... linking ... done. Loading package integer ... linking ... done. Loading package base ... linking ... done. [1 of 1] Compiling Main ( teste.lhs, interpreted ) teste.lhs:1:0: Context reduction stack overflow; size = 20 Use -fcontext-stack=N to increase stack size to N `$dM{atp} :: {M m (f (f (f (f (f (f (f (f (f (f (f (f (f (f (f (f (f (f (f (f a))))))))))))))))))))}' arising from a use of `mm' at teste.lhs:10:13-22 `$dM{atm} :: {M m (f (f (f (f (f (f (f (f (f (f (f (f (f (f (f (f (f (f (f a)))))))))))))))))))}' arising from a use of `mm' at teste.lhs:10:13-22 `$dM{atj} :: {M m (f (f (f (f (f (f (f (f (f (f (f (f (f (f (f (f (f (f a))))))))))))))))))}' arising from a use of `mm' at teste.lhs:10:13-22 `$dM{atg} :: {M m (f (f (f (f (f (f (f (f (f (f (f (f (f (f (f (f (f a)))))))))))))))))}' arising from a use of `mm' at teste.lhs:10:13-22 `$dM{atd} :: {M m (f (f (f (f (f (f (f (f (f (f (f (f (f (f (f (f a))))))))))))))))}' arising from a use of `mm' at teste.lhs:10:13-22 `$dM{ata} :: {M m (f (f (f (f (f (f (f (f (f (f (f (f (f (f (f a)))))))))))))))}' arising from a use of `mm' at teste.lhs:10:13-22 `$dM{at7} :: {M m (f (f (f (f (f (f (f (f (f (f (f (f (f (f a))))))))))))))}' arising from a use of `mm' at teste.lhs:10:13-22 `$dM{at4} :: {M m (f (f (f (f (f (f (f (f (f (f (f (f (f a)))))))))))))}' arising from a use of `mm' at teste.lhs:10:13-22 `$dM{at1} :: {M m (f (f (f (f (f (f (f (f (f (f (f (f a))))))))))))}' arising from a use of `mm' at teste.lhs:10:13-22 `$dM{asY} :: {M m (f (f (f (f (f (f (f (f (f (f (f a)))))))))))}' arising from a use of `mm' at teste.lhs:10:13-22 `$dM{asV} :: {M m (f (f (f (f (f (f (f (f (f (f a))))))))))}' arising from a use of `mm' at teste.lhs:10:13-22 `$dM{asS} :: {M m (f (f (f (f (f (f (f (f (f a)))))))))}' arising from a use of `mm' at teste.lhs:10:13-22 `$dM{asP} :: {M m (f (f (f (f (f (f (f (f a))))))))}' arising from a use of `mm' at teste.lhs:10:13-22 `$dM{asM} :: {M m (f (f (f (f (f (f (f a)))))))}' arising from a use of `mm' at teste.lhs:10:13-22 `$dM{asJ} :: {M m (f (f (f (f (f (f a))))))}' arising from a use of `mm' at teste.lhs:10:13-22 `$dM{asG} :: {M m (f (f (f (f (f a)))))}' arising from a use of `mm' at teste.lhs:10:13-22 `$dM{asD} :: {M m (f (f (f (f a))))}' arising from a use of `mm' at teste.lhs:10:13-22 `$dM{asA} :: {M m (f (f (f a)))}' arising from a use of `mm' at teste.lhs:10:13-22 `$dM{asx} :: {M m (f (f a))}' arising from a use of `mm' at teste.lhs:10:13-22 `$dM{asj} :: {M m (f a)}' arising from a use of `mm' at teste.lhs:10:13-22 Failed, modules loaded: none. An example of instances of these classes: > instance F [] where > m = map > instance M (IORef a) a where > mm = flip modifyIORef I don't get what's the problem with my definition. Can someone clarify me on this? Greetings. -- marcot http://marcot.iaaeee.org/

2 5

question >>= [style, efficiency]
by Joel Neely 06 May '09

06 May '09

I can think of a variety of ways to put a value at the end of a list of the same type. -- cutesy-clever putAtEnd :: [a] -> a -> [a] putAtEnd xs x = reverse (x : reverse xs) -- by hand atEnd :: [a] -> a -> [a] atEnd [] z = [z] atEnd (x:xs) z = x : atEnd xs z -- obvious brute force infixr 9 +: (+:) :: [a] -> a -> [a] (+:) xs x = xs ++ [x] I'd appreciate feedback/advice on whether: 1) I've missed any clearly-better alternatives; 2) any of those is obviously better or worse than the others; 3) I should have known where to look for the answer myself (instead of brute-force Googling). I've semi-inadvertently mixed two issues above: infix-vs-prefix and algorithm design. TIA for suggestions on either. -jn- -- Beauty of style and harmony and grace and good rhythm depend on simplicity. - Plato

3 2