May 2006 - Haskell-Cafe

Parsec memory behavior
by Juan Carlos Arevalo Baeza 19 May '06

19 May '06

Try this simple program: import Text.ParserCombinators.Parsec ppAny = tokenPrim show (\p _ _ -> p) (\t -> Just t) ppTest = many ppAny p s = case runParser ppTest True "" s of Left error -> show error Right result -> result main = do let fname = "C:/main.i" f <- readFile fname let tokens = p f putStrLn . show $ head tokens This is the simplest expression of using Parsec, it just returns the input unchanged. But it already seems to have a big memory leak. When parsing a 2 MB file, I'm seeing the program grow in size up to about 160 MB before it ends. I assume this is known behavior. I believe it's because of the way Parsec deals with errors: when you chain two parsers in sequence, the result of the first one (in this case the head of the list) is not available until it knows if the second one failed or not. Is there any known alternative that doesn't exhibit this behavior? It would have to somehow return errors inline or on a "side channel". I'll be toying with this sort of thing for a while. Thanx! JCAB

4 5

shared local definitions
by Alberto Ruiz 19 May '06

19 May '06

Hi all, I have a question about optimization of shared values in local definitions. I frequently use this scheme: fun a b c d x = r where q = costly computation depending only on a, b, c, and d r = depends only on q and x g1 = fun 1 2 3 4 g2 = fun 5 4 2 7 (etc.) When I compute (using ghc -O) things like map g1 [1 .. 1000] the common q is evaluated only once, which is very nice. But the problem is that in some strange cases this kind of optimization is not applied, and the same q is evaluated 1000 times. Curiously, this happens if I add just: module Main where to one of my programs. Optimization is also lost if in the same program I use two partially applied functions: map g1 [1 .. 1000] map g2 [1 .. 1000] And in some cases optimization is only applied if the local definition is "easy" enough. For example: --------------------------------------------------- fun1 :: Int -> Int -> Int fun1 a x = q*x where q = {-# SCC "easy" #-} a+1+a^2 -- OK fun2 :: Int -> Int -> Int fun2 a x = q*x where q = {-# SCC "hard" #-} a+1+a^2 +a^3+(2*a) -- NO fun3 :: Int -> Int -> Int fun3 a x = r where q = local a r = q*x local u = {-# SCC "local easy" #-} u+1 -- OK fun4 :: Int -> Int -> Int fun4 a x = r where q = local a r = q*x local u = {-# SCC "local hard" #-} u+1+u^2 -- NO test h = print $ sum $ map h [1 .. 100] main = do test (fun1 3) test (fun2 3) test (fun3 3) test (fun4 3) -------------------------------------------------- COST CENTRE MODULE no. entries MAIN MAIN 1 0 main Main 154 101 fun4 Main 166 300 local hard Main 167 100 NO fun3 Main 163 100 fun2 Main 161 100 hard Main 162 100 NO fun1 Main 157 100 test Main 155 4 CAF Main 148 6 fun4 Main 168 0 main Main 158 0 fun3 Main 164 1 local easy Main 165 1 OK fun1 Main 159 0 easy Main 160 1 OK test Main 156 0 CAF System.IO 103 1 CAF GHC.Handle 101 3 ------------------------------------------------------------ Where can I find information about this topic? I have made some searches but probably using wrong keywords. Should I use some individual optimization flags? Thanks, Alberto

4 3

Controlling scope using monadic classes
by oleg＠pobox.com 18 May '06

18 May '06

Daniel McAllansmith wrote: > I'm trying to control the scope within which functions can be used by > putting them in a type class. Unfortunately I can't seem to figure > out how to get it done. Any advice would be much appreciated. Hopefully the following is close to what you wanted. The idea is to describe each appropriate function (like getInfo) with a label and to identify each monadic scope with a label, and then define the relationship which tells which labeled functions can be used within which scopes. If we attempt to obtain InfoC within the scope B, we get an error ``no instance (LabelOK ScopeC ScopeB)'' -- which seems clear. The more elaborate version of similar example can be found here: http://pobox.com/~oleg/ftp/Haskell/types.html#monadic-regions Using labels to enforce well-formedness term constraints (content model constraints for HTML/XML terms) can be found here: http://www.haskell.org/pipermail/haskell/2006-March/017656.html http://www.haskell.org/pipermail/haskell/2006-March/017684.html {-# OPTIONS -fglasgow-exts #-} module Scopes where import Control.Monad.Trans -- Our scopes newtype ScopeA m a = ScopeA{runScopeA :: m a} deriving (Monad, MonadIO) newtype ScopeB m a = ScopeB{runScopeB :: m a} deriving (Monad, MonadIO) newtype ScopeC m a = ScopeC{runScopeC :: m a} deriving (Monad, MonadIO) runScopeBA (ScopeB x) = ScopeA x runScopeCB (ScopeC x) = ScopeB x -- The deriving Show part is just to make the example better instance Show (ScopeA m a) where show _ = "ScopeA" instance Show (ScopeB m a) where show _ = "ScopeB" instance Show (ScopeC m a) where show _ = "ScopeC" -- Here we define the relationship that tells which labeled functions -- (identified by label') can appear within which scope (identified by label) class LabelOK (label' :: ( * -> * ) -> * -> * ) (label :: ( * -> * ) -> * -> * ) -- If we use overlapping isntances extension, the number of instances -- below can be significantly reduced. instance LabelOK ScopeA ScopeA instance LabelOK ScopeA ScopeB instance LabelOK ScopeA ScopeC instance LabelOK ScopeB ScopeB instance LabelOK ScopeB ScopeC instance LabelOK ScopeC ScopeC -- The function getInfo is labeled. The constraint LabelOK tells -- the the function can be used within any (monadic) scope where -- it is OK... getInfo :: (Monad m, Monad (label m), Show (label' [] ()), LabelOK label' label) => label' [] () -> label m String getInfo l = return (show l) -- The latter functions are to be defined analogously -- putInfo :: LabelOK label' label => label' -> String -> m () -- updateInfo :: UpdateOK label' label => label' -> Int -> m () main = runScopeA aScoped >>= print aScoped = do bResult <- runScopeBA bScoped -- updateAInfo bResult return "done" -- Inferred type: bScoped :: ScopeB IO Int bScoped = do i1 <- b1 i2 <- b2 return (i1 + i2) b1 :: (Monad m, MonadIO m) => ScopeB m Int b1 = do -- Within B scope, we can request AInfo and BInfo getInfo (ScopeA [()]) >>= liftIO . print getInfo (ScopeB [()]) >>= liftIO . print -- But we can't request CInfo -- If we uncomment the following, we get -- no instance (LabelOK ScopeC ScopeB) -- I think the error message is quite clear -- getInfo (ScopeC [()]) >>= liftIO . print return 2 b2 :: (Monad m, MonadIO m) => ScopeB m Int b2 = runScopeCB cScoped >>= return . fromEnum cScoped :: (Monad m, MonadIO m) => ScopeC m Char cScoped = do -- Within C scope, we can request AInfo and BInfo and CInfo getInfo (ScopeA [()]) >>= liftIO . print getInfo (ScopeB [()]) >>= liftIO . print getInfo (ScopeC [()]) >>= liftIO . print return '('

2 1

Haskell DB and XML libs: one user's experience
by Robert Dockins 18 May '06

18 May '06

Hello all, I recently found myself needing to do some data manipulation; I needed to take some data from a database and generate a series of XML files from it. In the past I've done most of this sort of work in Java, but this time I decided I'd take the opportunity to explore the state of the art of Haskell DB and XML libraries. As to DB, I tried using HDBC first. I was actually a little surprised how straightforward it was. My database (PostgreSQL) is directly supported, and the compile/install went smoothly. My first test connection program that typechecked worked as expected (!) and I was soon executing queries doing useful work with the results. I'd just like to take a moment to congratulate John Goerzen for creating a product with a low barrier of entry for using databases in Haskell. As I didn't really do anything beyond simple queries, can't comment on more advanced features. For XML, I wavered between HaXml and HXT (the Haskell XML Tookbox). I initially decided to use HXT because it has support for xml namespaces, which I was going to need, and because it just seems to be the most complete and advanced package available. The HXT install suffers a little bit from transitive-closureitis, but, overall wasn't too bad. However, I had a really hard time using it! The API is _really_ intimidating, and I couldn't find any basic tutorial-style documentation. The API docs are a little hard to use because related definitions are spread out over a bunch of modules, and the links don't always work. Also, the theses are nice, but they read like theses ;-) That's not what I want when I have a job to complete. Long story made short; I couldn't figure out how to create and XML document and serialize it to disk. I was reasonably motivated and I'm a pretty experienced Haskell programmer, but I had to call it quits after about 3 hours of struggling with it. Most of my programs would mysteriously fail to produce output OR errors! It was really frustrating. I ended up using HaXml instead and shoehorning in the namespaces by using attributes named "xmlns:xyz" etc. on the document root element (which is OK, but not ideal). The HaXml API was also tough to work with but was less mystifying than HXT's, and I eventually got it to work. I was a little disappointed by the results, because the pretty printer does some fairly bizarre things to ensure that it doesn't introduce extra whitespace into the DOM. I also had to do some futzing to make HaXml correctly escape literal text. Finally, the using the HaXml API to generate XML results in verbose code that's hard to read. I was hoping that I'd get results comparable to using xmlenc (http://xmlenc.sourceforge.net/) in Java, but I was disappointed by fairly low signal-to-noise ratio (although in all fairness, its probably comparable to using the DOM or SAX Java APIs). Overall, HaXml works, but feels a bit awkward, at least for this use case. Now taking a slightly closer look at HXML, I see that it may be the best choice for what I was attempting to do (although it also doesn't support namespaces). The simplified representation looks particularly nice for building XML from scratch. I may try rewriting with HXML and see how that goes. So that's it. I don't have any deep conclusions, but I thought I'd share my experiences in the hopes that they will be helpful to somebody. Rob Dockins Speak softly and drive a Sherman tank. Laugh hard; it's a long way to the bank. -- TMBG

2 1

RE: [Haskell-cafe] develop new Haskell shell?
by Bayley, Alistair 17 May '06

17 May '06

> From: haskell-cafe-bounces(a)haskell.org > [mailto:haskell-cafe-bounces@haskell.org] On Behalf Of Graham Klyne > > Did you see [http://nellardo.com/lang/haskell/hash/] ? > > Google also finds some links to code. > > #g > -- > > Marc Weber wrote: > > Hi. > > > > Who wants to try devloping a new shell with me? Also: http://www.cse.unsw.edu.au/~dons/h4sh.html ***************************************************************** Confidentiality Note: The information contained in this message, and any attachments, may contain confidential and/or privileged material. It is intended solely for the person(s) or entity to which it is addressed. Any review, retransmission, dissemination, or taking of any action in reliance upon this information by persons or entities other than the intended recipient(s) is prohibited. If you received this in error, please contact the sender and delete the material from any computer. *****************************************************************

14 24

Controlling scope using monadic classes
by Daniel McAllansmith 17 May '06

17 May '06

Hi. I'm trying to control the scope within which functions can be used by putting them in a type class. Unfortunately I can't seem to figure out how to get it done. Any advice would be much appreciated. What I want is to start out in a certain scope, which restricts me to using functions in that scope or opening up a subsidiary scope at which point I'm restricted to functions in that scope or opening up an even deeper scope. Hopefully a failed attempt will help explain what I'm trying to achieve... the following has trouble with the inScope{B,C} functions. type AInfo = String type BInfo = String type CInfo = String type BResult = Int type CResult = Char class (Monad m) => WithinA m where askAInfo :: m AInfo class (WithinA m) => WithinB m where askBInfo :: m BInfo class (WithinB m) => WithinC m where askCInfo :: m CInfo class (WithinA m) => ScopeA m where getAInfo :: m AInfo putAInfo :: AInfo -> m () updateAInfo :: BResult -> m () inScopeB :: (ScopeB m2) => m2 BResult -> m BResult class (WithinB m) => ScopeB m where getBInfo :: m BInfo putBInfo :: BInfo -> m () inScopeC :: (ScopeC m2) => m2 CResult -> m CResult class (WithinC m) => ScopeC m where getCInfo :: m CInfo putCInfo :: CInfo -> m () aScoped :: (ScopeA m) => m String aScoped = do bResult <- inScopeB bScoped updateAInfo bResult return "done" bScoped :: (ScopeB m) => m BResult bScoped = do i1 <- b1 i2 <- b2 return (i1 + i2) b1 :: (ScopeB m) => m Int b1 = return 2 b2 :: (ScopeB m) => m Int b2 = inScopeC cScoped >>= return . fromEnum cScoped :: (ScopeC m) => m Char cScoped = return '(' Thanks Daniel

1 0

transactional cache
by Alberto G. Corona 16 May '06

16 May '06

Finally i did it. The transactional cache uses STM, no blocking MVars. I created has a simple interface, the transactional "plumbing" is hidden in the TransactCacheSTM module. The usage is simple: withResources [object1, object2,..] process where process[maybeObject1,maybeObject2.....]= [newObject1,newObect2...] newObject1=..... newObject2=.... "process" run atomically, object1,object2.. are partially defined, just with the fields neccesary to retrieve them. newObjects are the resulting objects that replace the previous content in the cache. Non existing objects are created. the objects must implement "IResource" type class procedures for reading, writing and obtaining a unique key so that the objects can be read to, write from and do search from the cache. No other asumptions are made about the object types or storages. In the following example, client Alberto buy a computer. the total amount due by Alberto is increased with the computer price. The quantity of the item "computer" in stock is decreased. withResources[Client{name="Alberto"}, Item{iname="computer"} buy where buy[Nothing,_]= error "Client does not exist" buy[_,Nothing]= error "Item does not exist" buy[Just client, Just item]= [client{total client=total client+ price item}, item{quantity=quantity-1}] The resulting code is transactional and clean. The object is read if not already in the cache using the user defined procedure for that object (either a sql query or read from a file). The write is delayed depending on object usage in the cache and the cache size. I also defined ordinary, non transactional object retrieval (getResources :: [Resource]->IO[Resource] ) To have real ACID transactions, I also defined a procedure for atomic write of the entire cache to disk, in order to have coherent content in permanent storage, (I´m using it on a portal 100% coded in Haskell (I love Haskell since i knew it five months ago). this trhansactional cache makes the data handling in my portal a lot easier. I use XML files, no boring database tables are necessary. I will put online the transactional cache sometime later, but by now I will send te code by mail to anyone interested. Message: 8 Date: Sat, 13 May 2006 12:26:42 +0900 From: "Evan Martin" <martine(a)danga.com> Subject: Re: [Haskell-cafe] RE: transactional cache To: "Alberto G. Corona" <agocorona(a)gmail.com> Cc: haskell-cafe(a)haskell.org Message-ID: <3a6f89fc0605122026y6727d55cl61e60a101c73e93e(a)mail.gmail.com> Content-Type: text/plain; charset=ISO-8859-1; format=flowed On 5/13/06, Alberto G. Corona <agocorona(a)gmail.com> wrote: > > notglobal = newIORef True > > main = do a <- notglobal > > b <- notglobal > > Thanks. I got the poit more or less; Each invocation creates a new > IORef instance. Another way of looking at this, that might be more instructive, is that notglobal is defined to be the action of creating a new IO ref. You can see that in its type: > :t newIORef True newIORef True :: IO (IORef Bool) I read that type as "an IO operation that produces an IORef Bool when executed". Then the code in main "executes" notglobal twice. Another way of looking at this is that you can always substitute the right side of an equals sign in for the left side. If you do that on this code this makes it plain that a and b will be different. (unsafePerformIO breaks this substitution rule.)

1 0

Newbie:Debugging and Overgeneralization
by Aditya Siram 15 May '06

15 May '06

I have been working with a Haskell text for the past couple of months or so and I have some general problem solving questions. 1. Is there a way to output intermediate values of a calculation? As an imperative programmer I have become used to using "System.out"'s or 'cout's to check that my function works as intended. I can see no easy way to do that in Haskell. The only solution I could come up with was to avoid using nested functions except for the most trivial expressions and test all expressions in the interpreter. This approach seems to make my code ugly and less readable. 2. Haskell is great because it makes abstracting from problem very easy. For example, if the problem asks for the area of a square, why not write a function to compute the area of all polygons? find myself falling into the trap of generalizing to the point that a simple problem becomes quite a bit harder . From a general design perspective should I concentrate on abstracting away just enough to solve the problem or solve the harder problem in the hoping of reusing that code to make life easier in the future? Thanks.... Deech

3 2

dumb monad syntax question
by mvanier 15 May '06

15 May '06

I've been reading Phil Wadler's monad papers from the early '90s, and it's been interesting to see how the monad concept evolved over the course of those years. But I haven't been able to track down the first use of the "do" notation for monads. Can anyone tell me where that came from? I'd appreciate paper citations if it was presented initially in a paper. Thanks in advance, Mike

4 3

Linspire/Freespire Core OS Team and Haskell
by Clifford Beshers 15 May '06

15 May '06

The OS team at Linspire, Inc. would like to announce that we are standardizing on Haskell as our preferred language for core OS development. We are redoing a bunch of our infrastructure using Haskell as our common standard language. Our first task is redoing our Debian package builder (aka autobuilder) in Haskell. Other tools such as ISO builders, package dependency checkers are in progress. The goal is to make a really tight simple set of tools that will let developers contribute to Freespire, based on Debian tools whenever possible. Our hardware detector, currently in OCaml, is on the block to be rewritten as well. There are four of us using Haskell, all CCed on this message. All of us have been using functional languages for quite some time. At Linspire, our choices have been OCaml and Haskell. David Fox wrote the hardware detector in OCaml and is now porting it to Haskell. Jeremy Shaw has been doing various utilities in Haskell for several years. Sean Meiners recently wrote an application for managing his recipe collection and is now hooked. I am porting our CD build procedure from OCaml to Haskell. We are interested in many other uses of Haskell. The recent discussion about Haskell as a shell interests greatly, for example, as we have all suffered through years of bash code. We'd also like to make some Haskell bindings for Qt and KDE, though at the moment we don't have a good plan to tackle that problem efficiently. To date, Linspire (formerly Lindows) has focused on polishing Linux for the consumer market. I mentioned Freespire, above. We announced Freespire recently (www.freespire.org) Essentially it is a more open, developer friendly version of Linspire. http://freespire.org/about/vision and http://freespire.org/support/faqs have good overviews. Access through apt, open-source CNR client and many other good things. I mention Freespire because some of our colleagues were concerned that using Haskell would isolate us from the larger community of developers and make it hard to find new employees skilled in Haskell, should we need to. From our perspective, functional programming makes us more effective and we think that getting even a few people who know Haskell hacking with us is a better combination than lots of Perl and bash. I'm not sure I expect anyone on this list to disagree, but still I'd love to hear your thoughts on the subject. Also, Linspire is based on Debian. We've talked a little with John Goerzen who announced his missingH library here a while back. We've imported it and expect to pass updates back to him as well as any other libraries and tools that he would be interested in includng in the Debian archive. Also, it seems there are quite a few other libraries out there which are either not debianized or stale. We are looking into helping the folks on the debian-haskell list with that, if possible, documenting and automating wherever possible. Clifford Beshers <clifford.beshers(a)linspire.com> OS Team Lead Linspire, Inc. (I'm subscribed to this list from my personal account. Feel free to use either address.)

2 1