May 2010 - Haskell-Cafe

ShowList magic
by Abby Henríquez Tejera 17 May '10

17 May '10

Hi. I'm a Haskell newbie and there's a bit of Haskell code that I don't understand how it works. In the prelude, defining the class Show, the function showList is implemented twice, one for String and another one for other lists: showList cs = showChar '"' . showl cs where showl "" = showChar '"' showl ('"':cs) = showString "\\\"" . showl cs showl (c:cs) = showLitChar c . showl cs and showList [] = showString "[]" showList (x:xs) = showChar '[' . shows x . showl xs where showl [] = showChar ']' showl (x:xs) = showChar ',' . shows x . showl xs The thing is... how does Haskell «know» which to execute? It works even for the blank string: Prelude> show "" "\"\"" Prelude> show [] "[]" Salud, Abby

5 7

ANN: Leksah 0.8
by Jürgen Nicklisch-Franken 17 May '10

17 May '10

This is our official 0.8 release. Anyone still using 0.6 should upgrade. Anyone using an earlier 0.8 release should upgrade too (and delete ~/.leksah-0.8/prefs.lkshp and ~/.leksah-0.8/prefscoll.lkshp). There's lots of new stuff, so please have a look if you can. Let us know which of the things that aren't there you think we should work on next. Some changes in 0.8: * Workspaces (for working on projects with multiple packages) * Better metadata (includes nonexported definitions in workspace packages) * Optional downloading of prebuilt metadata for packages (you can turn this off in the first start dialog) * Better completion (keywords, language extensions, module name, non exported definitions) * Split in a client and server part (Client part doesn't import ghc-api) * Compiles with GHC 6.12 * Many bug fixes and little enhancements * Unstable and very limited Yi mode (vim bindings only for now) Not new but worth mentioning: * <Ctrl> <Enter> evaluates current line or selection in GHCi * <Ctrl> R adds missing imports To building Leksah yourself: * You need GHC 6.10 or 6.12 installed. The preferred way is current Haskell platform. * You need Gtk2Hs including the GtkSourceView2 package. (Currently gtk2hs has no release for 6.12. On Linux we suggest you use the darcs version and install it via cabal install) * cabal install leksah * leksah Making a Gtk application look nice on Windows and OS X is not easy so we recommend using one of these prebuilt binaries: http://leksah.org/packages/leksah-0.8.0.6.exe (Windows) http://leksah.org/packages/leksah-0.8.0.6.dmg (OS X) (Installation of gtk2hs for the development of gtk2hs apps is not done by these installers. Please consult http://leksah.org/download.html for more details about installation! Background information can be found in the Leksah manual: http://leksah.org/leksah_manual.pdf. Known bugs and problems: * If you have installed an earlier 0.8 version please delete your ~/.leksah-0.8/prefs.lkshp and ~/.leksah-0.8/prefscoll.lkshp * The server may occasionally allocate much memory, which has been observed on Windows. You can simply restart leksah (of leksah-server if you have started it separately) * leksah don't run with ghc-6.12.2 (http://http://hackage.haskell.org/trac/ghc/ticket/4038) Have fun Jürgen & Hamish

1 0

Getting a string from url-converted UTF8 input
by Eugene Dzhurinsky 17 May '10

17 May '10

Hello all! Can somebody please explain wha am I doing in wrong way? =============================================================== module UrlEncode where import System import Codec.Binary.UTF8.String as SU import Codec.Binary.Url as U import Data.Maybe main :: IO () main = do args <- getArgs processWithArgs args processWithArgs ("-d":[]) = getLine >>= putStrLn . maybe "" SU.decode . U.decode processWithArgs ("-e":[]) = getLine >>= putStrLn . U.encode . SU.encode processWithArgs _ = putStrLn "Usage: -e (encode) or -d (decode)" =============================================================== With this script if fed with input: =============================================================== 1%29%20%D0%B3%D0%B4%D0%B5%20%D0%BD%D1%8B%D0%BD%D1%87%D0%B5%20%D0%BC%D0%BE%D0%B4%D0%BD%D0%BE%20%D0%B1%D1%80%D0%B0%D1%82%D1%8C%20%D0%BA%D0%BD%D0%B8%D0%B6%D0%BA%D0%B8%20%D0%B2%20%D0%B2%D0%B8%D0%B4%D0%B5%20FB2%3F%0D%0A%0D%0A2%29%20%D0%BA%D0%B0%D0%BA%D0%BE%D0%B9%20%D0%B5%D1%81%D1%82%D1%8C%20%D1%81%D0%BE%D1%84%D1%82%20%D0%BD%D0%B0%20%D0%B6%D0%B5%D0%BB%D0%B5%D0%B7%D0%BA%D1%83%20%D1%82%D0%B8%D0%BF%D0%B0%20%D1%82%D0%B5%D0%BB%D0%B5%D1%84%D0%BE%D0%BD%20%D1%81%20Symbian =============================================================== I am getting the output: =============================================================== 1) 345 =K=G5 <>4=> 1@0BL :=86:8 2 2845 FB2? 2) :0:>9 5ABL A>DB =0 65;57:C B8?0 B5;5D>= A Symbian =============================================================== which is wrong. So what do I miss in encoding the data in UTF? Thank you in advance! -- Eugene Dzhurinsky

3 4

ANN: cil-0.0.1
by Tom Hawkins 16 May '10

16 May '10

CIL [1] is an OCaml library that parses and compiles C down to a simplified subset to ease different forms of static analysis. Frama-C [2] augments CIL with a property specification language (ACSL), which can capture design contracts for C functions. Frama-C's Jessie plugin uses the Why [3] software verification platform, which itself uses several different SMT solvers and proof assistances to verify ACSL function contracts -- a very cool platform, I encourage anyone interested in the verification of C programs to check it out. This Hackage library [4] is an interface to the Frama-C environment. Specifically, it provides equivalent CIL and ACSL data types, allowing CIL and ACSL based analyzers to be written in Haskell. The library installs a Frama-C/OCaml plugin, which dumps the CIL database into Haskell. Internally, both the OCaml and Haskell sides of the interface are generated by a script (GenCIL.hs) that parses the contents of the CIL type definitions (cil_types.mli). Currently it only works for the most basic C programs. A bug in either the generated OCaml plugin or Frama-C causes issues [5]. -Tom [1] http://cil.sourceforge.net/ [2] http://frama-c.com/ [3] http://why.lri.fr/ [4] http://hackage.haskell.org/package/cil [5] http://bts.frama-c.com/view.php?id=481

1 0

What makes Haskell difficult as .NET?
by Daryoush Mehrtash 16 May '10

16 May '10

In this presentation http://norfolk.cs.washington.edu/htbin-post/unrestricted/colloq/details.cgi… the speaker talks about F# on .Net platform. Early on in the talk he says that they did F# because haskell would be "hard to make as a .Net language". Does anyone know what features of Haskell make it difficult as .Net language? Daryoush

7 9

Monadic style with Streams (as in Data.Array.Parallel.Stream)
by Mark Wassell 16 May '10

16 May '10

Hi, This possibly might go against the spirit of what Stream programming is about but I having difficulties converting an imperative algorithm [1] into Haskell and think it would be easier if I was able to write it in a monadic style with operations to read and write from and to the streams. I first tried to approach it by delving into the innards of other Stream functions to devise what I needed. I only got so far and the sticking point was defining the Monad. I then approached it from the Monad side and although what I have is workable, it probably isn't going to perform (for one it uses fromStream and tailS on each read off the front of the stream). So: 1. Is this monadic style within the spirit of what Stream programming is about? 2. Is there anyway to do this more elegantly and without the user of fromStream and tailS, for example. This is the workable solution I have: module StreamMonad where import Data.Array.Parallel.Stream import Data.Monoid import Control.Monad.Writer import Control.Monad.State instance Monoid (Stream a) where mempty = emptyS mappend = (+++) type SM a b c = StateT (Stream a) (Writer (Stream b)) c readS :: SM a b a readS = do s <- get let a = head $ fromStream s put $ tailS s return a writeS :: b -> SM a b () writeS x = tell $ singletonS x t1' :: SM (Int,Int) Int () t1' = mapM_ (\_ -> do (x,y) <- readS writeS x writeS y) [1..2] t1 = fromStream $ snd $ runWriter $ runStateT t1' $ toStream [(1,2),(3,4)] -- At least this works .. t2 = fromStream $ snd $ runWriter $ runStateT t1' $ toStream [(2*x-1,2*x) | x <- [1..] ] Cheers Mark [1] The arithmentic coding and decoding algorithms given in http://mattmahoney.net/dc/dce.html#Section_32

3 3

ANN: Monad.Reader Issue 16
by Brent Yorgey 16 May '10

16 May '10

I am very pleased to announce that Issue 16 of The Monad.Reader is now available [1]. Issue 16 consists of the following three articles: * "Demand More of Your Automata" by Aran Donohue * "Iteratee: Teaching an Old Fold New Tricks" by John W. Lato * "Playing with Priority Queues" by Louis Wasserman Feel free to browse the source files [2]. You can check out the entire repository using darcs: darcs get http://code.haskell.org/~byorgey/TMR/Issue16 If you'd like to write something for Issue 17, please get in touch. The deadline will likely be sometime in September; more details will be forthcoming. -Brent [1] http://themonadreader.files.wordpress.com/2010/05/issue16.pdf [2] http://code.haskell.org/~byorgey/TMR/Issue16

9 11

Speed of Error handling with Continuations vs. Eithers
by Max Cantor 16 May '10

16 May '10

Based on some discussions in #haskell, it seemed to be a consensus that using a modified continuation monad for Error handling instead of Eithers would be a significant optimization since it would eliminate a lot of conditional branching (everytime >>= is called in the Either monad, there is a conditional. I implemented a ErrCPS monad which does exactly that, but the speed has been disappointing. It runs almost exactly 3x slower than a drop in replacement using the MonadError instance of Either from mtl. mkEMA and midError are basically toy functions but I dont know why Either is so much faster. I've experimented with putting some seq's in the bindErrCPS and even {-# INLINE (>>=) #-} in the Monad instance, but to no avail. I've copy/pasted the code below, any suggestions on optimization, or if this is simply a bad idea would be much appreciated. Strangely, compiling with -O2 seems to have no effect on the speed: -Max > {-# LANGUAGE MultiParamTypeClasses #-} > {-# LANGUAGE FlexibleInstances #-} > {-# LANGUAGE FlexibleContexts #-} > {-# LANGUAGE Rank2Types #-} > module Main where > > import Control.Applicative > import Control.Monad.Error -- hiding (foldM) > import Control.Monad.Trans > import Control.Monad hiding (foldM) > import System.Random > import Control.Monad.Identity (runIdentity, Identity) > import Control.Monad.Reader.Class > import Data.Time.LocalTime as Time -- for benchmarking > import Data.Time.Calendar (Day) > import Data.Time.LocalTime (getZonedTime) > midError :: MonadError String m => Double -> Double -> m Double > midError a b = if (b < 1) then throwError "check val" > else let r = (a + b) / 2 in r `seq` (return r) > mkEMA l = foldM midError 1 l > newtype ErrCPS e m a = ErrCPS { runErrCPS :: forall r . (e -> m r) -- error handler > -> (a -> m r) -- success handler > -> m r } > > {-# INLINE retErrCPS #-} > retErrCPS :: a -> ErrCPS e m a > retErrCPS x = ErrCPS $ \_ good -> good x > > {-# INLINE bindErrCPS #-} > bindErrCPS :: ErrCPS e m b -> (b -> ErrCPS e m a) -> ErrCPS e m a > bindErrCPS m f = ErrCPS $ \err good -> runErrCPS m err $ \x -> runErrCPS (f x) err good > > instance Monad m => Monad (ErrCPS e m) where > return = retErrCPS > (>>=) = bindErrCPS > main :: IO () > main = do > let n = 500000 > runEither e b g = either b g e > runTest f s = do > sg <- newStdGen > let l = take n $ randomRs (2, 50000) sg > mapM_ (\e -> e `seq` return ()) l > stopwatch $ f (mkEMA l) > (putStr . show) > (putStr . (s ++) . show) > > forever $ do runTest runEither "either: " > runTest runErrCPS "errCPS: " ErrCPS based code seems to run almost exactly 3x slower than the Either based code: errCPS: 37453.226 Action ran in: 30 msec either: 26803.055 Action ran in: 11 msec errCPS: 15840.626 Action ran in: 34 msec either: 32556.881 Action ran in: 10 msec errCPS: 38933.121 Action ran in: 30 msec either: 35370.820 Action ran in: 11 msec ... > > instance (Error e, Monad m) => MonadError e (ErrCPS e m) where > throwError = errCPS > catchError m f = ErrCPS $ \err good -> runErrCPS m (\e -> runErrCPS (f e) err good) good > > > -- * MTL stuff > instance MonadTrans (ErrCPS e ) where lift m = ErrCPS $ \_ good -> m >>= good > instance (MonadIO m) => MonadIO (ErrCPS e m ) where liftIO = lift . liftIO > Random utility stuff > stopwatch :: IO () -> IO () > stopwatch act = do > t1 <- getFastTimeOfDay > act > t2 <- getFastTimeOfDay > putStrLn $ " Action ran in: " ++ show (t2 - t1) ++ " msec" > type FastTimeOfDay = Int > > -- | Return the current trading day. This should respect the > -- fact that the Trading Day ranges from > -- SingTime 6am (UTC -02:00) to SST 5:59 am (UTC -1:59). > getTradingDay :: IO Day > getTradingDay = error "getTradingDay undefined" > > getFastTimeOfDay :: IO FastTimeOfDay > getFastTimeOfDay = getZonedTime >>= > (return . fastFromTimeOfDay . Time.localTimeOfDay . Time.zonedTimeToLocalTime) > > timeOfDayFromFast :: FastTimeOfDay -> Time.TimeOfDay > timeOfDayFromFast fast = Time.TimeOfDay > { Time.todHour = fromIntegral (fast `div` (3600 * 1000)) > , Time.todMin = fromIntegral (fast `div` (60 * 1000)) `mod` 60 > , Time.todSec = fromRational $ (fromIntegral fast) / 1000 > } > > fastFromTimeOfDay :: Time.TimeOfDay -> FastTimeOfDay > fastFromTimeOfDay t = fromIntegral $ > ((Time.todHour t) * 3600000) + > ((Time.todMin t) * 60000) + > (round $ 1000 * Time.todSec t) > > instance (Monad m) => Functor (ErrCPS e m) where > fmap f m = ErrCPS $ \err good -> runErrCPS m err (good . f) > > instance (Monad m) => Applicative (ErrCPS e m) where > pure = return > f <*> a = do f' <- f > a' <- a > return $ f' a' > > errCPS :: forall e m a . e -> ErrCPS e m a > errCPS e = ErrCPS $ \err _ -> err e > >

8 20

What Object Oriented Paradigms Does Haskell Support?
by John Creighton 15 May '10

15 May '10

In response to the discussion What makes Haskell difficult as .NET? http://groups.google.ca/group/haskell-cafe/browse_thread/thread/f61ee38f208… I thought I'd start a discussion on what object oriented features Haskell supports. A good reference is: Haskell's Overlooked Object System http://homepages.cwi.nl/~ralf/OOHaskell/paper.pdf The comparison is often made of Haskell's classes to interface. However, once we define an instance we have something concrete which is closer to a class under the object oriented paradigm. If our instances are paramatric: MyType a = MyType{.......child::a} Then when we can create subclass instances which are sybtypes of our Paramatric type. This gives us inheritance. Overriding might be slightly trickier. We can certainly create new instances of the parent class for a specific subtype. As a minimum we will need to specify each method we created which is not defined in terms of the others (our getters and setters) and perhaps we are allowed to over ride the methods which are derived from the other methods. Anyway, I'll do some re reading of the paper, experiment with some code and see what other options there are.

1 0

ANNOUNCE: hmumps, a MUMPS interpreter in Haskell
by Antoine Latter 15 May '10

15 May '10

Hi folks, As an educational project a few years back I started working on an interpreter for the MUMPS language in Haskell. It's got a REPL and can call into functions defined in external files. It doesn't support a lot of the built-in-functions, nor does it have support for on-disk persistent variabls (globals, in MUMPS speak). But it's on Hackage, in case anyone else is pervers enough to be interested in such a thing. I started it a few years back, so I wouldn't say it has an ideal structure. But it was surprisingly easy to come back to it and extend the parser/runtime in the past few weeks. hackage link: http://hackage.haskell.org/package/hmumps MUMPS wikipedia link: http://en.wikipedia.org/wiki/MUMPS Feedback is appreciated. Antoine

1 0