May 2006 - Haskell-Cafe

Re: [Haskell-cafe] #if and #endif
by ihope 06 May '06

06 May '06

On 4/13/06, Jason Dagit <dagit(a)codersbase.com> wrote: > Try using passing -cpp to ghc when you compile. > > Jason Thanks. Will do.

2 1

NewBinary/ BinMem and IO monad
by Marc Weber 06 May '06

06 May '06

I'm trying to write some true type library (implementing only the tables I need at the moment). When loading a font file it doesn't make sense to "parse" every table which isn't needed. So lazyness of haskell would perfectly meet requirements here. My problem: NewBinary supports memory buffers. After loading a file to mem it can't change anymore so I no longer need an IO monad. It looks like this: bh <- readBinMem "file" b::Word8 <- get bh Of cause I can't remove the monad here because bh contains an internal pointer to the current position... but it might be done returning the new pointer: (bh2,b::Word8) = get bh ? Then I would be able to lazily parse the tables eg: getTable1 bh = do bh = seek bh offset -- seek to the beginning of the table get binary data and build internal representation return list of glyph and outlines and ... of cause this mem should be readonly then.. Would it make sense to implement this? Does it already exist? Marc

2 4

Dynamically stackable monads
by Christophe Poucet 05 May '06

05 May '06

Hello, I was wondering if it's possible to stack a runtime-known amount of monads on top of each other. Let me illustrate. Assume I have a monad that can consume data and expects as starting parameter an action of the underlying monad to use this data (call it produce at the lower level monad). Now one could imagine stacking one of these consumers on top of the other, as can be seen below. However I can not choose at runtime how many I want to stack. Is there any solution for this? Regards, Christophe ------------------------------ -------------------------------------------------- {-# OPTIONS_GHC -fglasgow-exts #-} module Main where import Control.Monad import Control.Monad.Identity import Control.Monad.State import Control.Monad.Trans data Action e m = Action { produce :: e -> m () } newtype SequencerT e m a = SequencerT (StateT (Action e m) m a) deriving (Functor, Monad, MonadIO) newtype Sequencer e a = Sequencer (SequencerT e Identity a) deriving (Functor, Monad, MonadSequencer e) instance MonadTrans (SequencerT e) where lift = SequencerT . lift class Monad m => MonadSequencer e m | m -> e where consume :: e -> m () instance Monad m => MonadSequencer e (SequencerT e m) where consume x = SequencerT $ do s <- get lift . (produce s) $ x evalSequencerT (SequencerT s) action = evalStateT s action evalSequencer (Sequencer s) inputs action = evalSequencerT s action runSequencerT (SequencerT s) action = runStateT s action runSequencer (Sequencer s) action = runSequencerT s action main :: IO () = evalSequencerT (evalSequencerT (consume 1 >> consume 2 >> consume 3) (Action{produce = \x -> if x > 1 then consume x else liftIO . print $ ("A" ++ show x)})) (Action{produce = print . ("B" ++) . show }) -- Christophe Poucet Ph.D. Student Phone:+32 16 28 87 20 E-mail: --- <Christophe.Poucet(a)imec.be> IMEC vzw – Register of Legal Entities Leuven VAT BE 0425.260.668 – Kapeldreef 75, B-3001 Leuven, Belgium – www.imec.be *****DISCLAIMER***** This e-mail and/or its attachments may contain confidential information. It is intended solely for the intended addressee(s). Any use of the information contained herein by other persons is prohibited. IMEC vzw does not accept any liability for the contents of this e-mail and/or its attachments. **********

1 0

Re: Optimizing locking with MVars
by Simon Marlow 05 May '06

05 May '06

This is interesting, thanks. I propose to add INLINE pragmas to withMVar and friends. Having an interface for simple locks sounds like a good idea to me. Would you like to send a patch? This won't affect Handle I/O unfortunately, because we need block to protect against asynchronous exceptions. I'm still not certain you won't need that in the stream library, too: check any stateful code (eg. buffering) and imagine what happens if an exception is raised at an arbitrary point. Cheers, Simon Bulat Ziganshin wrote: > Main reason of slowness of existing Handle-based I/O in GHC is locking > around each operation. it is especially bad for simple char-at-a-time > I/O where 99% of time spent on locking and unlocking. > > To be exact, on my CPU, hPutChar for 100mb file requires 150 seconds, > while hGetChar for the same file is "only" 100 seconds long. it seems > that former use 3 locking operations and later 2 ones, because my own > vGetChar/vPutChar implementations both requires 52 seconds, of those > only about one second is real work and rest is just `withMVar` > expenses. > > Until now, i thought that this 0.5 ms (about 1000 primitive CPU > operations) on each withMVar is pure time required to perform > takeMVar+putMVar operations. But yesterday i investigated this problem > deeper and results was amazing! > > First, i just made local copy of `withMVar` and added INLINE to it: > > import Control.Exception as Exception > {-# INLINE inlinedWithMVar #-} > inlinedWithMVar :: MVar a -> (a -> IO b) -> IO b > inlinedWithMVar m io = > block $ do > a <- takeMVar m > b <- Exception.catch (unblock (io a)) > (\e -> do putMVar m a; throw e) > putMVar m a > return b > > > Second, i've developed my own simplified version of this procedure. > Here i should say that my library uses "MVar ()" field to hold lock > and separate immutable data field with actual data locked: > > data WithLocking h = WithLocking h !(MVar ()) > > This allowed me to omit block/unblock operation and develop the > following faster analog of withMVar: > > lock (WithLocking h mvar) action = do > Exception.catch (do takeMVar mvar > result <- action h > putMVar mvar () > return res > ) > (\e -> do tryPutMVar mvar (); throw e) > > And as third variant i tried exception-unsafe variant of `withMVar`: > > unsafeWithMVar :: MVar a -> (a -> IO b) -> IO b > unsafeWithMVar m io = do > a <- takeMVar m > b <- io a > putMVar m a > return b > > > And now are results: > > withMVar 52 seconds > inlinedWithMVar 38 seconds > lock 20 seconds > unsafeWithMVar 10 seconds > > > So, > > 1) `withMVar` can be made significantly faster just by attaching > INLINE pragma to it. until GHC includes this patch, you can just make > local copy of this procedure (it's implementation is > compiler-independent) and use INLINE pragma for this local copy > > 2) if MVar is used only to protect some immutable data from > simultaneous access, it's use can be made significantly faster by > using above-mentioned WithLocking type constructor together with > 'lock' function. I hope that this mechanism will go into future > Haskell implementations and in particular it will be used in my own > Streams library and in new DiffArray implementation (that is a part > of ArrayRef library) > > 3) For simple programs that don't catch exceptions anyway, this > excessive protection is just meaningless. they can use > 'unsafeWithMVar' to work as fast as possible. i mean in particular > shootout-like benchmarks. it is also possible to develop fast & safe > routines by using explicit unlocking (with 'tryPutMVar') in > higher-level exception handlers > > > and a more general conclusion. this case is a good demonstration of > significant performance loss due to using of higher-order functions. i > think that more aggressive inlining of high-order and polymorphic > functions should significantly speed up GHC-compiled programs. > >

3 6

Are records type safe?
by Tom Hawkins 04 May '06

04 May '06

I was experimenting with records this morning and discovered a slight oddity... data Rec = RecA { a :: Int } | RecB { a :: Int, b :: Bool } deriving Show main :: IO () main = do print (b (RecB { a = 1, b = True })) -- Works print (b (RecA { a = 1 })) -- Doesn't Of course extracting "b" from a record constructed with "RecA" is illegal, but the compiler did not warn against it (ghc -W). I was expecting a warning similar to non-exhaustive pattern matching. Are records with optional fields really type safe? -Tom

2 1

Is it possible to export module aliases?
by Brian Hulley 04 May '06

04 May '06

Hi - Given some large list of modules which need to be used qualified, I'd like to be able to make a convenience module that I could use instead, and which would export all these modules also qualified by an alias, ie: module Top ( module qualified Top.First as First , module qualified Top.Second as Second ) where ... import qualified Top.First so that I could then say: import Top main = do a <- First.create ... b <- Second.create ... instead of having to always write: import qualified Top.First as First import qualified Top.Second as Second -- this may be a *very* long list in every module that uses the "Top" API. The current "workaround" for this problem in the standard libraries seems to be to always append the module name to the name of the function or type or constructor (which is unfortunately, like record field names, not local to the type but that's another story) eg by using createFirst, createSecond etc, which seems a bit messy to me. An alternative is to use the C preprocessor and #include a file containing all the import declarations, but although "ok", I'd prefer to be able to express the code organization purely in Haskell itself. This must be a very common issue so I'm wondering if anyone else has some better ideas on how to solve it? Thanks, Brian.

2 2

Am I lazy enough?
by Joel Reymont 03 May '06

03 May '06

Folks, I'm looking to use the following code to process a multi-GB text file. I am using ByteStrings but there was a discussion today on IRC about tail recursion, laziness and accumulators that made me wonder. Is fixLines below lazy enough? Can it be made lazier? Thanks, Joel --- module Main where import IO import System import Numeric import Data.Char import Data.Word import qualified Data.Map as M import qualified Data.ByteString.Char8 as B import Prelude hiding (lines) grabTableInfo x = (tableId', (tableType, tableStakes)) where (tableId:tableType:_:tableStakes:_) = B.split ',' x Just (tableId', _) = B.readInt tableId lines = B.split '\n' --- My Oracle ascii dump is 80 characters wide so some lines --- are split. I need to skip empty lines and join lines --- containing less than the required number of commas. fixLines 0 lines = lines fixLines _ [] = [] fixLines n (line:lines) = fixLines' lines line [] where fixLines' [] str acc | B.count ',' str == n = acc ++ [str] | otherwise = acc fixLines' (x:xs) str acc | B.null str -- skip = fixLines' xs x acc | B.count ',' str < n -- join with next line = fixLines' xs (B.append str x) acc | otherwise = fixLines' xs x (acc ++ [str]) mkMap = M.fromList . map grabTableInfo . fixLines 20 loadTableInfo = do bracket (openFile "game_info_tbl.csv" ReadMode) (hClose) (\h -> do c <- B.hGetContents h return $ mkMap $ lines c) -- http://wagerlabs.com/

2 1

Code review: efficiency question
by Brian Hulley 03 May '06

03 May '06

Hi - I started off writing the following piece of monadic code: let drawModal :: Control -> ManagerM () drawModal c = do -- details omitted -- Prolog style coding... drawModals :: [Control] -> ManagerM () drawModals [] = return () drawModals (c:cs) = do drawModals cs drawModal c drawModals cs then it struck me that I should have not bothered with drawModals and instead should just have used: mapM_ drawModal (reverse cs) However, while this looks more elegant, it is less efficient? In other words, how much optimization can one assume when writing Haskell code? I'm trying to get a rough idea so I can decide whether to write helper functions such as drawModals in future or whether I should always just use the most elegant code instead. Any ideas? Thanks, Brian.

5 7

GetOpt
by Anton Kulchitsky 02 May '06

02 May '06

Hi all, I just started to study Haskell and it is my almost first big experience with functional languages (except Emacs Lisp and Python). I enjoyed all small exercises and started a bigger business writing a general utility. However, I have a problem from the beginning. The utility get some file and convert it to another format. It is a kind of small compiler. It also accepts many parameters and behaves depending on them. The problem is how to do this neat! How should I write my program to accept and neatly work with options???? Please, could you suggest an example of code how to do this properly in Haskell. No book or tutorial discuss this topic. It is really sad because the problem is very unclear. Indeed, what I do in C. I make a struct settings and set its fields. Then, the program uses this parameters easily. However, what can I do in Haskell? I imagine the program as a composite function that take some input and produce the output. I decided that now I should consider my program options as an additional variable(s) of the input. Well, it is still hard to implement. Below is an example of what I did first. However, it is just not enough and looks ugly for me. Please, HELP!!!: -------------------------CODE IS BELOW------------------------- module Main where -- std import System.IO import System.Console.GetOpt import System.Environment ( getArgs ) import System.Exit import Char -- data import Data.Maybe ( fromMaybe ) -- local -- main program: options, maybe in file >> out file main :: IO () main = do -- program info genInfo -- options processing args <- getArgs case check_filter args of (WrongOpts,strLst) -> usage ("Error: Wrong option list\n" ++ (concat strLst)) >> exitWith (ExitFailure 1) (ForHelp,strLst) -> usage [] >> exitWith ExitSuccess (ForVersion,strLst) -> version >> exitWith ExitSuccess --strLst contains 3 strings: input file name, output, and parameters (OK,strLst) -> do inputstr <- readFile infile --get the content writeFile outfile (pgnjs inputstr params) --write the result exitWith ExitSuccess --exit where infile = (strLst !! 0) outfile = (strLst !! 1) params = (strLst !! 2) --(_,_) -> version >> exitWith (ExitFailure (-1)) ---------------- OPTIONS DESCRIPTION ---------------- -- OptionFlag is data OptionFlag = Version | Help | Output String | Input String deriving (Show, Eq) -- description of all options options :: [OptDescr OptionFlag] options = [ Option ['h', '?'] ["help"] (NoArg Help) ("show this help"), Option ['V'] ["version"] (NoArg Version) ("show version number"), Option ['i'] ["input"] (ReqArg Input "file") ("input file name"), Option ['o'] ["output"] (ReqArg Output "file") ("output file name") ] ------------------------------------------------------ -- this data describes the result of program work data ErrKey = OK | ForHelp | ForVersion | WrongOpts deriving (Show, Eq) ----------------------------------------------------------------------- -- input is a string of options and output is the result of the -- program. Actually, this is only a filter which filter all -- exceptional situation in option lists and then call a real function -- if list is good check_filter :: [String] -> ( ErrKey, [String] ) check_filter args = case (getOpt Permute options args) of (os, [], []) -> if (elem Help os) then (ForHelp,[]) else if (elem Version os) then (ForVersion, []) else if (not ((elem "-i" args) && (elem "-o" args)) ) then (WrongOpts, ["both -i and -o must be specified\n"]) -- we filtered now all exceptional situation else (OK, ["in.tmp","out.tmp",[]]) (os, fs, ers) -> (WrongOpts, []) -------------- OPTIONS EXCEPTIONAL FUNCTIONS ----------------- -- Version info version :: IO () version = putStrLn $ "Version 0.1.1a of October-November 2005" -- Usage short info: Output error line and usage usage :: String -> IO () usage errLine = putStr $ errLine ++ (usageInfo "Usage: shipgnjs [option...]" options) -- General info string genInfo :: IO () genInfo = putStrLn "shipgnjs (c) 2005 Anton Kulchitsky" {- This is the main function that operates on correct string: input: the first element is input pgn, the second line are parameters the output is html text for the result file -} pgnjs :: String -> String -> String pgnjs pgnstr params = map toUpper pgnstr ---- Thank you in advance, Anton Kulchitsky (a.k.a. atoku)

8 18

Summer of Code - Student Application Form
by Paolo Martini 02 May '06

02 May '06

Hi, it was just published the student application form, you can find it at: <http://code.google.com/soc/student_step1.html> I hope we will be collecting good Haskell applications from students :-) I am very happy to see how many did signed up on the People page as now: <http://hackage.haskell.org/trac/summer-of-code/> Keep on writing! Paolo. --

1 0