- Haskell-Cafe - Haskell.org

ANN: BNFC-meta-0.1.0
by Jonas Almström Duregård 22 Sep '10

22 Sep '10

I'm pleased to announce BNFC-meta-0.1.0! BNFC-meta can take a quasi-quoted LBNF grammar (as used by the BNF Converter) representation of a language and generate (using Template Haskell) a number of wonderful tools for dealing with this language, including: * Abstract syntax types * Lexer * LALR Parser * Pretty-printer * Quasi-quoter Apart from the quasi-quoter, these are all features of the BNF Converter, but grammars can now be embedded directly into Haskell modules. Here's an example of a small subset of C: \begin{code} {-# LANGUAGE QuasiQuotes #-} module MiniLanguage where import Language.LBNF -- 'Compile' is a Template Haskell function, 'cf' is a QuasiQuoter. compile [$cf| antiquote "[" ":" ":]" ; Fun. Prog ::= Typ Ident "(" ")" "{" [Stm] "}" ; SDecl. Stm ::= Typ Ident ";" ; SAss. Stm ::= Ident "=" Expr ";" ; SIncr. Stm ::= Ident "++" ";" ; SWhile. Stm ::= "while" "(" Expr ")" "{" [Stm] "}" ; ELt. Expr0 ::= Expr1 "<" Expr1 ; EPlus. Expr1 ::= Expr1 "+" Expr2 ; ETimes. Expr2 ::= Expr2 "*" Expr3 ; EVar. Expr3 ::= Ident ; EInt. Expr3 ::= Integer ; []. [Stm] ::= ; (:). [Stm] ::= Stm [Stm] ; _. Stm ::= Stm ";" ; _. Expr ::= Expr0 ; _. Expr0 ::= Expr1 ; _. Expr1 ::= Expr2 ; _. Expr2 ::= Expr3 ; _. Expr3 ::= "(" Expr ")" ; TInt. Typ ::= "int" ; comment "/*" "*/" ; comment "//" ; |] \end{code} And here is a module that uses it: \begin{code} {-# LANGUAGE QuasiQuotes #-} import MiniLanguage import Language.LBNF(pp) -- overloaded pretty-printing function import Prelude hiding (exp) power :: Ident -> Integer -> Prog power var x = [$prog| // This quoter accepts C-style comments int myPower() { int tmp; tmp = 0; // Things in [: :] are anti-quoted Haskell expressions. [: repeatWhile (Ident "tmp") x mult :] } |] where -- [X:haskell:] means the anti-quoted expression represents non-terminal X, -- Used to resolve ambiguities (in this case between Ident/Expr/Integer). mult = [$stm| [:var:] = [Ident:var:] * [Ident:var:] ; |] -- Repeats a statement n times. (at least if variable var is 0... ) repeatWhile var n statement = [$stm| while ([Ident:var:] < [:n:]) { [Stm:statement:] [:var:] ++ ; }|] pr = power (Ident "n") 10 main = putStr $ pp pr \end{code} There are a few more examples in the source tarball. More documentation on these features will be supplied eventually :) Best regards, Jonas

1 0

ANNOUNCE: http-enumerator 0.0.0
by Michael Snoyman 22 Sep '10

22 Sep '10

Hi all, I'd like to announce the first release of http-enumerator[1], an HTTP client package with support for HTTPS connections. This release is very experimental; bug reports and API feedback are very welcome. In addition to providing built-in HTTPS support, this package also attempts to improve upon current offerings by offering a very simple API, being built on bytestrings by default, and using the enumerator package to allow efficient parsing of response bodies. I've also put up a blog post[2] giving some more motivation and future goals for those interested. Michael [1] http://hackage.haskell.org/package/http-enumerator [2] http://docs.yesodweb.com/blog/announcing-http-enumerator/

4 4

Cleaning up threads
by Mitar 22 Sep '10

22 Sep '10

Hi! I run multiple threads where I would like that exception from any of them (and main) propagate to others but at the same time that they can gracefully cleanup after themselves (even if this means not exiting). I have this code to try, but cleanup functions (stop) are interrupted. How can I improve this code so that this not happen? module Test where import Control.Concurrent import Control.Exception import Control.Monad thread :: String -> IO ThreadId thread name = do mainThread <- myThreadId forkIO $ handle (throwTo mainThread :: SomeException -> IO ()) $ -- I want that possible exception in start, stop or run is propagated to the main thread so that all other threads are cleaned up bracket_ start stop run where start = putStrLn $ name ++ " started" stop = forever $ putStrLn $ name ++ " stopped" -- I want that all threads have as much time as they need to cleanup after themselves (closing (IO) resources and similar), even if this means not dying run = forever $ threadDelay $ 10 * 1000 * 1000 run :: IO () run = do threadDelay $ 1000 * 1000 fail "exit" main :: IO () main = do bracket (thread "foo") killThread $ \_ -> bracket (thread "bar") killThread $ \_ -> bracket (thread "baz") killThread (\_ -> run) Mitar

11 25

Cabal-install prefix
by N. Raghavendra 22 Sep '10

22 Sep '10

I am new to Haskell, and am trying to install a package (scan) using cabal-install. I want it to install all files under the directory ${HOME}/nonvc, like in ~/nonvc/share and ~/nonvc/bin. So I specified install-dirs user -- prefix: /home/raghu/nonvc in ~/.cabal/config. But when I do `cabal install scan', it still installs the files in ~/.cabal/bin and ~/.cabal/share. How do I make cabal install these files in ~/nonvc? Thanks and regards, Raghavendra. -- N. Raghavendra <raghu(a)mri.ernet.in> | http://www.retrotexts.net/ Harish-Chandra Research Institute | http://www.mri.ernet.in/ See message headers for contact and OpenPGP information.

2 2

ANN: Copilot 0.22 -- A stream DSL for writing embedded C.
by Lee Pike 22 Sep '10

22 Sep '10

Announcing Copilot 0.22: Can you write a list in Haskell? Then you can write embedded C code using Copilot. Here's a Copilot program that computes the Fibonacci sequence (over Word 64s) and tests for even numbers: fib :: Streams fib = do "fib" .= [0,1] ++ var "fib" + (drop 1 $ varW64 "fib") "t" .= even (var "fib") where even :: Spec Word64 -> Spec Bool even w = w `mod` const 2 == const 0 Copilot contains an interpreter, a compiler, and uses a model-checker to check the correctness of your program. The compiler generates constant time and constant space C code via Tom Hawkin's Atom[1] (thanks Tom!). Copilot was originally developed to write embedded monitors for more complex systems, but it can be used to develop a variety of embedded code. HACKAGE: http://hackage.haskell.org/package/copilot WEBPAGE: http://leepike.github.com/Copilot/ (with more info). PICS/VIDEO of Copilot's maiden flight: http://picasaweb.google.com/105722675808588603973 A PAPER (PDF): http://www.cs.indiana.edu/~lepike/pub_pages/rv2010.html The Copilot Team * Maintainer: Lee Pike (leepike(a)galois.com) Galois, Inc. * Alwyn Goodloe, National Institute of Aerospace * Robin Morisset, École Normale Supérieure * Sebastian Niller, Technische Universität Ilmenau [1] http://hackage.haskell.org/package/atom

4 5

Ultra-newbie Question
by Christopher Tauss 22 Sep '10

22 Sep '10

Hello Haskell Community - I am a professional programmer with 11 years experience, yet I just do not seem to be able to get the hang of even simple things in Haskell. I am trying to write a function that takes a list and returns the last n elements. There may be a function which I can just call that does that, but I am trying to roll my own just to understand the concept. Let's call the function n_lastn and, given a list [1,2,3,4,5], I would like n_lastn 3 = [3,4,5] Seems like it would be something like: n_lastn:: [a]->Int->[a] n_lastn 1 (xs) = last(xs) n_lastn n (x:xs) = ???? The issue is I do not see how you can store the last elements of the list. Thanks in advance. ctauss

17 24

asymmetric runtimes for symmetric trees
by Daniel Seidel 21 Sep '10

21 Sep '10

Hi, I'm having a tree data type data Tree a = Leaf a | Fork (Tree a) (Tree a) , a generator for the left-most path of the tree, taking the depth leftPath :: Int -> Tree Int leftPath d | d > 1 = Fork (leftPath (d-1)) (Leaf 1) | d == 1 = (Leaf 1) | otherwise = error "Can't make tree of depth <= 0." and the similar thing for a right-most path rightPath :: Int -> Tree Int rightPath d | d > 1 = Fork (Leaf 1) (rightPath (d-1)) | d == 1 = (Leaf 1) | otherwise = error "Can't make tree of depth <= 0." Now I measured how long it takes to build a huge tree via print $ sumLeafs $ leftPath 1000000 and print $ sumLeafs $ rightPath 1000000 as main functions where sumLeafs (Fork l r) = sumLeafs l + sumLeafs r sumLeafs (Leaf i) = i Compiling without optimisation and running with no extra runtime options, besides -K50M to make available enough stack, yields on my machine (measured via time) that for leftPath the runtime is 3.8s, for rightPath 2.9s. If I optimize with -O2 runtimes decrease to approx. 1s / 0.8s, meaning the difference is still there. Using the -sstderr runtime option shows that (also with the runtime option -H2.5G) garbage collection for the leftPath case takes always slightly longer than for the rightPath case. Can anyone explain why there is that difference? Cheers, Daniel. PS: Here the programs as one block: ---LeftPath.hs module Main where data Tree a = Leaf a | Fork (Tree a) (Tree a) leftPath :: Int -> Tree Int leftPath d | d > 1 = Fork (leftPath (d-1)) (Leaf 1) | d == 1 = (Leaf 1) | otherwise = error "Can't make tree of depth <= 0." sumLeafs (Fork l r) = sumLeafs l + sumLeafs r sumLeafs (Leaf i) = i main = print $ sumLeafs $ leftPath 1000000 ---RightPath.hs module Main where data Tree a = Leaf a | Fork (Tree a) (Tree a) rightPath :: Int -> Tree Int rightPath d | d > 1 = Fork (Leaf 1) (rightPath (d-1)) | d == 1 = (Leaf 1) | otherwise = error "Can't make tree of depth <= 0." sumLeafs (Fork l r) = sumLeafs l + sumLeafs r sumLeafs (Leaf i) = i main = print $ sumLeafs $ rightPath 1000000

2 2

Re: ANNOUNCE: GotoT-transformers version 1.0
by oleg＠okmij.org 21 Sep '10

21 Sep '10

Let us look at GoTo from several angles: (un)delimited continuations, exceptions and trampolines. Gregory Crosswhite wrote regarding the definition goto (ContT m) = ContT $ \_ -> m return > *HOWEVER*, if we replace main with > > main = runContT myComp (const $ putStrLn "I can't wait to print > this string!") > > Then the program will be eternally disappointed because it will never > actually get to print that string at the end [if goto had been used] > > it just seems to me like at that point the spirit of the > continuation monad is being violated since the final continuation is > never actually called. That isn't necessarily a big deal, but it is the > kind of behavior that could bite someone if they weren't aware or forgot > about it. Let us start by looking at the problem from the point of view of undelimited continuations. Although that is not my preferred one, it could be instructive. An undelimited continuation -- the kind that is typically associated with call/cc -- has no ``final continuation'' to run at the end. There is no end. The value produced by the undelimited continuation can never be used by the program itself, because by the time that value is produced the program shall be dead. It may help to think of the return value of an undelimited continuation as the value produced when a computer crashes or the universe ends. Therefore the type ContT from mtl or MonadLib is not a good model of undelimited continuations. Better is the following > data Falsum -- it doesn't exist > > type K m a = a -> m Falsum -- NOT a, or the continuation from a > > newtype ContT m a = ContT{unC:: K m a -> m Falsum} -- NOT NOT a > > > instance Monad m => Monad (ContT m) where > return x = ContT $ \k -> k x > m >>= f = ContT $ \k -> unC m (\v -> unC (f v) k) > > instance (Monad m, MonadIO m) => MonadIO (ContT m) where > liftIO m = ContT $ \k -> liftIO m >>= k > > callCC :: (K m a -> ContT m a) -> ContT m a > callCC f = ContT (\k -> unC (f k) k) Given such ContT, the original goto expression would not type: goto :: (Monad m) => ContT m () -> ContT m a goto (ContT m) = ContT $ \_ -> m return Couldn't match expected type `()' against inferred type `Falsum' If we drop the type annotation, the goto will type, but the argument computation will be assigned the type ContT m Falsum. There can be no non-divergent computation with that type. That typing failure points to the problem with the definition: the argument of goto was a ContT computation that expects a continuation. We supplied `return' -- assuming that was the `initial, or system' continuation. That is, we assumed that the corresponding runContT indeed supplied `return' as the initial continuation. If runContT supplied something else, we run into inconsistency. Thus the correct definition of goto, in the current approach, instead of guessing the continuation to abort it, should ask the user. We obtain the following definition > goto :: Monad m => K m () -> ContT m () -> ContT m a > goto k (ContT m) = ContT (\_ -> m k) We need a way to obtain the continuation to pass to goto. That's where callCC comes in handy: > myComp :: ContT IO () > myComp = callCC $ \k0 -> do > input <- liftIO $ putStrLn "Print something (y/n)?" >> getLine > unless ("y" `isPrefixOf` input) $ goto k0 exit > liftIO $ putStrLn "Something." > > input <- liftIO $ putStrLn "Print more (y/n)?" >> getLine > unless ("y" `isPrefixOf` input) $ goto k0 exit > liftIO $ putStrLn "More." > > where > exit = liftIO $ putStrLn "Ok, I'm exiting." A reader must have been wondering since five paragraphs ago about running ContT computations. Ideally, there should be no runContT -- as there is no runIO. Since we can't change the behavior of `main' or add a similarly distinguished `mainCont', we have to find a continuation to supply to our ContT computation -- the continuation from the present state till the end of the universe. That seems problematic. Fortunately, cheating is always an option: > data FinalExit = FinalExit deriving (Show, Typeable) > instance Exception FinalExit > > main :: IO () > main = do > handle (\FinalExit -> return ()) > (unC myComp (\() -> putStrLn "At the end" >> throw FinalExit) >> > error "unreachable") The string "At the end" is printed at every end, caused by goto or the normal termination. Although the program type-checks and runs with the expected behavior, it seems quite contrived. Our goto only skips a prefix of the current continuation, from the current point to some definite point in the program, marked by `handle' or runContT, etc. We don't make any essential use of undelimited continuations. In fact, I am yet to see any practical use for undelimited continuations. Delimited continuations are much more useful. The monad ContT of mtl or MonadLib is the monad for simple delimited continuations; runContT is the delimiter, and (\m -> lift $ runContT m return) is the reset. Our example makes a special use of delimited continuations: we capture the continuation from the current point till the main point, and throw it away. That pattern is called abort, and it undelies exceptions. We immediately obtain the following simplified implementation: > data GoTo = GoTo deriving (Show, Typeable) > instance Exception GoTo > > goto :: IO () -> IO a > goto m = m >> throw GoTo > > myComp :: IO () > myComp = do > input <- putStrLn "Print something (y/n)?" >> getLine > unless ("y" `isPrefixOf` input) $ goto exit > putStrLn "Something." > > input <- putStrLn "Print more (y/n)?" >> getLine > unless ("y" `isPrefixOf` input) $ goto exit > putStrLn "More." > > where > exit = putStrLn "Ok, I'm exiting." > > > main :: IO () > main = do > handle (\GoTo -> return ()) myComp > putStrLn "At the end" There is no longer any need in the ContT monad transformer: IO supports exceptions natively. The solution exhibits a well-known memory leak. Consider do x <- make_huge_value goto long_running_computation return x While long_running_computation keeps running, the value x is being referenced from the stack and cannot be garbage collected. There is a well-known solution to the problem: trampolining. We abort first and then run the goto computation. This leads us to the final solution: {-# LANGUAGE DeriveDataTypeable #-} module C2 where import Data.List import Control.Monad import Control.Exception import Data.Typeable data GoToIt = GoToIt (IO ()) deriving (Typeable) instance Show GoToIt where show _ = "Trampoline" instance Exception GoToIt goto :: IO () -> IO a goto m = throw (GoToIt m) myComp :: IO () myComp = do input <- putStrLn "Print something (y/n)?" >> getLine unless ("y" `isPrefixOf` input) $ goto exit putStrLn "Something." input <- putStrLn "Print more (y/n)?" >> getLine unless ("y" `isPrefixOf` input) $ goto exit putStrLn "More." where exit = putStrLn "Ok, I'm exiting." main :: IO () main = do handle_it myComp putStrLn "At the end" where handle_it m = handle (\(GoToIt m) -> handle_it m) m

1 0

[ANN] Crypto-API 0.1.0.0
by Thomas DuBuisson 21 Sep '10

21 Sep '10

Crypto-API is a project aimed at unifying algorithm developers and users by presenting a uniform typeclass interface to low level algorithms and providing generalized helper functions for the (slightly) higher-level interactions needed by crypto-users. The main features are typeclasses (hash, cipher, signing and RNG), block cipher modes, platform independent entropy/seed acquisition, padding, testing and benchmarking. This release represents a fleshing out of the testing infrastructure, addition of padding mechanisms, and a reduction in build dependencies. In particular, I want to encourage package maintainers of TwoFish, AES, and SHA* algorithms to use the included test infrastructure - examples can be found on the homepage. == Project Management == Homepage: http://trac.haskell.org/crypto-api/wiki Bug trac: http://trac.haskell.org/crypto-api/report/1 Repo: http://code.haskell.org/crypto-api/ == API Removals == * Test.ParseNistKATs doesn't use Parsec and has a barebones interface. * Crypto.Random does not export "AsRG" or "Splittable" (see change log, 'random' build dep removed) == API Additions == * class Signing p v | p -> v, v -> p where ... * instance Monad (Either GenError) where ... * cereal >= 0.2 && < 0.4 (was == 0.2.*) * Testing ** Tests are split from Test.Crypto ** SHA, HMAC tests are new and from NIST CAVP KATs ** AES CFB128 mode KATs ** TwoFish NIST KATs ** Cipher property tests included (enc . dec ~ id, and many mode specific tests) * Crypto.Padding is included with PKCS5 and ESP padding methods. * "blockSizeBytes" helper function is now included == Build Dependencies == While I've never had objections to dependencies (this is what cabal is for and removing unused code is what GHC+linkers are for), I feel this is a good minimum and hope others agree. Some potential users made noise about having both Binary and Cereal and just the number of deps in general. * deps removed: binary, parsec, random (and indirectly: time, old-locale) * deps remaining: base, tagged, bytestring, cereal, filepath, directory * indirect deps remaining: data-default, containers, arrays To reiterate, the only deps above a normal GHC baseline are tagged, cereal, and data-default. CHANGE LOG (since 0.0.0.2) * Add 'Signing' class. * Tests showing the strict and lazy Crypto.Modes functions are eq * Basic BlockCipher property tests (enc . dec ~ id) * Enable tests for CFB128 * Added ESP and PCKS5 padding * add a 'blockSizeBytes' helper * TwoFish KATs * Bump 'cereal' version bound to include 0.3 * instance Monad (Either GenError) -- that was an obvious oversight * Remove the 'binary' dep. (cereal makes more sense and can be leveraged in Binary.{Get,Put} routines). * Removed the 'parsec' dep, which was only needed for Test.* but not even that now. * Updated the CPP tests for Windows in System.Random.Crypto (still need a tester) * Fixed up the testing infrastructure. Algorithms now use separate modules (Test.SHA, Test.HMAC, Test.AES). more NIST KATs included: ~1000 SHA tests, hundreds of SHA HMAC tests. * Fixed ugly bug for HMACs using keys > blockSize (eep! Obvious interop problem, but there was no-less security in the hmac result) * Removes the 'random' dep and by extension removes indirect deps on time and old-locale. Random was only used to provide trivial lifting of a newtype wrapped CryptoRandomGen instances into the RandomGen class, which was of questionable sense in the first place. == TODO == * Improve benchmarking infrastructure ** Improved reporting ** Benchmark modes and other higher-level functions, but in a generic way ** Benchmark asymmetric algorithms * Optimize block cipher modes * Statistical RNG tests * Portability testing (Mac, Windows testing needed) Cheers, Thomas

1 0

Re: Ultra-newbie Question
by Henrique Becker 21 Sep '10

21 Sep '10

Why not? import Data.Number.Nat as N lastN :: Integral b => b -> [a] -> [a] lastN n xs = N.drop (N.length xs - n') xs where n' = N.toNat n Not import Prelude maybe make more clear. []'s Henrique Becker

2 3

Do expression definition
by Alexander Kotelnikov 21 Sep '10

21 Sep '10

Hello. http://www.haskell.org/onlinereport/exps.html#sect3.14 a obscure (to me) note which says "As indicated by the translation of do, variables bound by let have fully polymorphic types while those defined by <- are lambda bound and are thus monomorphic." What actually does it mean? And, also, would it make any difference if do {p <- e; stmts} = let ok p = do {stmts} ok _ = fail "..." in e >>= ok is redefined as "e >>= (\p -> do {stmts})"? Thanks, Alexander

9 16

OpenGL Speed!
by Eitan Goldshtrom 20 Sep '10

20 Sep '10

I'm having an unusual problem with OpenGL. To be honest I probably shouldn't be using OpenGL for this, as I'm just doing 2D and only drawing Points, but I don't know about any other display packages, so I'm making due. If this is a problem because of OpenGL however, then I'll have to learn another package. The problem is speed. I have a list of points representing the color of 800x600 pixels. All I'm trying to do is display the pixels on the screen. I use the following: renderPrimitive Points $ mapM_ display list flush where display [] = return () display ((x,y,i):n) = do color $ Color3 i i i vertex $ Vertex2 x y display n But, for some reason this takes FOREVER. I don't know how to use debugging hooks yet without an IDE -- and I don't use an IDE -- but I used a cleverly placed putStrLn to see that it was actually working, just really really slowly. Is there a solution to this speed problem or should I use a package that's more suited to 2D applications like this? Also, if I should use another package, are there any suggestions for which to use? Thanks for any help. -Eitan

11 14

ANNOUNCE: text 0.9.0.0 and text-icu 0.4.0.0
by Bryan O'Sullivan 20 Sep '10

20 Sep '10

I've issued new releases of the text and text-icu packages, the fast, comprehensive Unicode text manipulation libraries. http://hackage.haskell.org/package/text http://hackage.haskell.org/package/text-icu Features of text: - Compact array-based data representation. - Library code based on stream fusion automatically reduces copying in your application, compared to a more naive library. - The lazy text type supports streaming of data much larger than RAM. Features of text-icu: - - Locale sensitive case mapping. - [NEW] Language sensitive text boundary analysis. - Text normalization. (What is normalization? http://unicode.org/faq/normalization.html) - [NEW] Access to the Unicode Character Database. - Locale sensitive string collation. - Conversion to and from a huge number of native encodings. - Efficient comparison of ByteString and Text.

2 2

example in "All about Monads"
by ender 20 Sep '10

20 Sep '10

Hi all: I am a newbie of haskell and I'm reading "All about Monads<http://www.haskell.org/all_about_monads/html/>" right now, I have some question about the example shows in Chapter 2, it says that following code is ugly mothersPaternalGrandfather :: Sheep -> Maybe Sheep mothersPaternalGrandfather s = case (mother s) of Nothing -> Nothing Just m -> case (father m) of Nothing -> Nothing Just gf -> father gf and after intruduce the comb function, it become more cleaner: -- comb is a combinator for sequencing operations that return Maybe comb :: Maybe a -> (a -> Maybe b) -> Maybe b comb Nothing _ = Nothing comb (Just x) f = f x -- now we can use `comb` to build complicated sequences mothersPaternalGrandfather :: Sheep -> Maybe Sheep mothersPaternalGrandfather s = (Just s) `comb` mother `comb` father `comb` father my question is, why not define the function father and mother as type of father::Maybe Sheep -> Maybe Sheep? this can also clean the code and it avoid the additional function comb further more, why we need a function => with type of => m a -> ( a -> m b ) -> mb? define some function with type m a -> m b can solve these problems too. Thanks and BR

4 3

Unified Haskell login
by Michael Snoyman 20 Sep '10

20 Sep '10

Hi cafe, Let me preface this by stating that this is purposely a half-baked idea, a straw man if you will. I'd like to hear what the community thinks about this. I mentioned yesterday that I was planning on building haskellers.com. The first technicality I considered was how login should work. There are a few basic ideas: * Username/password on the site. But who wants to deal with *another* password? * OpenID. Fixes the extra password problem, but doesn't give us any extra information about the user (email address, etc). * Facebook/Twitter/Google: We get the users email address, but do we *really* want to force users to have one of those accounts? I then started thinking about the Yesod documentation site[1], and realized in the not-too-distant future I'm going to want to provide a feature tracker. Once again, I'll need to face the exact same problem. And then I realized something: I already have *two* Haskell-centric logins: one for Hackage, and one for the Haskell wiki. Consolidating our logins as a community could be a huge plus. If we keep the same kind of system as we have now with Hackage and the wiki, we can verify each new user to keep things "clean". Or even better: we could have a built-in permissions system: permissions for uploading to Hackage, modifying the wiki, feature requests, etc. Users get simplification of only needing to apply for an account once and only need to remember one password. (In fact, if we wanted to, we could bypass the password some of the time by allowing OpenID authentication.) But perhaps the biggest advantage would be the community building advantage. Imagine if you go to Hackage and the upload by field is a link to someone's Haskellers profile. Imagine going to Haskellers and seeing a list of all the users uploaded packages and wiki contributions. We could even start with some clever things like badges per user. I'm sure there are lots of possibilities out there I haven't considered. Obviously there are some technical hurdles to overcome. We would probably need to do some significant work on the wiki to get this to happen. But given that we seem to have had trouble with mediawiki in the past (I remember hearing about some migration issues), maybe it's time to eat our own dog food and switch to a Haskell-based wiki[2] that could be more easily modified to suit our needs. We would also need some kind of protocol for the cross-site authentication; OAuth 2.0 might be worth considering for this. All of this may just be the ramblings of a mad-man (I haven't had breakfast yet), but I do think that *some* form of unified login could really push Haskell forward. Michael [1] http://docs.yesodweb.com/ [2] http://hackage.haskell.org/package/gitit

11 16

Haskell/JDK/tail-calls etc. (please vote on bug No. 6804517)
by Karel Gardas 20 Sep '10

20 Sep '10

Hello, from time to time request for Haskell running on top of Java's VM pops on the haskell related mailing list and then usually dies off when someone mentions that JDK does not have proper support for tail-calls. I think haskell community might do something with this fact or at least attempt to do something with it. I think the proper request for enhancement is here: http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6804517 if you agree with it (as it's proposed on the rfe's mentioned blog article[1]), then please either join or if you are already a member of SDN then just login and vote for this bug. That's something we can do for free and will take just few minutes yet perhaps push a little bit more weight behind this bug (err, just 4 votes now, why's that?). Thanks, Karel [1]: http://blogs.sun.com/jrose/entry/tail_calls_in_the_vm

6 5

"Introducing The Monads" Presentation Slides
by aditya siram 20 Sep '10

20 Sep '10

Hi folks, I just did a presentation on monads and how to use the basic ones (IO,Reader,Writer,State,ReaderT,WriterT,StateT) in practice. I thought the community might want to look at it. Is there some place I can upload the slides (it's just PDF)? -deech

5 7

Memoization/call-by-need
by Alex Rozenshteyn 20 Sep '10

20 Sep '10

I feel that there is something that I don't understand completely: I have been told that Haskell does not memoize function call, e.g. > slowFib 50 will run just as slowly each time it is called. However, I have read that Haskell has call-by-need semantics, which were described as "lazy evaluation with memoization" I understand that > fib50 = slowFib 50 will take a while to run the first time but be instant each subsequent call; does this count as memoization? (I'm trying to understand "Purely Functional Data Structures", hence this question) -- Alex R

8 7

searching haskell-cafe ?
by briand＠aracnet.com 20 Sep '10

20 Sep '10

is there a way to search the haskell-cafe list. I found a potential link on the haskell wiki, but the link is busted. Didn't see anything on the haskell-cafe mailing list page. Thanks, Brian

4 3

cabal problem on OS X
by Bill Atkins 20 Sep '10

20 Sep '10

When I run "cabal update" on my Mac (Snow Leopard, Intel), I get: % cabal update Downloading the latest package list from hackage.haskell.org cabal: Codec.Compression.Zlib: incompatible zlib version Anyone else seeing this? Reinstalling the Haskell Platform hasn't helped. Thanks!

8 7

Problems with installing type-level package
by Николай Кудасов 20 Sep '10

20 Sep '10

Hi, cafe, I have a stange thing when trying to install type-level package: $ sudo ./Setup.hs configure Configuring type-level-0.2.4... $ sudo ./Setup.hs build Preprocessing library type-level-0.2.4... Building type-level-0.2.4... [1 of 8] Compiling Data.TypeLevel.Num.Reps ( src/Data/TypeLevel/Num/Reps.hs, dist/build/Data/TypeLevel/Num/Reps.o ) [2 of 8] Compiling Data.TypeLevel.Num.Sets ( src/Data/TypeLevel/Num/Sets.hs, dist/build/Data/TypeLevel/Num/Sets.o ) [3 of 8] Compiling Data.TypeLevel.Num.Aliases.TH ( src/Data/TypeLevel/Num/Aliases/TH.hs, dist/build/Data/TypeLevel/Num/Aliases/TH.o ) [4 of 8] Compiling Data.TypeLevel.Num.Aliases ( src/Data/TypeLevel/Num/Aliases.hs, dist/build/Data/TypeLevel/Num/Aliases.o ) Loading package ghc-prim ... linking ... done. Loading package integer ... linking ... done. Loading package base ... linking ... done. Loading package syb ... linking ... done. Loading package array-0.2.0.0 ... linking ... done. Loading package containers-0.2.0.1 ... linking ... done. Loading package pretty-1.0.1.0 ... linking ... done. Loading package template-haskell ... linking ... done. Generating and compiling a zillion numerical type aliases, this might take a while $ sudo ./Setup.hs haddock Running Haddock for type-level-0.2.4... Preprocessing library type-level-0.2.4... Warning: The documentation for the following packages are not installed. No links will be generated to these packages: rts-1.0, template-haskell-2.4.0.0 Generating and compiling a zillion numerical type aliases, this might take a while $ sudo ./Setup.hs install Installing library in /usr/local/lib/type-level-0.2.4/ghc-6.10.4 Setup.hs: Error: Could not find module: Data.TypeLevel with any suffix: ["hi"] in the search path: ["dist/build"] I have ghc-6.10.4 (that's what is mentioned in "tested-with" in type-level.cabal file) and cabal-1.8.0.2. Has anyone had some similar problems?

3 4

Re: [Haskell-cafe] haltavista - look for functions by example
by Roel van Dijk 19 Sep '10

19 Sep '10

Impressive! I didn't think you could implement it so quickly. Now someone needs to add this functionality to Leksah or hack something up for Emacs. Regards, Roel On Sun, Sep 19, 2010 at 8:27 PM, Paul Brauner <paul.brauner(a)inria.fr> wrote: > It works: > > brauner@worf:/tmp$ cat test.hs > import Test.QuickCheck > import Test.QuickCheck.Arbitrary > import Control.Monad(forM_) > > intMul :: Integer -> Integer -> Integer > intMul x n | n < 0 = -(intMul x $ abs n) > | n == 0 = 0 > | n > 0 = x + intMul x (n - 1) > > main = do xs <- sample' arbitrary > ys <- sample' arbitrary > zip xs ys `forM_` \(x,y) -> > putStrLn (show x ++ " " ++ show y ++ " " ++ (show $ intMul x y)) > > > brauner@worf:/tmp$ runghc test.hs | haltavista > Prelude (*) > > I will include this functionality in the next version. Thank you for > this nice idea. > > Paul

1 0

haltavista - look for functions by example
by Paul Brauner 19 Sep '10

19 Sep '10

Hello, I just hacked together something I've been talking about a while ago on that mailing list. It's a program that looks for functions given a set of input/outputs. Example session 1: brauner@worf:~$ haltavista 2 2 4 <EOF> Prelude (*) Prelude (+) Prelude (^) Example session 2 (refining previous search): brauner@worf:~$ haltavista 2 2 4 1 2 3 <EOF> Prelude (+) Example session 3 (higher-order functions): brauner@worf:~$ haltavista (+1) (+2) (1,1) (2,3) <EOF> Data.Graph.Inductive.Query.Monad (><) Under the hood, uses: - hint for type inference; - hoogle to get a list of candidate functions; - hint for testing. Hoogle calling facility has been copy-pasted (and later modified) from the Yi project. It's availaible on github (http://github.com/polux/haltavista) and I plan to release it on hackage as soon as I catch stack overflows that occur during testing using hint. So far I didn't manage to do it, even by catching asynchronous exceptions. Every suggestion/help is welcome. Also, if I got something wrong with the licences (Yi uses GPL-2 and code is copy-pasted, Hint BSD3 and is linked, Hoogle is called as an external process, haltavista is GPL-3 for now) please tell me. Paul

2 5

Re: [Haskell-cafe] haltavista - look for functions by example
by Paul Brauner 19 Sep '10

19 Sep '10

It works: brauner@worf:/tmp$ cat test.hs import Test.QuickCheck import Test.QuickCheck.Arbitrary import Control.Monad(forM_) intMul :: Integer -> Integer -> Integer intMul x n | n < 0 = -(intMul x $ abs n) | n == 0 = 0 | n > 0 = x + intMul x (n - 1) main = do xs <- sample' arbitrary ys <- sample' arbitrary zip xs ys `forM_` \(x,y) -> putStrLn (show x ++ " " ++ show y ++ " " ++ (show $ intMul x y)) brauner@worf:/tmp$ runghc test.hs | haltavista Prelude (*) I will include this functionality in the next version. Thank you for this nice idea. Paul On Sun, Sep 19, 2010 at 08:16:08PM +0200, Paul Brauner wrote: > That's a great idea! > > In the same vein, have you had a look at quickspec by Koen Claessen, > Nicholas Smallbone and John Hughes? > > www.cse.chalmers.se/~nicsma/quickspec.pdf > > This reminds me of another idea, suggested by Jun inoue: look for > functions by specification instead of examples. > > I will try your idea ASAP. As you say, I think that might be helpful for > beginners, as you suggest, or even when you're not a beginner anymore > but you start using a new library. > > Paul > > > On Sun, Sep 19, 2010 at 07:41:21PM +0200, Roel van Dijk wrote: > > Very interesting! > > > > It got me thinking: if you combine this with the Arbitrary class [1] > > of QuickCheck you can use it check if you have defined a function that > > is "equal" to an already defined function. > > > > Let's say I write the following function: > > > > intMul ∷ Integer → Integer → Integer > > intMul x 0 = 0 > > intMul x n = x + intMul x (n - 1) > > > > No you can automatically apply this function to a list of 100 > > generated inputs to get a list of input output pairs. Feed this into > > haltavista and it should tell you that you can replace your definition > > with Prelude (*). While such an observation is certainly not a proof > > it is still useful. > > > > It would be a nice addition to a Haskell editor. Especially for those > > new to the language. > > > > Regards, > > Roel > > > > 1 - http://hackage.haskell.org/packages/archive/QuickCheck/2.3/doc/html/Test-Qu…

1 0

Hackage hierarchical module naming conventions
by Jan Snajder 19 Sep '10

19 Sep '10

Hi folks, I'm almost ready to upload my first-ever package to Hackage, but there's one thing that's bothering me for quite some time now: Are there any hierarchical module naming conventions in Hackage?! Well, I've came across this: http://www.haskell.org/haskellwiki/Hierarchical_module_names This is nice, but obviously (intentionally?) underspecified, and consequently the structure we have now doesn't really seem all that consistent. For example, consider these three packages (just an example, no offense intended): Data.KMeans Data.Datamining.Clustering.Gsom Data.Clustering.Hierarchical (I actually prefer Data.Clustering.*) It seems like anyone is building his or her own taxonomies of modules, and we end up with a lot of space in between. Has this issue been brought up before? Are there any additional guidelines? Best, Jan

1 0

how to measure memory usage?
by Johannes Waldmann 19 Sep '10

19 Sep '10

How could I measure the amount of memory that my ghc-compiled program is actually using, from inside the program? It is expanding nodes in a (game) tree, and I need to stop this when it gets near the physical limits of the system (or some other limit that I want to set on the command line) The node size is varying so I cannot just pre-compute a maximal number of nodes. Thanks - J.W. PS: the program is this: http://www.littlegolem.net/jsp/info/player.jsp?plid=22146

1 1

Full strict functor by abusing Haskell exceptions
by Maciej Piechotka 19 Sep '10

19 Sep '10

I started experiment with strict functors. I come to: > import Control.Exception > import Foreign > import Prelude hiding (catch) > > data StrictMonad a = StrictMonad a deriving Show > > instance Functor StrictMonad where > f `fmap` StrictMonad v = return $ f v > > instance Applicative StrictMonad where > pure = return > (<*>) = ap > > instance Monad StrictMonad where > return x = unsafePerformIO $ do > (return $! x) `catch` \(SomeException _) -> return x > return $! StrictMonad x > StrictMonad v >>= f = f v It seems to be valid IMHO Functor and Monad (I haven't prove it) as long as functions terminates. Some time ago there was post stating that there is not possible strict 'interesting' functor - I guess that the above is 'interesting' (and due to halting problem I guess it is not possible to create strict Functor which would deal with that problem). Regards

8 12

"malicious" JS on haskell site
by Keith Sheppard 19 Sep '10

19 Sep '10

Hello cafe, Maybe malicious isn't the right word but there is a JS based web counter on http://www.haskell.org/complex/why_does_haskell_matter.html which likes to show pop up adverts. They must have switched over from counting visitors to showing adverts at some point since the web page was created. I'm sure this is something we want removed... It would probably be good to grep the whole server to make sure that this counter doesn't show up on some other page too. Sorry if this is a simple oversight on my part but I don't know who I should be contacting about this kind of thing. It would be great if there was some kind of webmaster(a)haskell.org address that was advertised or some form that we could submit for issues like this. -keith -- keithsheppard.name

3 3

translating bidirectional fundeps to TFs
by Gábor Lehel 19 Sep '10

19 Sep '10

Now that the new typechecking awesomeness has been committed to GHC HEAD, theoretically all of the things one can express with FunctionalDependencies (bar overlap) should now be expressible with TypeFamilies as well. This got me to thinking how this might actually be done. Here's an example of a previously-inexpressible class I might want to translate, which functional dependencies allow to be expressed fairly neatly: class TwoPhase frozen thawed | frozen -> thawed, thawed -> frozen where thaw :: frozen -> thawed freeze :: thawed -> frozen (Vaguely inspired by things I saw in the Vector API; it's an abstraction for types which have the same internal representation but can present either a pure, functional interface or a mutable, monadic one and be converted between the two. For the purposes of this message this is just an example.) As far as I can tell, the straightforward translation of this to type families and equality constraints would be like this: class (Frozen (Thawed a) ~ a) => Immutable a where type Thawed a :: * thaw :: a -> Thawed a freeze :: Thawed a -> a type family Frozen a :: * But I don't think this looks too nice. It loses the nice symmetry of the FD version. (You could take both type families outside the class to make it a bit less asymmetric, among other things, but I don't see a way to avoid the fact that you need to distinguish one end of the mapping and define the other in terms of it.) What I would *want* to write is this: class (Mutable (Thawed a), Frozen (Thawed a) ~ a) => Immutable a where type Thawed a :: * thaw :: a -> Thawed a class (Immutable (Frozen a), Thawed (Frozen a) ~ a) => Mutable a where type Frozen a :: * freeze :: a -> Frozen a This looks considerably nicer, but it's not valid -- I get a cycle in class declarations via superclasses error, on the one hand, and (if I remove that) an infinite loop in the typechecker (context reduction stack overflow) on the other (FlexibleContexts being a prerequisite for most of the interesting things you can do with TypeFamilies). So what should one, theoretically, do here? Is there a way to express this using TypeFamilies which preserves both the semantics and the symmetry of the FDs version, and is also valid? Or should one just go ahead and use the FDs because, in this case, they're simply better suited? *Or* should one just suck it up and go with the ugly TypeFamilies version because TypeFamilies are The Future*? * The abbreviation TF not being a coincidence. ~g -- Work is punishment for failing to procrastinate effectively.

2 3

ANN: happstack-auth-0.2
by Nils Schweinsberg 18 Sep '10

18 Sep '10

Hey! I'd like to announce the release of happstack-auth-0.2 [1]. It offers an easy (and secure) way to implement user authentication for Happstack web applications with a lot of high level functions and a solid Happstack-State back-end. The original project got started by MightyByte, until I took it over and improved the whole package. As a result, the API has changed a lot and if you were using the old happstack-auth you might consider rewriting your application to use the new api.* However, your applications state will be completely compatible with the new version and be migrated automatically. The package got uploaded to hackage and can now be installed via cabal: cabal install happstack-auth It should build with both, the current stable release of happstack (0.5.0.2) and the latest darcs version (0.5.1). If there are any errors/bugs during building/running, please contact me! A demonstration website is up and running with about 30 lines of code (+ html templates and the actual happstack server code) at [2]. If you don't want to wait until hackage rendered the haddock pages, you can take a look at the (latest git version of the) API at [3]. Hope you enjoy it! :) - Nils Schweinsberg / McManiaC * You can still use the old state-query/update constructors by importing "Happstack.Auth.Internal", although you'll miss a lot of features like session management etc. In addition, MightyBytes old repo should be still available at [4]. [1] http://hackage.haskell.org/package/happstack-auth [2] http://n-sch.de/happstack-auth [3] http://n-sch.de/hdocs/happstack-auth [4] http://github.com/mightybyte/happstack-auth

3 3

Uniting graphics libraries
by Tillmann Vogt 18 Sep '10

18 Sep '10

Hi, I have nearly finished writing a Collada-output library to make 3d animation files. Before doing this I have looked at two libraries on hackage that parse Collada to display it. For my library I have copied the types from gpipe-collada and extended them. Now I am thinking that it would be nice if all 3d libraries would use the same data type. Currently gpipe-collada, graphics-formats-collada, obj, ... parse 3d-formats. FieldTrip, lambdacube-engine, ... (to mention examples) can generate and/or display 3d-objects. But they all cannot be combined without tedious type conversions. The obvious argument is that every application has its own needs. This is of course true but I think that the Collada format shows how to deal with this (you can do quite a lot with profile_common). I would be willing to write patches for some libraries and make a discussable 3d-types library based on Collada. Hope you agree, Tillmann

2 4

Curious why "cabal upgrade parsec" not installing latest version
by Peter Schmitz 18 Sep '10

18 Sep '10

Not that I'm having any problem with parsec 2.1.0.1, but I guess I would like to install the latest (3.1.0), unless there is a reason not to. I can't seem to get Cabal to do so; thanks in advance for any help. I don't understand part of the output from "cabal install --dry-run --reinstall -v parsec" at the end below, which includes: "selecting parsec-2.1.0.1 (hackage) and discarding parsec-2.0, 2.1.0.0, 3.0.0, 3.0.1 and 3.1.0". (http://hackage.haskell.org/package/parsec seems to point to 3.1.0.) Under Windows XP: > H:\proc\dev\cmd>cabal update > Downloading the latest package list from hackage.haskell.org > > H:\proc\dev\cmd>cabal info parsec > * parsec (library) > Synopsis: Monadic parser combinators > Latest version available: 3.1.0 > Latest version installed: 2.1.0.1 > Homepage: http://www.cs.uu.nl/~daan/parsec.html > Bug reports: [ Not specified ] > Description: Parsec is designed from scratch as an industrial-strength > parser library. It is simple, safe, well documented (on the > package homepage), has extensive libraries and good error > messages, and is also fast. It is defined as a monad > transformer that can be stacked on arbitrary monads, and it > is also parametric in the input stream type. > Category: Parsing > License: BSD3 > Author: Daan Leijen <daan(a)microsoft.com>, Paolo Martini <paolo(a)nemail.it> > Maintainer: Derek Elkins <derek.a.elkins(a)gmail.com> > Source repo: [ Not specified ] > Flags: base4 > Dependencies: mtl -any, bytestring -any, base >=4 && <5, syb -any, > base >=3.0.3 && <4 > Documentation: [ Not installed ] > Cached: No > Modules: > Text.ParserCombinators.Parsec > Text.ParserCombinators.Parsec.Char > Text.ParserCombinators.Parsec.Combinator > Text.ParserCombinators.Parsec.Error > Text.ParserCombinators.Parsec.Expr > Text.ParserCombinators.Parsec.Language > Text.ParserCombinators.Parsec.Perm > Text.ParserCombinators.Parsec.Pos > Text.ParserCombinators.Parsec.Prim > Text.ParserCombinators.Parsec.Token > > > H:\proc\dev\cmd>cabal upgrade parsec > Resolving dependencies... > No packages to be installed. All the requested packages are already installed. > If you want to reinstall anyway then use the --reinstall flag. > > > H:\proc\dev\cmd>cabal install --dry-run --reinstall parsec > Resolving dependencies... > In order, the following would be installed (use -v for more details): > parsec-2.1.0.1 > > > H:\proc\dev\cmd>cabal install --dry-run --reinstall -v parsec > H:\proc\tools\Haskell Platform\2010.1.0.0\bin\ghc.exe --numeric-version > looking for package tool: ghc-pkg near compiler in > H:\proc\tools\Haskell Platform\2010.1.0.0\bin > found package tool in > H:\proc\tools\Haskell Platform\2010.1.0.0\bin\ghc-pkg.exe > H:\proc\tools\Haskell Platform\2010.1.0.0\bin\ghc-pkg.exe --version > H:\proc\tools\Haskell Platform\2010.1.0.0\bin\ghc.exe --supported-languages > Reading installed packages... > H:\proc\tools\Haskell Platform\2010.1.0.0\bin\ghc-pkg.exe dump --global > H:\proc\tools\Haskell Platform\2010.1.0.0\bin\ghc-pkg.exe dump --user > Reading available packages... > Resolving dependencies... > selecting parsec-2.1.0.1 (hackage) and discarding parsec-2.0, > 2.1.0.0, 3.0.0, 3.0.1 and 3.1.0 > selecting base-3.0.3.2 (installed) and 4.2.0.0 (installed) and discarding > syb-0.1.0.0, 0.1.0.1, 0.1.0.2, 0.1.0.3, 0.2 and 0.2.1 > selecting ffi-1.0 (installed) > selecting ghc-prim-0.2.0.0 (installed) > selecting integer-gmp-0.2.0.0 (installed) > selecting rts-1.0 (installed) > selecting syb-0.1.0.2 (installed) > In order, the following would be installed: > parsec-2.1.0.1 (reinstall) changes: base-4.2.0.0 -> 3.0.3.2 > > H:\proc\dev\cmd> --

7 15

types for parsing a tree
by Jared Jennings 18 Sep '10

18 Sep '10

Dear haskell-cafe: I'm trying to parse an Open Financial eXchange (OFX) 1.x file. It details my bank transactions, like debit card purchases. It's SGML-based and it goes like: <OFX>[...] <STMTRS>[...] <STMTTRN>[...] <TRNUID>9223ry29r389 <NAME>THE GROCERY STORE BLABLABLA <TRNAMT>234.99 </STMTTRN> <STMTTRN>[...] <TRNUID>1237tg832t <NAME>SOME DUDE ON PAYPAL 4781487 <TRNAMT>2174.27 </STMTTRN> </STMTRS> </OFX> I've left out a bunch, but as you can see it's tree-shaped, and the only reason they didn't misuse XML as a data serialization language instead of SGML was because it wasn't popular yet. (OFX 2.x uses XML but my bank doesn't use OFX 2.x.) When I imagine how to put this into a data structure, I think: -- The '...' below is stuff like the date, info about the bank data OFX = OFX { statement :: StatementResponse, ... } -- The '...' below is stuff like the account number data StatementResponse = StatementResponse { transactions: [Transaction], ... } data Transaction = Transaction { id :: String, name :: String, amount :: Decimal, sic :: Maybe Int, ... } Then I tried to make a parser to emit those data types and failed. I come from Python, where there's no problem if a function returns different types of values depending on its inputs, but that doesn't fly in Haskell. I've tried data OFXThing = OFX { statement :: OFXThing } | StatementResponse { ... transactions :: [OFXThing] } but that would let me make trees of things that make no sense in OFX, like a transaction containing a statement. I made a data Tree k v = Branch k [Tree k v] | Leaf k v type TextTree = Tree String String and a tagsoup-parsec parser that returns Branches for tags like OFX, and Leafs for tags like TRNUID. But now I just have a tree of strings. That holds no useful type information. I want my types to say that OFXes contain statements and statements contain transactions - just like the OFX DTD says. How can I construct the types so that they are tight enough to be meaningful and loose enough that it's possible to write functions that emit them?

4 5

Stateful DSLs
by Günther Schmidt 18 Sep '10

18 Sep '10

Hello, I'd want to create a EDSL where I want to be able to statically ensure that expressions can only be built according to a particular "state". Like in a network application, SMTP client for example, where I can only issue commands if the application is in a certain state. Are there any Haskell examples for this sort of thing? Günther

3 3

A new cabal odissey: cabal-1.8 breaking its own neck by updating its dependencies
by Paolo Giarrusso 17 Sep '10

17 Sep '10

Hi, after Andrew Coppin's odissey [1], I also had a few problem with cabal, which stopped installing new packages. Details will follow; meanwhile, here are some questions prompted by what happened: - when recompiling a package with ABI changes, does cabal always update dependent packages? It seems "not always" - it didn't update itself, nor refuse the breaking upgrade, and the ABI breakage caused linker errors on Setup.hs. Luckily, cabal was already linked so I could always use it for queries. - can cabal extract and check dependencies as specified in the .hi files? I had a broken dependency which I could see with "grep" but not otherwise. - is there a "specification" of which are the "core" packages? Not sure if this is more useful as a bug report or as discussion, or if I just misused cabal and it's the only perfect software in the world; still I wanted to share my experience. Also I am not sure if this is the best place - but I'm not subscribed to other lists, and the previous "cabal odissey" was posted here, so I hope it's fine. A related idea is that Gentoo had a tool which not only extracted such dependencies, but recompiled all affected packages. While package removal is not supported through cabal, it is sometimes needed (and well, it should be supported at some point). See for instance this FAQ: http://www.haskell.org/cabal/FAQ.html#dependencies-conflict My problem seems a nastier variation of the one described there :-(. Details follow. Best regards [1] http://groups.google.com/group/haskell-cafe/browse_thread/thread/787c67b31f… -- Paolo Giarrusso - Ph.D. Student http://www.informatik.uni-marburg.de/~pgiarrusso/

11 23

IO-oriented cache library for interacting with GUI
by Alexey Karakulov 17 Sep '10

17 Sep '10

Hi. I'm writing GUI (gtk) program which purpose is take some data as user input, perform some evaluations, and produce some plots and coefficients. Since some evaluations take significant time (about 10 seconds), I try to cache results. The problem is that dependency structure is quite complicated, something like this: a* -> x, b* x -> c x, b* -> d where α -> β means that β depends on α values designated by *a*,*b*,*c*,*d* can be showed to user by request, and *x* is internal value values designated by letters with asterisk (*a**,*b**) can be edited by user Consider *x*. I have two values: xCache :: IORef X xUpToDate :: IORef Bool Initial state is: xCache <- newIORef undefined xUpToDate <- newIORef False Since *x* is evaluated once, I do xCache `writeIORef` x xUpToDate `writeIORef` True When user changes the value of *a *and saves it, all dependent on *a *values cache is expired: xUpToDate `writeIORef` False (recursively do it with all cache depends on *x*) When it comes to handling all *a,b,c,d,x *dependencies the code becomes a mess. I now have something like import Data.Functor import Data.IORef import Control.Monad data Mutable a = Mutable { ref :: IORef a, onChange :: IO () } change :: Mutable a -> a -> IO () change Mutable {..} a = ref `writeIORef` a >> onChange data Cache a b = Cache { fn :: a -> b, arg :: IORef a, cached :: IORef b, upToDate :: IORef Bool } expire :: Cache a b -> IO () expire Cache {..} = upToDate `writeIORef` False update :: Cache a b -> IO () update Cache {..} = do utd <- readIORef upToDate unless utd $ writeIORef cached =<< fn <$> readIORef arg test = do aRef <- newIORef undefined xRef <- newIORef undefined xCache <- Cache (^2) aRef xRef <$> newIORef False let aMut = Mutable aRef (expire xCache) aMut `change` 1 update xCache print =<< readIORef xRef -- 1 aMut `change` 2 print =<< readIORef xRef -- still 1 update xCache print =<< readIORef xRef -- now 4 I'd like to know if there is some library that could help me. (Sorry for my English) -- All the best, Alexey

4 3

Reachable variables exercise
by Carlos Camarao 17 Sep '10

17 Sep '10

Hi. Consider for example an expression e0 like: fst (True,e) where e is any expression. e0 should have type Bool IMHO irrespectively of the type of e. In Haskell this is the case if e's type is monomorphic, or polymorphic, or constrained and there is a default in the current module that removes the constraints. However, e0 is not type-correct if e has a constrained type and the constraints are not subject to defaulting. For example: class O a where o::a main = print $ fst(True,o) generates a type error; in GHC: Ambiguous type variable `a' in the constraint: `O a' arising from a use of `o' at ... Probable fix: add a type signature that fixes these type variable(s) A solution (that avoids type signatures) can be given as follows. The type of f e, for f of type, say, K=>t'->t and e of type K'=> t' should be: K +_t K' => t (not K U K' => t) where K +_t K' denotes the constraint-set obtained by adding from K' only constraints with type variables reachable from t. (A type variable is reachable if it appears in the same constraint as either a type variable free in the type, or another reachable type variable.) Comments? Does that need and deserve a proposal? Cheers, Carlos

2 2

Fwd: [Haskell-cafe] Reachable variables exercise
by Carlos Camarao 17 Sep '10

17 Sep '10

---------- Forwarded message ---------- From: Carlos Camarao <carlos.camarao(a)gmail.com> Date: Fri, Sep 17, 2010 at 12:01 AM Subject: Re: [Haskell-cafe] Reachable variables exercise To: Luke Palmer <lrpalmer(a)gmail.com> boolify o has type Boolable a => Bool under the proposal, then we have ambiguity, type error, right? In general, consider 'e' as (g:: K=>a -> t) (o:: O a=>a); then the type of 'e' has constraint (O a) iff 'a' occurs in t. Let's think about how could 'a' not occur in t. That happens if 'o' is not needed for computing the result; well, or, as in your example, 'g' is overloaded and requires the argument to resolve the overloading ('a' occurs in K and does not occur in t), in which case K=>t is ambiguous. Cheers, Carlos On Thu, Sep 16, 2010 at 6:56 PM, Luke Palmer <lrpalmer(a)gmail.com> wrote: > I am not totally sure if I understand your proposal correctly, but if > I do, then it has a flaw. Consider: > > class Boolable a where > boolify :: a -> Bool > > class O a where > o :: a > > main = print $ boolify o > > It seems like under your proposal this should not be a type error. > But if that is so, then what is its output? > > Luke > > On Thu, Sep 16, 2010 at 7:31 AM, Carlos Camarao > <carlos.camarao(a)gmail.com> wrote: > > Hi. Consider for example an expression e0 like: > > > > fst (True,e) > > > > where e is any expression. > > > > e0 should have type Bool IMHO irrespectively of the type of e. In Haskell > > this is the case if e's type is monomorphic, or polymorphic, or > > constrained and there is a default in the current module that removes > > the constraints. However, e0 is not type-correct if e has a > > constrained type and the constraints are not subject to > > defaulting. For example: > > > > class O a where o::a > > main = print $ fst(True,o) > > > > generates a type error; in GHC: > > > > Ambiguous type variable `a' in the constraint: > > `O a' arising from a use of `o' at ... > > Probable fix: add a type signature that fixes these type variable(s) > > > > A solution (that avoids type signatures) can be given as follows. > > > > The type of f e, for f of type, say, K=>t'->t and e of type K'=> t' > > should be: > > > > K +_t K' => t (not K U K' => t) > > > > where K +_t K' denotes the constraint-set obtained by adding from K' > > only constraints with type variables reachable from t. > > > > (A type variable is reachable if it appears in the same constraint as > > either a type variable free in the type, or another reachable type > > variable.) > > > > Comments? Does that need and deserve a proposal? > > > > Cheers, > > > > Carlos > > > > _______________________________________________ > > Haskell-Cafe mailing list > > Haskell-Cafe(a)haskell.org > > http://www.haskell.org/mailman/listinfo/haskell-cafe > > > > >

1 0

Idea for hackage feature
by Mitar 17 Sep '10

17 Sep '10

Hi! I just got an idea for hackage feature. All functions/modules listed there could have some mark if they or any function/module they use uses an unsafe* function. Of course this will make probably almost everything marked as unsafe, but this is the idea - to raise awareness about that so that you can prefer some function/implementation over another. Of course marking/tagging everything as unsafe is not really useful. Because of this I propose that then community votes/vouches on correctness/stability of implementations and this would then influence the how unsafe given function really is (or is according to community, if we are more precise). Of course it would be even better that every function using unsafe would have also a formal proof but as we cannot believe that we will prove everything in a feasible feature we could maybe opt for such "crowd intelligence" approach. We cannot have a Turing machine, but maybe we can have crowd. ;-) (Of course low number of found bugs and good unit test code coverage can then positively influence crowd, so authors would be motivated to assure that.) Comments? Opinions? Because I really hate that I try to keep my code pure and separate IO from everything else and then somewhere deep in there some unsafe* lurks. (Ah, yes, a side effect of this tagging/marks would be also that you would be able to see where all those unsafe* calls are for a given function, so you would be able to fast jump (with link) to a given line in code and evaluate circumstances in which that unsafe* call is made. And then vote/vouch once you discover that it is probably pretty safe.) Mitar

9 11

IO Put confusion
by Chad Scherrer 17 Sep '10

17 Sep '10

Hello, I need to be able to use strict bytestrings to efficiently build a lazy bytestring, so I'm using putByteString in Data.Binary. But I also need random numbers, so I'm using mwc-random. I end up in the "IO Put" monad, and it's giving me some issues. To build a random document, I need a random length, and a collection of random words. So I have docLength :: IO Int word :: IO Put Oh, also putSpace :: Put My first attempt: doc :: IO Put doc = docLength >>= go where go 1 = word go n = word >> return putSpace >> go (n-1) Unfortunately, with this approach, you end up with a one-word document. I think this makes sense because of the monad laws, but I haven't checked it. Second attempt: doc :: IO Put doc = docLength >>= go where go 1 = word go n = do w <- word ws <- go (n-1) return (w >> putSpace >> ws) This one actually works, but it holds onto everything in memory instead of outputting as it goes. If docLength tends to be large, this leads to big problems. Oh, yes, and my main is currently main = L.writeFile "out.txt" =<< fmap runPut doc This needs to be lazier so disk writing can start sooner, and to avoid eating up tons of memory. Any ideas? Thanks! Chad

2 2

ANN: monte-carlo version 0.3
by Patrick Perry 17 Sep '10

17 Sep '10

monte-carlo is a haskell library providing a monad and associated monad transformer for computing with quasi-random numbers. It provides a high-level interface to the distributions supported by the GNU Scientific Library (currently just uniform, normal, exponential, Poisson, Levy, but others are easy to add). You can see examples of the library in action at http://github.com/patperry/hs-monte-carlo/tree/master/examples/ . Hackage documentation is at http://hackage.haskell.org/package/monte-carlo . A few blog posts describe an older version of the library, but beware the API has changed slightly, and these examples require some modification: http://ptrckprry.com/blog/2008/08/26/a-monte-carlo-monad-for-haskell/ (see examples/Pi.lhs) http://ptrckprry.com/blog/2008/12/31/monte-carlo-poker-odds/ (see examples/Poker.hs) The changes since the last release are listed below. I welcome feedback, bug reports, and contributions. Patrick Changes since version 0.2. * Add strict versions of sampleSubset, sampleIntSubset, and shuffleInt. * Port to vector-0.6.0. * Add Exponential and Levy alpha-Stable distributions. * Add Summary.Bool for indicators. * Move Summary to Data.Summary * Introduce `repeatMC`, which produces an infinite (lazy) stream of values, and `replicateMC`, which produces a lazy list of specified length. * Remove `repeatMC/repeatMCWith`. * Build fix for 6.8.2 from Robert Gunst. * The function `sample`, `sampleWithWeights`, `sampleSubset`, and `shuffle` no longer require that you explicitly pass in the length. * The pure RNG is now a newtype, so you can't use the functions from GLS.Random.Gen on it anymore. * The internals of the monad have been cleaned up. IO is used internally instead of `seq` calls and `unsafePerformIO` everywhere. This results in a modest performance boost.

1 0

benchmarking c/c++ and haskell
by Vo Minh Thu 16 Sep '10

16 Sep '10

Hi, I would like to benchmark C/C++ and Haskell code. The goal is to improve the Haskell port[0] of smallpt[1]. To make sure my approach was reliable, I got the code of two programs (one in C, the other in Haskell) from a post[2] by Don. The code is reproduced below. When timing the execution of both program, I have a >4x difference. It is said on the blog the programs should have similar performance. I simply don't get the reason of such a difference. I've tried the code on my Atom netbook and also on an older centrino machine. The timing are similar (i.e. the C and Haskell program show >4x difference). Both machines have GHC 6.12.1 on Linux. Would you have an idea? [0] http://hackage.haskell.org/package/smallpt-hs [1] http://www.kevinbeason.com/smallpt/ [2] http://donsbot.wordpress.com/2008/06/04/haskell-as-fast-as-c-working-at-a-h… $ gcc -O2 mean.c -omean-c $ ghc --make -O2 mean.hs -o mean-hs $ time ./mean-c 1e8 50000000.500000 real 0m1.575s user 0m1.513s sys 0m0.000s $ time ./mean-hs 1e8 50000000.5 real 0m6.997s user 0m6.856s sys 0m0.013s -- file mean.hs module Main where import System.Environment import Text.Printf mean :: Double -> Double -> Double mean n m = go 0 0 n where go :: Double -> Int -> Double -> Double go s l x | x > m = s / fromIntegral l | otherwise = go (s+x) (l+1) (x+1) main = do [d] <- map read `fmap` getArgs printf "%f\n" (mean 1 d) /* file mean.c */ #include <stdio.h> #include <stdlib.h> int main (int argc, char **argv) { double d = atof(argv[1]); double n; long a; double b; for (n = 1, a = 0, b = 0; n <= d; b+=n, n++, a++) ; printf("%f\n", b / a); return 0; }

7 12

A question about "threading" state
by michael rice 16 Sep '10

16 Sep '10

I've been playing around with State Monads. Two I looked at earlier used *sequence* and *replicate* but when I came to this one I found myself puzzling over how to structure the problem when there was no predetermined count of how many times to thread the state. ============== Program 1 ============= import Control.Monad import Control.Monad.State type GeneratorState = State (Int, Int) -- lcf (largest common factor) -- lcf :: (Int, Int) -> ((Int, Int), Int) lcf (x, y) | x == y = ((x, y), x) | x < y = ((y, x), 0) | otherwise = ((y, x-y), 0) lcfstate :: GeneratorState Int lcfstate = State (\st -> lcf st) ============== Some output ========= {- *Main> runState lcfstate (24,18) (0,(18,6)) *Main> runState lcfstate (18,6) (0,(6,12)) *Main> runState lcfstate (6,12) (0,(12,6)) *Main> runState lcfstate (12,6) (0,(6,6)) *Main> runState lcfstate (6,6) (6,(6,6)) *Main> runState (sequence $ replicate 5 lcfstate) (24,18) ([0,0,0,0,6],(6,6)) -} {- *Main> evalState (sequence $ replicate 2 lcfstate) (24,18) [0,0] *Main> evalState (sequence $ replicate 3 lcfstate) (24,18) [0,0,0] *Main> evalState (sequence $ replicate 4 lcfstate) (24,18) [0,0,0,0] *Main> evalState (sequence $ replicate 5 lcfstate) (24,18) [0,0,0,0,6] -} =================================== Then I saw the same problem solved here http://www.engr.mun.ca/~theo/Misc/haskell_and_monads.htm ============== Program 2 ============= import Control.Monad import Control.Monad.ST newtype StateTrans s a = ST( s -> (s, a) ) instance Monad (StateTrans s) where -- (>>=) :: StateTrans s a -> (a -> StateTrans s b) -> StateTrans s b (ST p) >>= k = ST( \s0 -> let (s1, a) = p s0 (ST q) = k a in q s1 ) -- return :: a -> StateTrans s a return a = ST( \s -> (s, a) ) applyST :: StateTrans s a -> s -> (s, a) applyST (ST p) s = p s type ImpState = (Int, Int) getX, getY :: StateTrans ImpState Int getX = ST(\(x,y)-> ((x,y), x)) getY = ST(\(x,y)-> ((x,y), y)) putX, putY :: Int -> StateTrans ImpState () putX x' = ST(\(x,y)->((x',y),())) putY y' = ST(\(x,y)->((x,y'),())) gcdST :: StateTrans ImpState Int gcdST = do x <- getX y <- getY (if x == y then return x else if x < y then do putY (y-x) gcdST else do putX (x-y) gcdST) greatestCommonDivisor x y = snd( applyST gcdST (x,y) ) ============== Some output ========= {- *Main> greatestCommonDivisor 24 18 6-} ==================================== Very impressive. Is this solution typical for problems where the number of times the state must be threaded is dependent on the state itself? Michael

1 0

Generating arbitrary functions with QuickCheck?
by Matias Eyzaguirre 16 Sep '10

16 Sep '10

Hi, I'v been reading a small paper/lesson on writing parser combinators in Haskell, and it seems more or less straightforward. In this case a parser is defined thusly: > type Parser a = String -> Maybe (a, String) And then it goes on to list some simple parsers, and then starts going on about combinators. I was wondering how one would write quickcheck properties for the items presented in the paper, and the answer seemed fairly straightforward for the actual parsers. But how on earth would you write a test for a combinator? Presumable one would need to make the type an instance of Arbitrary. I see two problems: Firstly, as far as i can tell, one cannot declare a type synonym to be an instance of a type class, thus how would you make it an instance of Arbitrary? Secondly, (and more importantly, or at least more interesting) I can see how one would make a generator for simple compound data types, but how on earth do you make a generator produce functions?

5 4

Scraping boilerplate deriving?
by Kevin Jardine 16 Sep '10

16 Sep '10

I have a set of wrapper newtypes that are always of the same format: newtype MyType = MyType Obj deriving (A,B,C,D) where Obj, A, B, C, and D are always the same. Only MyType varies. A, B, C, and D are automagically derived by GHC using the {-# LANGUAGE GeneralizedNewtypeDeriving #-} feature. I would like to use some macro system (perhaps Template Haskell?) to reduce this to something like defObj MyType I've read through some Template Haskell documentation and examples, but I find it intimidatingly hard to follow. Does anyone has some code suggestions or pointers to something similar? Alternatively, is there any way in standard Haskell to define some kind of union class: U = (A, B, C, D) and then using newtype MyType = MyType Obj deriving U which would at least be shorter?

12 19

[PREANNOUNCE] Crypto-API Major Version Bump (0.1.0.0)
by Thomas DuBuisson 16 Sep '10

16 Sep '10

All, Ironing out crypto-api, I have commited the below changes mostly intended to streamline crypto-api and focus it on the main purpose of connecting algorithm developers with slightly higher-level (and generic) function needed by crypto-users. Feel free to object, comment, or recommend additional alterations before 0.1 is released. Padding, NIST KATs for TwoFish, and a generalized/testable CFB mode might appear before release, but no promises. PROJECT MANAGEMENT: Homepage: http://trac.haskell.org/crypto-api/wiki Bug trac: http://trac.haskell.org/crypto-api/report/1 Repo: http://code.haskell.org/crypto-api/ API CHANGES * instance Monad (Either GenError) where ... * cereal >= 0.2 && < 0.3 (was == 0.2.*) * Test.{HMAC,SHA,AES} now exist / are split from Test.Crypto ** SHA and HMAC tests are new and from NIST CAVP KAT collection - no more rolling your own testing! * Test.ParseNistKATs doesn't use Parsec and has a barebones interface. * Crypto.Random does not export "AsRG" or "Splittable" (see change log, 'random' build dep removed) DEPENDENCIES While I've never had objections to dependencies (this is what cabal is for and removing unused code is what GHC+linkers are for), I feel this is a good minimum and hope others agree. Some potential users made noise about having both Binary and Cereal and just the number of deps in general. * deps removed: binary, parsec, random (and indirectly: time, old-locale) * deps remaining: base, tagged, bytestring, cereal, filepath, directory * indirect deps remaining: data-default, containers, arrays CHANGE LOG (since 0.0.0.2) * Bump 'cereal' version bound to include 0.3 * instance Monad (Either GenError) -- that was an obvious oversight * Remove the 'binary' dep. (cereal makes more sense and can be leveraged in Binary.{Get,Put} routines). * Removed the 'parsec' dep, which was only needed for Test.* but not even that now. * Updated the CPP tests for Windows in System.Random.Crypto (still need a tester) * Fixed up the testing infrastructure. Algorithms now use separate modules (Test.SHA, Test.HMAC, Test.AES). more NIST KATs included: ~1000 SHA tests, hundreds of SHA HMAC tests. * Fixed ugly bug for HMACs using keys > blockSize (eep! Obvious interop problem, but there was no-less security in the hmac result) * Removes the 'random' dep and by extension removes indirect deps on time and old-locale. Random was only used to provide trivial lifting of a newtype wrapped CryptoRandomGen instances into the RandomGen class, which was of questionable sense in the first place. TESTING I've been using the HEAD crypto-api, specifically Test.{HMAC,SHA,AES}, Crypto.{Classes,HMAC} and Benchmark.{BlockCipher,Hash}, with instances for SimpleAES, cryptohash, pureMD5, and SHA packages with good success. My HEAD DRBG (NIST SP 800-90) code uses Crypto.Random and Crypto.Classes libraries to good effect, thus far things seem to flow well. Cheers, Thomas

2 2

Simple Parsec example, question
by Peter Schmitz 16 Sep '10

16 Sep '10

Simple Parsec example, question I am learning Parsec and have been studying some great reference and tutorial sites I have found (much thanks to the authors), including: http://legacy.cs.uu.nl/daan/download/parsec/parsec.html#UserGuide http://legacy.cs.uu.nl/daan/download/parsec/parsec.html#ReferenceGuide http://book.realworldhaskell.org/read/using-parsec.html http://lstephen.wordpress.com/2007/06/19/first-go-with-parsec/ http://jonathan.tang.name/files/scheme_in_48/tutorial/overview.html http://www.defmacro.org/ramblings/lisp-in-haskell.html I'm having trouble coding a simple parser to count the number of lines in a text file. "lineCount" fails to compile; the compiler error text is below it. Any advice, code, etc. would be appreciated. For those using Gtk2Hs + Glade, I have included the glade file after the Haskell code, in case you want to try it. (You will need to remove the leading "> " and fix some lines that the email wrapped.) If you do wish to offer code, feel free to remove or rewrite: eol, textLines and lineCount entirely. I'm looking for the simplest way to code this. Thanks very much, -- Peter > -- A parsing demo, using: > -- Haskell + Gtk2Hs + Glade (GtkBuilder) + Parsec > module Main where > > -- import Data.IORef > import Graphics.UI.Gtk > import Graphics.UI.Gtk.Builder > import Graphics.UI.Gtk.Selectors.FileChooser > -- import System.Cmd -- e.g., for invoking a shell cmd > import System.Glib.GError > import Text.ParserCombinators.Parsec > > main :: IO () > main = do > initGUI > > -- create builder; load UI file > builder <- builderNew > handleGError (\(GError dom code msg) -> fail msg) $ > builderAddFromFile builder "demo.glade" > -- Error message would look something like: > -- app.exe: user error (Failed to open file 'app.glade': > -- No such file or directory) > > -- get widget handles (reduce boilerplate?) > mainWindow <- builderGetObject builder castToWindow "mainWindow" > pickFileButton <- > builderGetObject builder castToFileChooserButton "pickFileButton" > parseButton <- builderGetObject builder castToButton "parseButton" > exitButton <- builderGetObject builder castToButton "exitButton" > > -- signal handlers -- > > -- parse selected file > onClicked parseButton $ do > file <- fileChooserGetFilename pickFileButton > > case file of > Nothing -> do > putStrLn "\nPlease first select a file." > return () > Just file -> do > putStrLn $ "\nParsing file: " ++ show file > result <- parseFromFile lineCount file > case (result) of > Left err -> print err > Right x -> putStrLn $ "Line count = " ++ show x > return () > > -- exit > onDestroy mainWindow mainQuit > onClicked exitButton mainQuit > > -- go > widgetShowAll mainWindow > mainGUI > > ----------------- > eol = char '\n' > > -- from RWH; perhaps use in future: > -- eol = try (string "\n\r") > -- <|> try (string "\r\n") > -- <|> string "\n" > -- <|> string "\r" > -- <?> "end of line" > > textLines = endBy eol > > lineCount :: Parser Int > lineCount = do > xs <- textLines > return (length xs) > > > -- demo.hs:72:3: > -- Couldn't match expected type `GenParser Char () Int' > -- against inferred type `GenParser Char st sep -> b' > -- In a stmt of a 'do' expression: xs <- textLines > -- In the expression: > -- do { xs <- textLines; > -- return (length xs) } > -- In the definition of `lineCount': > -- lineCount = do { xs <- textLines; > -- return (length xs) } -- demo.glade follows -- > <?xml version="1.0"?> > <interface> > <requires lib="gtk+" version="2.16"/> >  > <object class="GtkWindow" id="mainWindow"> > <property name="visible">True</property> > <property name="title" translatable="yes">demo v.8</property> > <child> > <object class="GtkVBox" id="vbox1"> > <property name="visible">True</property> > <property name="border_width">6</property> > <property name="orientation">vertical</property> > <property name="spacing">10</property> > <child> > <object class="GtkLabel" id="label1"> > <property name="visible">True</property> > <property name="tooltip_text" translatable="yes">You can hover over the buttons below for some information about them. > > You can also resize this window, to make the buttons bigger. > </property> > <property name="label" translatable="yes">Demo: Haskell + Gtk2Hs + Glade (GtkBuilder) + Parsec > </property> > </object> > <packing> > <property name="position">0</property> > </packing> > </child> > <child> > <object class="GtkHBox" id="hbox1"> > <property name="visible">True</property> > <property name="spacing">5</property> > <child> > <object class="GtkFrame" id="pickFileframe"> > <property name="visible">True</property> > <property name="tooltip_text" translatable="yes">Use this File Chooser widget to select the file to parse. > </property> > <property name="label_xalign">0</property> > <property name="shadow_type">none</property> > <child> > <object class="GtkAlignment" id="alignment1"> > <property name="visible">True</property> > <property name="left_padding">12</property> > <child> > <object class="GtkFileChooserButton" id="pickFileButton"> > <property name="visible">True</property> > <property name="title" translatable="yes">Select file</property> > </object> > </child> > </object> > </child> > <child type="label"> > <object class="GtkLabel" id="pickFileLabel"> > <property name="visible">True</property> > <property name="label" translatable="yes"><b>Select file to parse:</b></property> > <property name="use_markup">True</property> > </object> > </child> > </object> > <packing> > <property name="position">0</property> > </packing> > </child> > <child> > <object class="GtkButton" id="parseButton"> > <property name="label" translatable="yes">P_arse</property> > <property name="visible">True</property> > <property name="can_focus">True</property> > <property name="receives_default">True</property> > <property name="tooltip_text" translatable="yes">Use this to parse the file you have selected.</property> > <property name="use_underline">True</property> > </object> > <packing> > <property name="position">1</property> > </packing> > </child> > <child> > <object class="GtkButton" id="exitButton"> > <property name="label" translatable="yes">E_xit</property> > <property name="visible">True</property> > <property name="can_focus">True</property> > <property name="receives_default">True</property> > <property name="tooltip_text" translatable="yes">Exit this program and close both windows.</property> > <property name="use_underline">True</property> > </object> > <packing> > <property name="position">2</property> > </packing> > </child> > </object> > <packing> > <property name="position">1</property> > </packing> > </child> > </object> > </child> > </object> > </interface> -- end --

3 4

try, seq, and IO
by Jeroen van Maanen 15 Sep '10

15 Sep '10

The past year I have been working on a port of my machine learning project named LExAu from Java to Haskell. I'm still very glad I took the jump, because the complexity curve appears to be log shaped rather than exp shaped. In one year I almost got to the functionality that had taken me five years to produce in Java (of course it helped a lot that I had a working prototype this time). There is one thing that still bothers me though: when I write seq or $! it doesn't seem to have any effect! Currently I am trying to add some exception handling to help me debug the system, but the code that I managed to produce depends on the logging statement to produce the desired result. :-( It looks like this, and only works when I uncomment the line '-- logger "Check sum": [...]', otherwise the exception is caught by the try around the body of the thread that this code runs in: do logger "Received update" [showString label, logs update] result <- try $! do maybeUpdatedModel <- return $ f update startModel theCheckSum <- return $ liftM checkSum maybeUpdatedModel -- logger "Check sum" [showString label, shows theCheckSum] return $! seq theCheckSum maybeUpdatedModel maybeNextModel <- case result of Right theMaybeNextModel -> return theMaybeNextModel Left exception -> do let exc :: SomeException exc = exception logger "Exception" [showString label, shows exception] return Nothing logger "Maybe next model" [showString label, logs maybeNextModel] For more context see: http://lexau.svn.sourceforge.net/viewvc/lexau/branches/totem/src/LExAu/Pipe… after line 241. Can someone explain why a few showStrings a shows and a putStrLn are more effective in forcing the check sum to be computed (which necessarily evaluates the complete updated model and reveals the lurking exception) than the seq on the line just below the logging statement? Cheers, Jeroen

4 3

Re: [Haskell-cafe] Set of Haskell programs
by Chris BROWN 15 Sep '10

15 Sep '10

Hi Ivan, HaRe itself is not Haskell 98, but for testing purposes we have used various Haskell 98 programs and test suites. One rather large full Haskell 98 program that we have used to test HaRe is nhc: http://www.cs.york.ac.uk/fp/nhc98/ nhc also comes with various Haskell 98 test suites, all of which were very useful to test various transformations (and this is all Haskell 98). Aside from nhc and its test suites, there are also exercises from Simon's text on Haskell from his webpage, that we have also used to test various refactorings: http://www.cs.kent.ac.uk/people/staff/sjt/craft2e/Code/code.html This includes some nice examples for Huffman encoding and parsing, which are all Haskell 98. I hope this helps, Kind regards, Chris. > > >> From: Ivan Lazar Miljenovic <ivan.miljenovic(a)gmail.com> >> Date: 15 September 2010 11:23:54 GMT+01:00 >> To: Enrique Martín <emartinm(a)fdi.ucm.es> >> Cc: haskell-cafe(a)haskell.org >> Subject: Re: [Haskell-cafe] Set of Haskell programs >> >> 2010/9/15 Enrique Martín <emartinm(a)fdi.ucm.es>: >>> Hello, >>> >>> I would want to ask if there is any set of "real" Haskell 98 programs >>> publicly available. I am working on a program transformation and I would >>> want to test it with several "real" programs. I think it is a good idea to >>> have a set of standard programs that people could use to check the >>> efficiency of their transformation/optimizations. >> >> HaRe is presumably. >> >> -- >> Ivan Lazar Miljenovic >> Ivan.Miljenovic(a)gmail.com >> IvanMiljenovic.wordpress.com >> _______________________________________________ >> Haskell-Cafe mailing list >> Haskell-Cafe(a)haskell.org >> http://www.haskell.org/mailman/listinfo/haskell-cafe >

1 0

Set of Haskell programs
by Enrique Martín 15 Sep '10

15 Sep '10

Hello, I would want to ask if there is any set of "real" Haskell 98 programs publicly available. I am working on a program transformation and I would want to test it with several "real" programs. I think it is a good idea to have a set of standard programs that people could use to check the efficiency of their transformation/optimizations. Thank you very much in advance, Enrique.

3 2