June 2010 - Haskell-Cafe

Emacs script to align Haskell import list
by Christopher Done 26 Jun '10

26 Jun '10

I whipped up a little Emacs script to align the import lines in the current buffer. I am using it in my projects and have experienced no problems. It's good at keeping within 80 columns. http://gist.github.com/453933 I've pasted it as a gist on Github so that anyone can edit it, gists also provide a simple revision history and comment support. Please feel free to contribute some tweaks and fixes. I'll then see about merging this into haskell-mode in some fashion. It doesn't handle multiple line explicit imports as I have a personal rule that any explicit import list with more than a few symbols should be changed to an "as X" import, as an addition to tibbe's style guide.[1] I haven't decided on a recommended keybinding. I'm considering a context-dependent binding of C-c C-. that indents the import list when you are on an import line. [1]: http://github.com/tibbe/haskell-style-guide

1 1

Re: [Haskell-cafe] Huffman Codes in Haskell
by John Lato 26 Jun '10

26 Jun '10

> From: Max Rabkin <max.rabkin(a)gmail.com> > > This seems like an example of list-chauvinism -- what Chris Okasaki > calls a communal blind spot of the FP community in Breadth-First > Numbering: Lessons from a Small Exercise in Algorithm Design -- > http://www.eecs.usma.edu/webs/people/okasaki/icfp00.ps > Thanks for sharing; this was an interesting (and short!) read. I would like to see other Haskeller's responses to this problem. I'll restate it here hoping to get replies from those who haven't read the paper yet: Assume you have a type of labeled binary trees: data Tree a = E | T a (Tree a) (Tree a) and you are to produce a function bfnum :: Tree a -> Tree Int that performs a breadth-first numbering of the tree (starting with 1), preserving the tree structure. How would you implement bfnum? (If you've already read the paper, what was your first answer?) For the record, my solution doesn't rely on any other data structures or laziness AFAICT, and I think it would fit into the Level-Oriented category of solutions. John

6 9

Haskell Web Framework for newbies?
by Giuseppe Luigi Punzi 26 Jun '10

26 Jun '10

Hi all, At the moment, I'm learning haskell and I would like to use the things I'm learning under web. I would like to mount a local web server, but I would like to test some things in my VPS in 1&1 with CentOs 5, but this, in a near future. For the moment, my doubt is, wich is the haskell web framework more easy to learn for newbies? Cheers.

1 0

Re: [Haskell-cafe] Manual Type-Checking to provide Read instances for GADTs. (was Re: [Haskell-cafe] Read instance for GATD)
by Edward Kmett 26 Jun '10

26 Jun '10

I've obtained permission to repost Gershom's slides on how to deserialize GADTs by typechecking them yourself, which are actually a literate haskell source file, that he was rendering to slides. Consequently, I've just pasted the content below as a literate email. -Edward Kmett - Deserializing strongly typed values (four easy pieces about typechecking) Gershom Bazerman - prior art: Oleg (of course) http://okmij.org/ftp/tagless-final/course/course.html ...but also Stephanie Weirich http://www.comlab.ox.ac.uk/projects/gip/school/tc.hs = Ahem... \begin{code} {-# LANGUAGE DeriveDataTypeable, ExistentialQuantification, FlexibleContexts, FlexibleInstances, FunctionalDependencies, GADTs, RankNTypes, ScopedTypeVariables #-} \end{code} = ahem. \begin{code} import Data.Typeable import Data.Maybe import Control.Monad.Error import Control.Applicative import qualified Data.Map as M import Unsafe.Coerce \end{code} = A simple ADT. \begin{code} data SimpleExpr = SOpBi String SimpleExpr SimpleExpr | SOpUn String SimpleExpr | SDbl Double | SBool Bool deriving (Read, Show, Typeable) \end{code} Yawn. = An awesome GADT! \begin{code} data Expr a where EDbl :: Double -> Expr Double EBool :: Bool -> Expr Bool EBoolOpBi :: BoolOpBi -> Expr Bool -> Expr Bool -> Expr Bool ENumOpBi :: NumOpBi -> Expr Double -> Expr Double -> Expr Double ENumOpUn :: NumOpUn -> Expr Double -> Expr Double deriving Typeable data NumOpBi = Add | Sub deriving (Eq, Show) data NumOpUn = Log | Exp deriving (Eq, Show) data BoolOpBi = And | Or deriving (Eq, Show) \end{code} The GADT is well typed. It cannot go wrong. - It also cannot derive show. = But we can write show... \begin{code} showIt :: Expr a -> String showIt (EDbl d) = show d showIt (EBool b) = show b showIt (EBoolOpBi op x y) = "(" ++ show op ++ " " ++ showIt x ++ " " ++ showIt y ++ ")" showIt (ENumOpBi op x y) = "(" ++ show op ++ " " ++ showIt x ++ " " ++ showIt y ++ ")" showIt (ENumOpUn op x) = show op ++ "(" ++ showIt x ++ ")" \end{code} = And eval is *much nicer*. It cannot go wrong --> no runtime typechecks. \begin{code} evalIt :: Expr a -> a evalIt (EDbl x) = x evalIt (EBool x) = x evalIt (EBoolOpBi op expr1 expr2) | op == And = evalIt expr1 && evalIt expr2 | op == Or = evalIt expr2 || evalIt expr2 evalIt (ENumOpBi op expr1 expr2) | op == Add = evalIt expr1 + evalIt expr2 | op == Sub = evalIt expr1 - evalIt expr2 \end{code} = But how do we write read!? read "EBool False" = Expr Bool read "EDbl 12" = Expr Double The type being read depends on the content of the string. Even worse, we want to read not from a string that looks obvious to Haskell (i.e. a standard showlike instance) but from something that looks pretty to the user -- we want to *parse*. So we parse into our simple ADT. Then we turn our simple ADT into our nice GADT. - But how? How do we go from untyped... to typed? [And in general -- not just into an arbitrary GADT, but an arbitrary inhabitant of a typeclass.] [i.e. tagless final, etc] = Take 1: Even if we do not know what type we are creating, we eventually will do something with it. So we paramaterize our typechecking function over an arbitrary continuation. \begin{code} mkExpr :: (forall a. (Show a, Typeable a) => Expr a -> r) -> SimpleExpr -> r mkExpr k expr = case expr of SDbl d -> k $ EDbl d SBool b -> k $ EBool b SOpUn op expr1 -> case op of "log" -> k $ mkExpr' (ENumOpUn Log) expr1 "exp" -> k $ mkExpr' (ENumOpUn Exp) expr1 _ -> error "bad unary op" SOpBi op expr1 expr2 -> case op of "add" -> k $ mkExprBi (ENumOpBi Add) expr1 expr2 "sub" -> k $ mkExprBi (ENumOpBi Sub) expr1 expr2 \end{code} = Where's the typechecking? \begin{code} mkExpr' k expr = mkExpr (appCast $ k) expr mkExprBi k expr1 expr2 = mkExpr' (mkExpr' k expr1) expr2 appCast :: forall a b c r. (Typeable a, Typeable b) => (c a -> r) -> c b -> r appCast f x = maybe err f $ gcast x where err = error $ "Type error. Expected: " ++ show (typeOf (undefined::a)) ++ ", Inferred: " ++ show (typeOf (undefined::b)) \end{code} ... We let Haskell do all the work! = Hmmm... the continuation can be anything. So let's just make it an existential constructor. \begin{code} data ExprBox = forall a. Typeable a => ExprBox (Expr a) appExprBox :: (forall a. Expr a -> res) -> ExprBox -> res appExprBox f (ExprBox x) = f x tcCast :: forall a b c. (Typeable a, Typeable b) => Expr a -> Either String (Expr b) tcCast x = maybe err Right $ gcast x where err = Left $ "Type error. Expected: " ++ show (typeOf (undefined::a)) ++ ", Inferred: " ++ show (typeOf (undefined::b)) \end{code} Now we can delay deciding what to apply until later. Typecheck once, execute repeatedly! = One more trick -- monadic notation lets us extend the context of unpacked existentials to the end of the do block \begin{code} retBox x = return (ExprBox $ x, typeOf x) typeCheck :: SimpleExpr -> Either String (ExprBox, TypeRep) typeCheck (SDbl d) = retBox (EDbl d) typeCheck (SBool b) = retBox (EBool b) typeCheck (SOpBi op s1 s2) = case op of "add" -> tcBiOp (ENumOpBi Add) "sub" -> tcBiOp (ENumOpBi Sub) "and" -> tcBiOp (EBoolOpBi And) "or" -> tcBiOp (EBoolOpBi Or) where tcBiOp constr = do (ExprBox e1, _) <- typeCheck s1 (ExprBox e2, _) <- typeCheck s2 e1' <- tcCast e1 e2' <- tcCast e2 retBox $ constr e1' e2' \end{code} = So that's fine for *very* simple expressions. How does it work for interesting GADTs? (like, for example, HOAS)? (The prior art doesn't demonstrate HOAS -- it uses DeBruijn.) = Our simple world \begin{code} type Ident = String type TypeStr = String data STerm = SNum Double | SApp STerm STerm | SVar Ident | SLam Ident TypeRep STerm \end{code} Note.. terms are Church style -- each var introduced has a definite type. Determining this type is left as an exercise. = Over the rainbow in well-typed land. \begin{code} data Term a where TNum :: Double -> Term Double TApp :: Term (a -> b) -> Term a -> Term b TLam :: Typeable a => (Term a -> Term b) -> Term (a -> b) TVar :: Typeable a => Int -> Term a deriving Typeable \end{code} Wait! DeBrujin (TVar) *and* HOAS (TLam)! The worst of both worlds. Don't worry. In the final product all TVars are eliminated by construction. Exercise to audience: rewrite the code so that TVar can be eliminated from the Term type. = Show and eval... \begin{code} showT :: Int -> Term a -> String showT c (TNum d) = show d showT c (TApp f x) = "App (" ++ showT c f ++ ") (" ++ showT c x ++ ")" showT c (TLam f) = "Lam " ++ ("a"++show c) ++ " -> " ++ (showT (succ c) $ f (TVar c)) showT c (TVar i) = "a"++show i runT :: Term a -> Term a runT (TNum d) = (TNum d) runT (TLam f) = (TLam f) runT (TApp f x) = case runT f of TLam f' -> runT (f' x) runT (TVar i) = error (show i) \end{code} = The existential \begin{code} data TermBox = forall a. Typeable a => TermBox (Term a) appTermBox :: (forall a. Typeable a => Term a -> res) -> TermBox -> res appTermBox f (TermBox x) = f x \end{code} = The typechecker returns a box *and* a typeRep. Cast is the usual trick. \begin{code} retTBox :: Typeable a => Term a -> Either String (TermBox, TypeRep) retTBox x = return (TermBox $ x, typeOf x) type Env = M.Map Ident (TermBox, TypeRep) trmCast :: forall a b c. (Typeable a, Typeable b) => Term a -> Either String (Term b) trmCast x = maybe err Right $ gcast x where err = Left $ "Type error. Expected: " ++ show (typeOf (undefined::a)) ++ ", Inferred: " ++ show (typeOf (undefined::b)) \end{code} = \begin{code} typeCheck' :: STerm -> Env -> Either String (TermBox, TypeRep) typeCheck' t env = go t env 0 where go (SNum d) _ idx = retTBox (TNum d) go (SVar i) env idx = do (TermBox t, _) <- maybe (fail $ "not in scope: " ++ i) return $ M.lookup i env retTBox $ t \end{code} Nums and vars are easy. = App and Lam... less so. \begin{code} go (SApp s1 s2) env idx = do (TermBox e1, tr1) <- go s1 env idx (TermBox e2, _) <- go s2 env idx TermBox rt <- return $ mkTerm $ head $ tail $ typeRepArgs $ head $ typeRepArgs $ tr1 -- TypeReps have their... drawbacks. e1' <- trmCast e1 retTBox $ TApp e1' e2 `asTypeOf` rt go (SLam i tr s) env idx = do TermBox et <- return $ mkTerm tr (TermBox e, _) <- go s (M.insert i (TermBox (TVar idx `asTypeOf` et),tr) env ) (idx + 1) retTBox $ TLam (\x -> subst (x `asTypeOf` et) idx e) \end{code} = How does mkTerm work? \begin{code} mkTerm :: TypeRep -> TermBox mkTerm tr = go tr TermBox where go :: TypeRep -> (forall a. (Typeable a) => Term a -> res) -> res go tr k | tr == typeOf (0::Double) = k (TNum 0) | typeRepTyCon tr == arrCon = go (head $ typeRepArgs tr) $ \xt -> go (head $ tail $ typeRepArgs tr) $ \y -> k (TLam $ \x -> const y (x `asTypeOf` xt)) arrCon = typeRepTyCon $ typeOf (undefined::Int -> String) \end{code} Same principle -- but can build arrows directly. Doing so requires staying cps... I think. = And this is how we get rid of the DeBruijn terms. \begin{code} subst :: (Typeable a) => Term a -> Int -> Term b -> Term b subst t i trm = go trm where go :: Term c -> Term c go (TNum d) = (TNum d) go (TApp f x) = TApp (go f) (go x) go (TLam f) = TLam (\a -> go (f a)) go (TVar i') | i == i' = either error id $ trmCast t | otherwise = (TVar i') \end{code} Q: Now you see why DeBruijn is handy -- substitution is otherwise a pain. = But note -- all functions must be monotyped. This is the simply typed lambda calculus. How do we represent TLam (\a -> a)? The masses demand HM polymorphism. - Take 4: A damn dirty hack. = All hacks begin with Nats. \begin{code} data Z = Z deriving (Show, Typeable) data S a = S a deriving (Show, Typeable) \end{code} = typeCheck is almost the same. \begin{code} typeCheck'' :: STerm -> Env -> Either String (TermBox, TypeRep) typeCheck'' t env = go t env 0 where go :: STerm -> Env -> Int -> Either String (TermBox, TypeRep) go (SNum d) _ idx = retTBox (TNum d) go (SVar i) env idx = do (TermBox t, _) <- maybe (fail $ "not in scope: " ++ i) return $ M.lookup i env retTBox $ t \end{code} = \begin{code} go (SApp s1 s2) env idx = do (TermBox e1, tr1) <- go s1 env idx (TermBox e2, _) <- go s2 env idx TermBox rt <- unifyAppRet e1 e2 e1' <- unifyAppFun e1 e2 retTBox $ TApp e1' e2 `asTypeOf` rt go (SLam i tr s) env idx = do TermBox et <- return $ mkTerm' $ tr (TermBox e, _) <- go s (M.insert i (TermBox (TVar idx `asTypeOf` et),tr) env) (idx + 1) retTBox $ TLam (\x -> subst (x `asTypeOf` et) idx e) \end{code} It looks like we just factored on the nasty arrow code. = mkTerm is almost the same... we just extended it to deal with Nats. \begin{code} mkTerm' :: TypeRep -> TermBox mkTerm' tr = go tr TermBox where go :: TypeRep -> (forall a. (Typeable a) => Term a -> res) -> res go tr k | tr == typeOf (0::Double) = k (TNum 0) | tr == typeOf Z = k (TVar 0 :: Term Z) | typeRepTyCon tr == succCon = go (head $ typeRepArgs tr) $ \t -> k $ succTerm t | isArr tr = go (head $ typeRepArgs tr) $ \xt -> go (head $ tail $ typeRepArgs tr) $ \y -> k (TLam $ \x -> const y (x `asTypeOf` xt)) | otherwise = error $ show tr succCon = typeRepTyCon $ typeOf (S Z) succTerm :: Typeable b => Term b -> Term (S b) succTerm _ = TVar 0 \end{code} = Some utilities \begin{code} isArr :: TypeRep -> Bool isArr x = typeRepTyCon x == (typeRepTyCon $ typeOf (undefined::Int -> String)) splitArrCon :: TypeRep -> Either String (TypeRep, TypeRep) splitArrCon x | isArr x = case typeRepArgs x of [a,b] -> Right (a,b) _ -> Left $ "Expected function, inferred: " ++ show x | otherwise = Left $ "Expected function, inferred: " ++ show x \end{code} = Give an arrow term we unify it with its argument... and return a witness. \begin{code} unifyAppRet :: forall a b. (Typeable a, Typeable b) => Term a -> Term b -> Either String TermBox unifyAppRet x y = do tr <- unifyAppTyps (head $ typeRepArgs $ typeOf x) (head $ typeRepArgs $ typeOf y) return $ mkTerm' tr \end{code} = Yes. Actual unification. (although this is unification of a type template, so at least it is local) \begin{code} unifyAppTyps :: TypeRep -> TypeRep -> Either String TypeRep unifyAppTyps trf trx = do (fl,fr) <- splitArrCon trf env <- go M.empty fl trx subIt env fr where -- go yields a substitution environment. go :: M.Map String TypeRep -> TypeRep -> TypeRep -> Either String (M.Map String TypeRep) go env x y | isFree x = case M.lookup (show x) env of Just x' -> if x' == y then return env else Left (error "a") Nothing -> return $ M.insert (show x) y env | isArr x = do (lh,rh) <- splitArrCon x (lh',rh') <- splitArrCon y env' <- go env lh lh' go env' rh rh' | otherwise = if x == y then return env else Left (error "b") \end{code} = \begin{code} -- subIt applies it subIt :: M.Map String TypeRep -> TypeRep -> Either String TypeRep subIt env x | isFree x = case M.lookup (show x) env of Just x' -> return x' Nothing -> Left (error "c") | isArr x = do (lh,rh) <- splitArrCon x lh' <- subIt env lh rh' <- subIt env rh return $ mkTyConApp arrCon [lh',rh'] | otherwise = return x succCon = typeRepTyCon $ typeOf (S Z) zCon = typeRepTyCon $ typeOf Z isFree x = typeRepTyCon x `elem` [zCon, succCon] arrCon = (typeRepTyCon $ typeOf (undefined::Int -> String)) \end{code} = And now, we just have to convince GHC that they unify! \begin{code} unifyAppFun :: forall a b c. (Typeable a, Typeable b, Typeable c) => Term a -> Term b -> Either String (Term c) unifyAppFun x y = do unifyAppTyps (head $ typeRepArgs $ typeOf x) (head $ typeRepArgs $ typeOf y) return $ unsafeCoerce x \end{code} = Problem solved. On Fri, Jun 25, 2010 at 2:03 PM, Edward Kmett <ekmett(a)gmail.com> wrote: > It turns out that defining Read is somewhat tricky to do for a GADT. > > Gershom Bazerman has some very nice slides on how to survive the process by > manual typechecking (much in the spirit of Oleg's meta-typechecking code > referenced by Stephen's follow up below) > > He presented them at hac-phi this time around. > > I will check with him to see if I can get permission to host them somewhere > and post a link to them here. > > -Edward Kmett > > > On Fri, Jun 25, 2010 at 5:04 AM, <corentin.dupont(a)ext.mpsa.com> wrote: > >> >> Hello Haskellers, >> >> I'm having trouble writing a Read Instance for my GATD. >> Arg this GATD!! It causes me more problems that it solves ;) >> Especially with no automatic deriving, it adds a lot of burden to my code. >> >> >data Obs a where >> > ProposedBy :: Obs Int -- The player that proposed the tested >> rule >> > Turn :: Obs Turn -- The current turn >> > Official :: Obs Bool -- whereas the tested rule is official >> > Equ :: (Eq a, Show a, Typeable a) => Obs a -> Obs a -> Obs >> Bool >> > Plus :: (Num a) => Obs a -> Obs a -> Obs a >> > Time :: (Num a) => Obs a -> Obs a -> Obs a >> > Minus :: (Num a) => Obs a -> Obs a -> Obs a >> > And :: Obs Bool -> Obs Bool -> Obs Bool >> > Or :: Obs Bool -> Obs Bool -> Obs Bool >> > Not :: Obs Bool -> Obs Bool >> > Konst :: a -> Obs a >> >> >> > instance Read a => Read (Obs a) where >> > readPrec = (prec 10 $ do >> > Ident "ProposedBy" <- lexP >> > return (ProposedBy)) >> > +++ >> > (prec 10 $ do >> > Ident "Official" <- lexP >> > return (Official)) >> > (etc...) >> >> Observable.lhs:120:8: >> Couldn't match expected type `Int' against inferred type `Bool' >> Expected type: ReadPrec (Obs Int) >> Inferred type: ReadPrec (Obs Bool) >> >> >> Indeed "ProposedBy" does not have the same type that "Official". >> Mmh how to make it all gently mix altogether? >> >> >> Best, >> Corentin >> >> >> _______________________________________________ >> Haskell-Cafe mailing list >> Haskell-Cafe(a)haskell.org >> http://www.haskell.org/mailman/listinfo/haskell-cafe >> > >

2 1

Why my program runs out of memory?
by Vladimir Ch. 25 Jun '10

25 Jun '10

I'm trying to solve this problem: http://projecteuler.net/index.php?section=problems&id=44, and my program runs out of memory. I was wondering where I have a space leak, I thought that this program doesn't accumulate any data structures (i.e. should use constant memory): CODE BEGINS -- returns list of pairs (i, j) of indices, for which differences (gen j - gen i) -- increase, provided that gen has the following property: -- gen (i+1) - gen i > gen i - gen (i - 1) incDiffPairs gen = iterate next (0, 1) where next (i, j) = if (i == 0) || gen (j+1) - gen j < gen j - gen (i - 1) then (j, j + 1) else (i - 1, j) -- returns ith pentagonal number pentagonal i = let n = i + 1 in n * (3 * n - 1) `div` 2 -- tests if a number is pentagonal isPentagonal x = let d = 24 * x + 1 in isSquare d && (1 + sqrti d) `mod` 6 == 0 result44 = head [(pentagonal j - pentagonal i, (i, j)) | (i, j) <- incDiffPairs pentagonal, isPentagonal (pentagonal j - pentagonal i), isPentagonal (pentagonal j + pentagonal i)] CODE ENDS

2 2

Fwd: signficant improvements to the containers package
by Don Stewart 25 Jun '10

25 Jun '10

Some people might be quite excited by Milan's work on significant performance improvements to the containers package... ----- Forwarded message from Milan Straka <fox(a)ucw.cz> ----- Date: Thu, 24 Jun 2010 07:45:50 +0200 From: Milan Straka <fox(a)ucw.cz> To: Don Stewart <dons(a)galois.com> Cc: Claus Reinke <claus.reinke(a)talk21.com>, libraries(a)haskell.org Subject: Re: Map folds in containers: why no worker/wrapper split? > > Data.Map is the way it is for historical reasons. It needs a dedicated > performance maintainer to do detailed benchmarking and static analysis. I did quite a lot of benchmarking, strictness analysis and performance improvements to the containers package recently, see the draft of my paper http://fox.ucw.cz/papers/containers/containers.pdf. Next week I will start finalizing the patches and submit them. The 'not generating a worker/wrapper' issue is one of several on my radar, so this should be resolved. Cheers, Milan ----- End forwarded message -----

7 12

Read instance for GATD
by corentin.dupont＠ext.mpsa.com 25 Jun '10

25 Jun '10

Hello Haskellers, I'm having trouble writing a Read Instance for my GATD. Arg this GATD!! It causes me more problems that it solves ;) Especially with no automatic deriving, it adds a lot of burden to my code. >data Obs a where > ProposedBy :: Obs Int -- The player that proposed the tested rule > Turn :: Obs Turn -- The current turn > Official :: Obs Bool -- whereas the tested rule is official > Equ :: (Eq a, Show a, Typeable a) => Obs a -> Obs a -> Obs Bool > Plus :: (Num a) => Obs a -> Obs a -> Obs a > Time :: (Num a) => Obs a -> Obs a -> Obs a > Minus :: (Num a) => Obs a -> Obs a -> Obs a > And :: Obs Bool -> Obs Bool -> Obs Bool > Or :: Obs Bool -> Obs Bool -> Obs Bool > Not :: Obs Bool -> Obs Bool > Konst :: a -> Obs a > instance Read a => Read (Obs a) where > readPrec = (prec 10 $ do > Ident "ProposedBy" <- lexP > return (ProposedBy)) > +++ > (prec 10 $ do > Ident "Official" <- lexP > return (Official)) > (etc...) Observable.lhs:120:8: Couldn't match expected type `Int' against inferred type `Bool' Expected type: ReadPrec (Obs Int) Inferred type: ReadPrec (Obs Bool) Indeed "ProposedBy" does not have the same type that "Official". Mmh how to make it all gently mix altogether? Best, Corentin

3 2

ANN: ForSyDe DSL v3.1
by Seyed Hosein Attarzadeh Niaki 25 Jun '10

25 Jun '10

Dear All, A new version of the ForSyDe DSL is uploaded to the Hackage database. "The ForSyDe (Formal System Design) methodology has been developed with the objective to move system design to a higher level of abstraction and to bridge the abstraction gap by transformational design refinement. This library provides ForSyDe's implementation as a Haskell-embedded Domain Specific Language (DSL). For more information, please see ForSyDe's website: http://www.ict.kth.se/forsyde/." In addition to compatibility with base 4 and GHC 6.10.x, the new version provides more freedom for declaration of process functions (e.g., support for when and let blocks). BR/ Hosein Attarzadeh

1 1

ANN: parameterized-data library v0.1.4
by Seyed Hosein Attarzadeh Niaki 25 Jun '10

25 Jun '10

Dear Haskell developers, A new version of the parameterized-data library providing fixed-sized vectors (based on the type-level library) is pushed into the repository and uploaded to the Hackage database. This is only a minor update to fix the compatibility issues with base 4, GHC>=6.10 and cabal-install (not backward compatible). Bests, Hosein Attarzadeh

1 1

RE: [Haskell-cafe] proposal: HaBench, a Haskell Benchmark Suite
by Andy Georges 25 Jun '10

25 Jun '10

Hi Simon et al, I've picked up the HaBench/nofib/nobench issue again, needing a decent set of real applications to do some exploring of what people these days call split-compilation. We have a framework that was able to explore GCC optimisations [1] -- the downside there was the dependency of these optimisations on each other, requiring them to be done in certain order -- for a multi-objective search space, and extended this to exploring a JIT compiler [2] for Java in our case -- which posed its own problems. Going one step further, we'd like to explore the tradeoffs that can be made when compiling on different levels: source to bytecode (in some sense) and bytecode to native. Given that LLVM is quicly becoming a state-of-the-art framework and with the recent GHC support, we figured that Haskell would be an excellent vehicle to conduct our exploration and research (and the fact that some people at our lab have a soft spot for Haskell helps too). Which brings me back to benchmarks. Are there any inputs available that allow the real part of the suite to run for a sufficiently long time? We're going to use criterion in any case given our own expertise with rigorous benchmarking [3,4], but since we've made a case in the past against short running apps on managed runtime systems [5], we'd love to have stuff that runs at least in the order of seconds, while doing useful things. All pointers are much appreciated. Or if any of you out there have (recent) apps with inputs that are open source ... let us know. -- Andy [1] COLE: Compiler Optimization Level Exploration, Kenneth Hoste and Lieven Eeckhout, CGO 2008 [2] Automated Just-In-Time Compiler Tuning, Kenneth Hoste, Andy Georges and Lieven Eeckhout, CGO 2010 [3] Statistically Rigorous Java Performance Evaluation, Andy Georges, Dries Buytaert and Lieven Eeckhout, OOPSLA 2007 [4] Java Performance Evaluation through Rigorous Replay Compilation, Andy Georges, Lieven Eeckhout and Dries Buytaert, OOPSLA 2008 [5] How Java Programs Interact with Virtual Machines at the Microarchitectural Level, Lieven Eeckhout, Andy Georges, Koen De Bosschere, OOPSLA 2003

5 6