January 2012 - Haskell-Cafe

Serializing UTCTimes
by Bas van Dijk 21 Jan '12

21 Jan '12

Hello, What's the recommended way for serializing (with the cereal package) an UTCTime? It's easy to give Serialize instances for UTCTime and Day: instance Serialize UTCTime where get = liftM2 UTCTime get get put (UTCTime day time) = put day >> put time instance Serialize Day where get = liftM Day get put = put . toModifiedJulianDay However I have no idea how to serialize the DiffTime stored in an UTCTime: instance Serialize DiffTime where get = ? put = ? Regards, Bas

3 4

Parsing workflow
by Nils Schweinsberg 21 Jan '12

21 Jan '12

Hi! I'm having a really hard time to write a correct parser for a small language I've developed. I have been trying to write a parser using parsec, but always get a lot of error messages like "unexpected "\n", expected ..., new-line or..." when trying to run the parser. Then I read about the happy parser and really liked the separation of lexing the text into tokens and parsing the actual logic behind those tokens. Since I couldn't get familiar with the lexer "alex" I gave up on the alex-happy-approach again and went back to parsec. But with that lexer->parser idea on my mind, my parser currently looks a lot like a lexer. So I came up with the idea of using a combination of parsec and happy, where I generate a list of tokens for my text via parsec and analyse it with happy. My questions would be: - Is this a valid approach? - What is your workflow on parsing complex data structures? - What about performance? Since my project is going to be an interpreted language parsing performance might be interesting aswell. I've read that happy is in general faster than parsec, but what if I combine both of them as I said above? I guess that parsing a simple list of tokens without any nested parser structures would be pretty fast? - Do you have any other ideas on how to improve my parser? - What are your general thoughts on happy vs. parsec? Thanks for any replies, Nils

10 17

generating parens for pretty-printing code in haskell-src-exts
by Conal Elliott 21 Jan '12

21 Jan '12

I'm using haskell-src-exts together with SYB for a code-rewriting project, and I'm having difficulty with parenthesization. I naïvely expected that parentheses would be absent from the abstract syntax, being removed during parsing and inserted during pretty-printing. It's easy for me to remove them myself, but harder to add them (minimally) after transformation. Rather than re-inventing the wheel, I thought I'd ask for help. Has anyone written automatic minimal parens insertion for haskell-src-exts? -- Conal

4 3

Combining Regions and Iteratees
by oleg＠okmij.org 21 Jan '12

21 Jan '12

Regions is an automatic resource management technique that statically ensures that all allocated resources are freed and a freed resource cannot be used. Regions also promote efficiency by helping to structure the computation so that resources will be freed soon, and en masse. Therefore, regions are particularly suitable for scarce resources such as file handles, database or network connections, etc. A lightweight monadic region library is available on Hackage. Iteratee IO also aims, among other things, to encapsulate resources such as file handles and network connections, ensuring their safe use and prompt disposal. One may wonder how much Iteratees and Regions have in common and if that commonality can be factored out. There seem to be several ways to combine regions and iteratees. This message describes the most straightforward attempt, combining a monadic region library (mostly as it is) with an Iteratee IO library, also mostly as it is. We use monadic regions to manage file handles or file descriptors, ensuring that file handles are always closed even in case of IO and other asynchronous exceptions. An enumerator like enumFile provided similar guarantees for its handles. (Since an enumerator keeps its handles to itself, there is no danger of iteratees' misusing them.) With the monadic region library, the enumerator code becomes simpler: we no longer have to worry about exceptions. The main benefit of monadic region library is to manage files opened by iteratees. The latter being passed around, and so their resources are harder to keep track. We thus demonstrate enumFile and iterFile for incremental file reading and writing, with the same safety guarantees. All opened files are *always* closed, regardless of any (asynchronous) exceptions that may arise during opening, reading, writing or transforming. The code has many examples of throwing errors from various stages of the pipeline and at various times. All files are closed. The commented code is available at http://okmij.org/ftp/Haskell/Iteratee/IterReg.hs which uses the lightweight monadic regions library from http://okmij.org/ftp/Computation/resource-aware-prog/ Since lightweight monadic library needs rank-2 types (now standard), it seemed appropriate to avail ourselves to common GHC extensions. We can clearly see that enumerators and enumeratees unify, both being instances of a general type forall a. Iteratee e mi a -> mo (Iteratee e mi a) which is a Monoid. To compose enumerators or enumeratees, we use the standard mappend. An alias in the code type R e m = Iteratee e m suggests that Iteratees are the view from the right -- the System.IO, getChar-like view. From that point of view, Iteratee IO is hardly different from System.IO (getChar, getLine, peekChar, etc). The dual newtype L e mi mo = L{unL :: forall a. R e mi a -> mo (R e mi a)} is the view from the left. Here are a few examples from the IterReg code. The first simply copies one file to another, block-by-clock. tIF1 = runSIO $ run =<< unL (enumFile "/etc/motd") (iterFile "/tmp/x") According to the trace opened file /etc/motd iterFile: opening /tmp/x Closing {handle: /etc/motd} Closing {handle: /tmp/x} the files are indeed closed, but _not_ in the LIFO order. That is important, so to let an iteratee write data coming from several sources. For example: tIF3 = runSIO $ run =<< unL (enumFile "/etc/motd" `mappend` enumFile "/usr/share/dict/words") (iterFile "/tmp/x") opened file /etc/motd iterFile: opening /tmp/x Closing {handle: /etc/motd} opened file /usr/share/dict/words Closing {handle: /usr/share/dict/words} Closing {handle: /tmp/x} The files will be closed even in case of exceptions: tIF4 = runSIO $ run =<< unL (enumFile "/etc/motd" `mappend` enumFile "/nonexistent") (iterFile "/tmp/x") opened file /etc/motd iterFile: opening /tmp/x Closing {handle: /etc/motd} opened file /nonexistent Closing {handle: /tmp/x} *** Exception: /nonexistent: openFile: does not exist All monadic region monads all support shCatch, so we can write our own exception-handling code. Other examples in IterReg.hs raise errors during data transformation. Monadic regions plus GHC extensions simplify code. For example, here are iterFile and enumFile (the signatures could be omitted; they will be inferred) iterFile :: (SMonad1IO m, m ~ (IORT s' m')) => FilePath -> R ByteString m () iterFile fname = lift (newSHandle fname WriteMode) >>= loop where loop h = getChunk >>= check h check h (Chunk s) = lift (mapM (shPut h) s) >> loop h check h e = return () enumFile :: (SMonadIO m) => FilePath -> L ByteString m m enumFile filepath = L $ \iterv -> do newRgn $ do h <- newSHandle filepath ReadMode unL (enumHandle h) iterv

1 0

How to get Cabal to spit out a .a library suitable for linking into C/Objective-C
by David Pollak 21 Jan '12

21 Jan '12

Howdy, I'm trying to figure out how to get Cabal configured to compile and link my Haskell code such that the code can be part of C and/or Objective-C code such that all the Haskell dependencies are rolled into a .a file and can be linked by a normal C linker (e.g., ld). I've been through http://haskell.org/ghc/docs/6.12.2/html/users_guide/ffi-ghc.html#using-own-… the associated linked, but I'm unable to find out the Cabal incantation to output a library that's linkable into my other code. Any pointers or examples would be greatly appreciated. Thanks, David -- Visi.Pro, Cloud Computing for the Rest of Us http://visi.pro Lift, the simply functional web framework http://liftweb.net Follow me: http://twitter.com/dpp Blog: http://goodstuff.im

3 3

Re: [Haskell-cafe] How to get Cabal to spit out a .a library suitable for linking into C/Objective-C
by Donn Cave 20 Jan '12

20 Jan '12

Sorry about the belated response, but this shouldn't be a problem since it isn't going to be very helpful anyway! I've managed to follow the process described on this page: http://www.haskell.org/haskellwiki/Using_Haskell_in_an_Xcode_Cocoa_project to link Haskell code to a non-Haskell main program, via Xcode. You've probably already seen this, it's mostly about a few iterations of trial and error linking, to get the list of GHC library dependencies, which is what you need whether you're using Xcode or not. If you really need a single library with your code and all those dependencies, that may be technically feasible, though awfully tedious. The only clear problem I encountered while experimenting with it is that GHC run time options need ghc -rtsopts, so they're unavailable if your program isn't built by ghc. I believe I worked around that with a special rtsmain.o, could probably recover the details if that's of interest. Donn

2 1

In-memory Handle for testing
by Simon Hengel 20 Jan '12

20 Jan '12

For testing I want to stub handles, performing all reads and writes in memory (and in process, so no mmap). From looking at the documentation of mkFileHandle[1], I think this should be possible. But it requires some work. Is there already something out there? Cheers, Simon [1] http://hackage.haskell.org/packages/archive/base/4.4.1.0/doc/html/GHC-IO-Ha…

2 2

instance (Enum a) => IArray UArray a
by Mikhail Arefiev 20 Jan '12

20 Jan '12

Is there a reason why there is no instance of (Enum a) => IArray UArray a (other than that it will require OverlappingInstances and/or IncoherentInstances if e. g. UArray of Bools is used in the same code)? I have written one with the help of StackOverflow (http://stackoverflow.com/questions/8941386/) here is the source code: - UArrays.hs: http://hpaste.org/56728 - BenchmarkUArray.hs: http://hpaste.org/56729 - Makefile: http://hpaste.org/56727 Running the benchmark with +RTS -s on the UArray version shows 1,283,705,968 bytes allocated in the heap 113,304 bytes copied during GC 80,027,864 bytes maximum residency (2 sample(s)) 744,128 bytes maximum slop 155 MB total memory in use (0 MB lost due to fragmentation) versus 567,014,904 bytes allocated in the heap 962,651,888 bytes copied during GC 324,111,008 bytes maximum residency (3 sample(s)) 2,887,992 bytes maximum slop 545 MB total memory in use (0 MB lost due to fragmentation) on the boxed (Array Int Color) version. Also, boxed enum time is 1.75s and unboxed is 0.45s. The benchmark may be silly (I am not experienced in testing for Haskell performance), and I would be grateful for any tips on how to improve it to achieve more accurate measurements. Does having such thing make any sense? -- Best regards, Arefiev

2 1

Re: [Haskell-cafe] Why were unfailable patterns removed and "fail" added to Monad?
by Michael Snoyman 20 Jan '12

20 Jan '12

On Jan 20, 2012 8:31 AM, "John Meacham" <john(a)repetae.net> wrote: > > > As expected, no warnings. But if I change this "unfailable" code above > > to the following failable version: > > > > data MyType = Foo | Bar > > > > test myType = do > > Foo <- myType > > return () > > > > I *still* get no warnings! We didn't make sure the compiler spits out > > warnings. Instead, we guaranteed that it *never* will. > > This is actually the right useful behavior. using things like > > do > Just x <- xs > Just y <- ys > return (x,y) > > will do the right thing, failing if xs or ysresults in Nothing. for > instance, in the list monad, it will create the cross product of the > non Nothing members of the two lists. a parse monad may backtrack and > try another route, the IO monad will create a useful (and > deterministic/catchable) exception pointing to the exact file and line > number of the pattern match. The do notation is the only place in > haskell that allows us to hook into the pattern matching mechanism of > the language in a general way. > > John I mention later that this is a "feature, not a bug" to some people, but I'm not one of them. The convenience of having this feature is IMO far outweighed by the cost of the runtime errors it can produce if you use the pattern matching in the wrong monad (e.g., IO, Reader, Writer...). Michael

2 1

partial type annotations
by Nicholas Tung 20 Jan '12

20 Jan '12

Dear all, I wanted to voice support for a partial type annotations. Here's my usage scenario: I have a monad for an imperative EDSL, which has an associated expression data type, class (Monad m, Expression (ExprTyp m)) => MyDSLMonad m where data ExprTyp m :: * -> * and you write imperative EDSL code like so, my_code_block = do x <- instruction1 y <- instruction2 (x + x) ... I want the user to be able to annotate "x is an Integer". However, to do that now, one has to now add a type signature for my_code_block like so, so that the $m$ variable is in scope, my_code_block :: forall m. MyDSLMonad m => m () my_code_block = do x :: ExprTyp m Integer <- instruction1 ... If such a feature were available, one could write a nice type synonym "Expr" and use it like so, type Expr a = ExprTyp _ a my_code_block = do x :: Expr Integer <- instruction1 Suggestions for workarounds are appreciated. I created an `asExprTypeOf`, similar to Prelude's `asExprTyp`, but I don't like the syntax as much. Some previous discussion * http://www.haskell.org/pipermail/haskell/2002-April/009409.html * (a reply) http://www.haskell.org/pipermail/haskell/2002-April/009413.html * http://hackage.haskell.org/trac/haskell-prime/wiki/PartialTypeAnnotations cheers, Nicholas — https://ntung.com — 4432-nstung

6 7