- Haskell-Cafe - Haskell.org

Grok Monad Transformers - some help needed
by Steve Horne 02 Jan '12

02 Jan '12

I'm having another go at figuring out Monad Transformers, starting at the same point I've started and stopped the last couple of times. That's this tutorial... http://blog.sigfpe.com/2006/05/grok-haskell-monad-transformers.html Onion layers, lift etc - I get that. But I've never actually got anything to work - and therefore never built the confidence to move on. Problem 1 - this is literate Haskell. I've tried feeding it to haddock - all I get is an error about it lacking a main. I don't know what to actually do with this after putting it in a *.lhs file. No big deal, but... Problem 2 - even cutting the code out, shoving it in a *.hs file, and :loading it into GHCi, I still get a lot of errors. For the functions test1 and test2, the fixes were explicit type signatures. Easy enough to figure out... test1 :: State Int (Int, Int) test2 :: State String (String, String) I guess the basic issue is the same with test3 (and though I haven't tried the others today, probably test5 and test7 too). The trouble there is that I don't know what those type signatures should be because I don't know that much about monad transformers and how they can work. I can see what's going on in the body of test3, but that is a very small amount of understanding - the type signatures are important. And I can't use :type because GHCi is rejecting the code. In short... HELP!!!

3 3

Dutch FP day 2012, January 6; ; reminder, and happy new year to all of you
by S D Swierstra 02 Jan '12

02 Jan '12

We are happy to announce that the next Dutch functional programming day will take place on January 6, 2012, at the university campus "de Uithof" of Utrecht University. The program, participants registered thus far, and further details can be found at: http://www.cs.uu.nl/wiki/bin/view/FPDag2012/WebHome If you are aware of people who might not be on the mailing list and might be interested (e.g. your students), please point this information out to them. Please do not forget to tell me that you whether you want to go to the dinner too. Best, hoping to see you all, Doaitse

1 0

Composing Enumeratees in enumerator
by Michael Craig 02 Jan '12

02 Jan '12

I've been looking for a way to compose enumeratees in the enumerator package, but I've come up with nothing so far. I want this function (=$=) :: Monad m => Enumeratee a0 a1 m b -> Enumeratee a1 a2 m b -> Enumeratee a0 a2 m b I'm building a modular library on top of enumerator that facilitates reading time series data from a DB, applying any number of transformations to it, and then writing it back / doing something else with it. I'd like to be able to write simple transformations (enumeratees) and compose them without binding them to either a db reader (enumerator) or db writer (iteratee). I've been looking at the iterIO package as a possible alternative, because it seems to allow easy composition of Inums (enumeratees). I'm a little skittish of it because it seems unpopular next to enumerator. Thoughts on these issues? Cheers, Mike S Craig

4 5

Installing glib
by Victor Miller 02 Jan '12

02 Jan '12

I have the Haskell Platform (version 7.0.4 of ghc) installed on my macbook (OS X 10.7 Lion) and I'd like to install glib. However, when I try cabal install glib, I get: cabal install glib Resolving dependencies... [1 of 2] Compiling SetupWrapper ( /tmp/glib-0.12.25777/glib-0.12.2/SetupWrapper.hs, /tmp/glib-0.12.25777/glib-0.12.2/dist/setup/SetupWrapper.o ) [2 of 2] Compiling Main ( /tmp/glib-0.12.25777/glib-0.12.2/Setup.hs, /tmp/glib-0.12.25777/glib-0.12.2/dist/setup/Main.o ) Linking /tmp/glib-0.12.25777/glib-0.12.2/dist/setup/setup ... ld: warning: could not create compact unwind for _ffi_call_unix64: does not use RBP or RSP based frame [1 of 2] Compiling Gtk2HsSetup ( Gtk2HsSetup.hs, dist/setup-wrapper/Gtk2HsSetup.o ) [2 of 2] Compiling Main ( SetupMain.hs, dist/setup-wrapper/Main.o ) Linking dist/setup-wrapper/setup ... ld: warning: could not create compact unwind for _ffi_call_unix64: does not use RBP or RSP based frame Cannot find gtk2hsC2hs Please install `gtk2hs-buildtools` first and check that the install directory is in your PATH (e.g. HOME/.cabal/bin). cabal: Error: some packages failed to install: glib-0.12.2 failed during the configure step. The exception was: ExitFailure 1 ------- I've tried cabal install gtk2hs-buildtools, and appears to complete (it does have two compilation warnings), but that doesn't help. Any suggestions? Victor Miller Here's the result cabal install gtk2hs-buildtools: bash-3.2$ sudo cabal install gtk2hs-buildtools Resolving dependencies... Configuring gtk2hs-buildtools-0.12.1... Preprocessing executables for gtk2hs-buildtools-0.12.1... Building gtk2hs-buildtools-0.12.1... [1 of 2] Compiling Paths_gtk2hs_buildtools ( dist/build/autogen/Paths_gtk2hs_buildtools.hs, dist/build/gtk2hsTypeGen/gtk2hsTypeGen-tmp/Paths_gtk2hs_buildtools.o ) [2 of 2] Compiling Main ( hierarchyGen/TypeGen.hs, dist/build/gtk2hsTypeGen/gtk2hsTypeGen-tmp/Main.o ) Linking dist/build/gtk2hsTypeGen/gtk2hsTypeGen ... ld: warning: could not create compact unwind for _ffi_call_unix64: does not use RBP or RSP based frame [1 of 2] Compiling Paths_gtk2hs_buildtools ( dist/build/autogen/Paths_gtk2hs_buildtools.hs, dist/build/gtk2hsHookGenerator/gtk2hsHookGenerator-tmp/Paths_gtk2hs_buildtools.o ) [2 of 2] Compiling Main ( callbackGen/HookGenerator.hs, dist/build/gtk2hsHookGenerator/gtk2hsHookGenerator-tmp/Main.o ) Linking dist/build/gtk2hsHookGenerator/gtk2hsHookGenerator ... ld: warning: could not create compact unwind for _ffi_call_unix64: does not use RBP or RSP based frame [ 1 of 41] Compiling DLists ( c2hs/base/general/DLists.hs, dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/DLists.o ) dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/CLexer.hs:1:12: Warning: -fglasgow-exts is deprecated: Use individual extensions instead [ 2 of 41] Compiling BaseVersion ( c2hs/base/admin/BaseVersion.hs, dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/BaseVersion.o ) [ 3 of 41] Compiling Switches ( c2hs/state/Switches.hs, dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/Switches.o ) [ 4 of 41] Compiling Map ( c2hs/base/general/Map.hs, dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/Map.o ) [ 5 of 41] Compiling FastMutInt ( c2hs/base/general/FastMutInt.hs, dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/FastMutInt.o ) [ 6 of 41] Compiling Config ( c2hs/base/admin/Config.hs, dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/Config.o ) [ 7 of 41] Compiling C2HSConfig ( c2hs/toplevel/C2HSConfig.hs, dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/C2HSConfig.o ) [ 8 of 41] Compiling CInfo ( c2hs/gen/CInfo.hs, dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/CInfo.o ) [ 9 of 41] Compiling Version ( c2hs/toplevel/Version.hs, dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/Version.o ) [10 of 41] Compiling Binary ( c2hs/base/general/Binary.hs, dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/Binary.o ) [11 of 41] Compiling Position ( c2hs/base/general/Position.hs, dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/Position.o ) [12 of 41] Compiling UNames ( c2hs/base/general/UNames.hs, dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/UNames.o ) [13 of 41] Compiling Errors ( c2hs/base/errors/Errors.hs, dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/Errors.o ) [14 of 41] Compiling Attributes ( c2hs/base/syms/Attributes.hs, dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/Attributes.o ) [15 of 41] Compiling Idents ( c2hs/base/syms/Idents.hs, dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/Idents.o ) [16 of 41] Compiling CTokens ( c2hs/c/CTokens.hs, dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/CTokens.o ) [17 of 41] Compiling CAST ( c2hs/c/CAST.hs, dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/CAST.o ) [18 of 41] Compiling CPretty ( c2hs/c/CPretty.hs, dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/CPretty.o ) [19 of 41] Compiling Lexers ( c2hs/base/syntax/Lexers.hs, dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/Lexers.o ) [20 of 41] Compiling StateTrans ( c2hs/base/state/StateTrans.hs, dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/StateTrans.o ) [21 of 41] Compiling StateBase ( c2hs/base/state/StateBase.hs, dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/StateBase.o ) [22 of 41] Compiling NameSpaces ( c2hs/base/syms/NameSpaces.hs, dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/NameSpaces.o ) [23 of 41] Compiling CAttrs ( c2hs/c/CAttrs.hs, dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/CAttrs.o ) [24 of 41] Compiling CBuiltin ( c2hs/c/CBuiltin.hs, dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/CBuiltin.o ) [25 of 41] Compiling CParserMonad ( c2hs/c/CParserMonad.hs, dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/CParserMonad.o ) [26 of 41] Compiling CLexer ( dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/CLexer.hs, dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/CLexer.o ) dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/CLexer.hs:454:17: Warning: Bindings containing unlifted types should use an outermost bang pattern: base = alexIndexInt32OffAddr alex_base s In the expression: let base = alexIndexInt32OffAddr alex_base s (I# (ord_c)) = ord c offset = (base +# ord_c) .... in case new_s of { -1# -> (new_acc, input) _ -> alex_scan_tkn user orig_input (len +# 1#) new_input new_s new_acc } In a case alternative: Just (c, new_input) -> let base = alexIndexInt32OffAddr alex_base s (I# (ord_c)) = ord c .... in case new_s of { -1# -> (new_acc, input) _ -> alex_scan_tkn user orig_input (len +# 1#) new_input new_s new_acc } In the second argument of `seq', namely `case alexGetChar input of { Nothing -> (new_acc, input) Just (c, new_input) -> let base = ... .... in case new_s of { -1# -> ... _ -> alex_scan_tkn user orig_input (len +# 1#) new_input new_s new_acc } }' dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/CLexer.hs:455:17: Warning: Bindings containing unlifted types should use an outermost bang pattern: (I# (ord_c)) = ord c In the expression: let base = alexIndexInt32OffAddr alex_base s (I# (ord_c)) = ord c offset = (base +# ord_c) .... in case new_s of { -1# -> (new_acc, input) _ -> alex_scan_tkn user orig_input (len +# 1#) new_input new_s new_acc } In a case alternative: Just (c, new_input) -> let base = alexIndexInt32OffAddr alex_base s (I# (ord_c)) = ord c .... in case new_s of { -1# -> (new_acc, input) _ -> alex_scan_tkn user orig_input (len +# 1#) new_input new_s new_acc } In the second argument of `seq', namely `case alexGetChar input of { Nothing -> (new_acc, input) Just (c, new_input) -> let base = ... .... in case new_s of { -1# -> ... _ -> alex_scan_tkn user orig_input (len +# 1#) new_input new_s new_acc } }' dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/CLexer.hs:456:17: Warning: Bindings containing unlifted types should use an outermost bang pattern: offset = (base +# ord_c) In the expression: let base = alexIndexInt32OffAddr alex_base s (I# (ord_c)) = ord c offset = (base +# ord_c) .... in case new_s of { -1# -> (new_acc, input) _ -> alex_scan_tkn user orig_input (len +# 1#) new_input new_s new_acc } In a case alternative: Just (c, new_input) -> let base = alexIndexInt32OffAddr alex_base s (I# (ord_c)) = ord c .... in case new_s of { -1# -> (new_acc, input) _ -> alex_scan_tkn user orig_input (len +# 1#) new_input new_s new_acc } In the second argument of `seq', namely `case alexGetChar input of { Nothing -> (new_acc, input) Just (c, new_input) -> let base = ... .... in case new_s of { -1# -> ... _ -> alex_scan_tkn user orig_input (len +# 1#) new_input new_s new_acc } }' dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/CLexer.hs:457:17: Warning: Bindings containing unlifted types should use an outermost bang pattern: check = alexIndexInt16OffAddr alex_check offset In the expression: let base = alexIndexInt32OffAddr alex_base s (I# (ord_c)) = ord c offset = (base +# ord_c) .... in case new_s of { -1# -> (new_acc, input) _ -> alex_scan_tkn user orig_input (len +# 1#) new_input new_s new_acc } In a case alternative: Just (c, new_input) -> let base = alexIndexInt32OffAddr alex_base s (I# (ord_c)) = ord c .... in case new_s of { -1# -> (new_acc, input) _ -> alex_scan_tkn user orig_input (len +# 1#) new_input new_s new_acc } In the second argument of `seq', namely `case alexGetChar input of { Nothing -> (new_acc, input) Just (c, new_input) -> let base = ... .... in case new_s of { -1# -> ... _ -> alex_scan_tkn user orig_input (len +# 1#) new_input new_s new_acc } }' dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/CLexer.hs:459:17: Warning: Bindings containing unlifted types should use an outermost bang pattern: new_s = if (offset >=# 0#) && (check ==# ord_c) then alexIndexInt16OffAddr alex_table offset else alexIndexInt16OffAddr alex_deflt s In the expression: let base = alexIndexInt32OffAddr alex_base s (I# (ord_c)) = ord c offset = (base +# ord_c) .... in case new_s of { -1# -> (new_acc, input) _ -> alex_scan_tkn user orig_input (len +# 1#) new_input new_s new_acc } In a case alternative: Just (c, new_input) -> let base = alexIndexInt32OffAddr alex_base s (I# (ord_c)) = ord c .... in case new_s of { -1# -> (new_acc, input) _ -> alex_scan_tkn user orig_input (len +# 1#) new_input new_s new_acc } In the second argument of `seq', namely `case alexGetChar input of { Nothing -> (new_acc, input) Just (c, new_input) -> let base = ... .... in case new_s of { -1# -> ... _ -> alex_scan_tkn user orig_input (len +# 1#) new_input new_s new_acc } }' [27 of 41] Compiling FNameOps ( c2hs/base/general/FNameOps.hs, dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/FNameOps.o ) [28 of 41] Compiling FileOps ( c2hs/base/general/FileOps.hs, dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/FileOps.o ) [29 of 41] Compiling CIO ( c2hs/base/state/CIO.hs, dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/CIO.o ) [30 of 41] Compiling State ( c2hs/base/state/State.hs, dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/State.o ) [31 of 41] Compiling C2HSState ( c2hs/state/C2HSState.hs, dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/C2HSState.o ) [32 of 41] Compiling CHSLexer ( c2hs/chs/CHSLexer.hs, dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/CHSLexer.o ) [33 of 41] Compiling CHS ( c2hs/chs/CHS.hs, dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/CHS.o ) [34 of 41] Compiling GenHeader ( c2hs/gen/GenHeader.hs, dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/GenHeader.o ) [35 of 41] Compiling CTrav ( c2hs/c/CTrav.hs, dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/CTrav.o ) [36 of 41] Compiling CNames ( c2hs/c/CNames.hs, dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/CNames.o ) [37 of 41] Compiling CParser ( dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/CParser.hs, dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/CParser.o ) [38 of 41] Compiling C ( c2hs/c/C.hs, dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/C.o ) [39 of 41] Compiling GBMonad ( c2hs/gen/GBMonad.hs, dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/GBMonad.o ) [40 of 41] Compiling GenBind ( c2hs/gen/GenBind.hs, dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/GenBind.o ) [41 of 41] Compiling Main ( c2hs/toplevel/Main.hs, dist/build/gtk2hsC2hs/gtk2hsC2hs-tmp/Main.o ) Linking dist/build/gtk2hsC2hs/gtk2hsC2hs ... ld: warning: could not create compact unwind for _ffi_call_unix64: does not use RBP or RSP based frame Warning: No documentation was generated as this package does not contain a library. Perhaps you want to use the --executables flag. Installing executable(s) in /Users/victorsmiller/Library/Haskell/ghc-7.0.4/lib/gtk2hs-buildtools-0.12.1/bin Updating documentation index /Users/victorsmiller/Library/Haskell/doc/index.html

2 1

Thanks and a happy new year!
by Ertugrul Söylemez 01 Jan '12

01 Jan '12

Dear fellow Haskellers, as I have learned so much throughout the past four years of Haskell experience, I feel obligated to thank everyone for the nice support and the great ideas. Exploring and using Haskell has changed my way of thinking about programming and computers in a profound way and made me a lot more productive. A happy new year 2012 for Haskell hacking to everyone! Many greets, Ertugrul -- nightmare = unsafePerformIO (getWrongWife >>= sex) http://ertes.de/

1 0

Twidge using hashtags
by Martin de Bruin 31 Dec '11

31 Dec '11

Hello! fairly new to twidge. Got it installed and have it setting status etc etc . I'm maintaing a local website supporting the eating of a seasonal pastry in a highly competitve fashion. A race of sorts. The contestant eating the most from january first to good friday wins. To keep the eating as transparent as possible one must report each pastry on the web. However, I feel this is not very 2012. I'm thinking about going about the new version allowing reporting to be done via twitter and picking it up with Twidge. To keep everything as much in the open as possible I'd like to have all contestants twittering the eating of a pastry mentioning the "official twitter account of the website" and throw in a hashtag like #report and then some comment. I'll then read the feed periodically via cron on the server and update the highscore database. Am I making sense? The longer I typed the above the more I started thinkng about just doing something in PHP... Any thoughts? Cheers Martin

1 0

Plugins on ghc 7.2: GHC does not export defaultCallbacks
by Brian Victor 31 Dec '11

31 Dec '11

Hi all, As a getting-my-feet-wet project I was starting to look into using plugins-auto with the yesod devel server, but I was quickly stymied because the plugins package isn't building on GHC 7.2. The error I get locally is the same as the one reported by hackage[1]. In short, defaultCallbacks seems to be gone from 7.2. It doesn't look like that function has simply been moved. So can someone give me an idea about how to proceed? Thanks! [1] http://hackage.haskell.org/packages/archive/plugins/1.5.1.4/logs/failure/gh… -- Brian

1 1

Copy .cabal folder to diff machine/user
by Vagif Verdi 31 Dec '11

31 Dec '11

Is it possible to copy .cabal and .ghc folders to different machine/ user and develop same project over there ? Or is the only way to allow a team of developers to work on the same project is to force each one of them to install all necessary packages on their machines.

2 3

Level of Win32 GUI support in the Haskell platform
by Steve Horne 30 Dec '11

30 Dec '11

I've been for functions like GetMessage, TranslateMessage and DispatchMessage in the Haskell Platform Win32 library - the usual message loop stuff - and not finding them. Hoogle says "no results found". Is this level of Win32 GUI coding supported? (other than by dealing with the FFI myself) Alternatively, should I be doing dialog-based coding and leaving Haskell to worry about message loops behind the scenes? Either way, is there an example I can use for reference? I have something along the lines of Petzolds Hello World in mind as the ideal (register a window class, handle the messages, paint some text), but anything that shows how to get a basic Win32 GUI app running in Haskell is fine.

5 6

purity and the season of good will
by Chris Dornan 30 Dec '11

30 Dec '11

(Whether readers would consider the post [or indeed this post] an act of trollery was mooted and mentioned several times in the original post - my thoughts at the end. I am writing this because I would have expected somebody to have said this by now. If it has been said then my sincere apologies. Meta issues, flames, etc., to me and not the list of course.) Pure versus Impure I suspect introducing C into this discussion may not help clarify the fundamental issue. As anyone with experience of programming in Haskell appreciates, there is a big difference between (e.g.) these two functions for taking the sum of two integers: plus :: Int -> Int -> Int plusIO :: Int -> Int -> IO Int The choice is a profound one and will affect their construction as well as the contexts they can be used and so forth. Haskell supports both styles of programming and allows them to be safely and freely intermixed with the type system guaranteeing to keep them properly separated. The type system and static semantics are critical to the Haskell approach to IO and 'purity'. I can't see how it can be meaningfully pushed into the background in any discussion or comparative discussion of these issues. In Short If the programming context in question doesn't provide any equivalent formal separation in its type system of plus-like functions and plusIO-like computations, that programmers use in practice to guide the construction of their programs, then how can the said programming context be considered equivalent to Haskell's treatment of pure functions and effects-generating computations. You just need to consider your own Haskell programming activity and how the type system keeps calculations and I/O actions separate to see this point. I doubt if any extra theory (or theology!) will add much insight. That T word Again (or not) Let's keep this forward-looking. With the email piling in as I write this, please consider whether this continuation of this discussion is likely to be helpful to the general readers of this list or whether it will confuse or discourage them, before adding to it. A Happy New Year to you, Chris From: haskell-cafe-bounces(a)haskell.org [mailto:haskell-cafe-bounces@haskell.org] On Behalf Of Steve Horne Sent: 28 December 2011 17:40 To: Haskell Cafe Mailing List Subject: [Haskell-cafe] On the purity of Haskell This is just my view on whether Haskell is pure, being offered up for criticism. I haven't seen this view explicitly articulated anywhere before, but it does seem to be implicit in a lot of explanations - in particular the description of Monads in SBCs "Tackling the Awkward Squad". I'm entirely focused on the IO monad here, but aware that it's just one concrete case of an abstraction. Warning - it may look like trolling at various points. Please keep going to the end before making a judgement. To make the context explicit, there are two apparently conflicting viewpoints on Haskell... 1. The whole point of the IO monad is to support programming with side-effecting actions - ie impurity. 2. The IO monad is just a monad - a generic type (IO actions), a couple of operators (primarily return and bind) and some rules - within a pure functional language. You can't create impurity by taking a subset of a pure language. My view is that both of these are correct, each from a particular point of view. Furthermore, by essentially the same arguments, C is also both an impure language and a pure one. See what I mean about the trolling thing? I'm actually quite serious about this, though - and by the end I think Haskell advocates will generally approve. First assertion... Haskell is a pure functional language, but only from the compile-time point of view. The compiler manipulates and composes IO actions (among other things). The final resulting IO actions are finally swallowed by unsafePerformIO or returned from main. However, Haskell is an impure side-effecting language from the run-time point of view - when the composed actions are executed. Impurity doesn't magically spring from the ether - it results from the translation by the compiler of IO actions to executable code and the execution of that code. In this sense, IO actions are directly equivalent to the AST nodes in a C compiler. A C compiler can be written in a purely functional way - in principle it's just a pure function that accepts a string (source code) and returns another string (executable code). I'm fudging issues like separate compilation and #include, but all of these can be resolved in principle in a pure functional way. Everything a C compiler does at compile time is therefore, in principle, purely functional. In fact, in the implementation of Haskell compilers, IO actions almost certainly *are* ASTs. Obviously there's some interesting aspects to that such as all the partially evaluated and unevaluated functions. But even a partially evaluated function has a representation within a compiler that can be considered an AST node, and even AST nodes within a C compiler may represent partially evaluated functions. Even the return and bind operators are there within the C compiler in a sense, similar to the do notation in Haskell. Values are converted into actions. Actions are sequenced. Though the more primitive form isn't directly available to the programmer, it could easily be explicitly present within the compiler. What about variables? What about referential transparency? Well, to a compiler writer (and equally for this argument) an identifier is not the same thing as the variable it references. One way to model the situation is that for every function in a C program, all explicit parameters are implicitly within the IO monad. There is one implicit parameter too - a kind of IORef to the whole system memory. Identifiers have values which identify where the variable is within the big implicit IORef. So all the manipulation of identifiers and their reference-like values is purely functional. Actual handling of variables stored within the big implicit IORef is deferred until run-time. So once you accept that there's an implicit big IORef parameter to every function, by the usual definition of referential transparency, C is as transparent as Haskell. The compile-time result of each function is completely determined by its (implicit and explicit) parameters - it's just that that result is typically a way to look up the run-time result within the big IORef later. What's different about Haskell relative to C therefore... 1. The style of the "AST" is different. It still amounts to the same thing in this argument, but the fact that most AST nodes are simply partially-evaluated functions has significant practical consequences, especially with laziness mixed in too. There's a deep connection between the compile-time and run-time models (contrast C++ templates). 2. The IO monad is explicit in Haskell - side-effects are only permitted (even at run-time) where the programmer has explicitly opted to allow them. 3. IORefs are explicit in Haskell - instead of always having one you can have none, one or many. This is relevant to an alternative definition of referential transparency. Politicians aren't considered transparent when they bury the relevant in a mass of the irrelevant, and even pure functions can be considered to lack transparency in that sense. Haskell allows (and encourages) you to focus in on the relevant - to reference an IORef Bool or an IORef Int rather than dealing with an IORef Everything. That last sentence of the third point is my most recent eureka - not so long ago I posted a "Haskell is just using misleading definitions - it's no more transparent than C" rant, possibly on Stack Overflow. Wrong again :-( So - what do you think?

1 0

Overloaded Quotes for Template Haskell
by Michael D. Adams 30 Dec '11

30 Dec '11

What would it take to get an "-XOverloadedQuotes" flag of the same sort as the "-XOverloadedStrings" flag? I.e. "[| ... |]" would have type "Quasi m => m Exp" instead of "Q Exp" and any splices in that quotation expect the contents of that splice to have type "m Exp". (Obviously, top level splices would still have type "Q Exp" otherwise the compiler wouldn't know how to evaluate the monad.) I ran into this problem when writing a Template Haskell program in which part of it operates in a "StateT S Q a" monad instead of the usual "Q a" monad. (The "S" type stores the state of a memoization table of code fragments already generated. Without it, the code would loop infinitely when processing certain recursive structures.) It is fairly easy to declare an instance of "Quasi" for "StateT S Q", so in order to keep the code clean, I'd like to use quotations with splices in them (i.e. [| ... $( ... ) ... |] ) for expressing the generated code. However, quotations and splices are tied to the "Q" monad which means that as it is now I have to manually write "LamE ... VarP ... VarE ... etc." instead of using the much nicer quotation syntax. Michael D. Adams mdmkolbe(a)gmail.com

2 2

Type classes in Typing Haskell in Haskell
by Alexander Bau 30 Dec '11

30 Dec '11

Hi, recently I tried the Typing Haskell in Haskell library. But I was wondering why this program type checks: > -- plusMfun is standard '+': Num a => a -> a -> a > test = let Just classEnv = ( addCoreClasses <:> addNumClasses ) > initialEnv > e = Ap ( Ap (Var "+") (Lit $ LitStr "3")) (Lit $ LitStr "5") > impl = ("foo",[([],e)]) > in > putStrLn $ pretty $ runTI $ tiImpls classEnv [plusMfun] [impl] I was expecting some kind of typechecking error, because [Char] is no instance of Num. But I get this: > ([isIn1 cNum (TAp tList tChar)], > ["foo" :>: > Forall [] > ([] :=> > (TAp tList tChar))]) The predicate says that if [Char] would be in Num then the type of the expression would be [Char]. But actually [Char] isn't in Num. So, how do I provoke a type check error in this case? Thanks in advance.

1 0

Text.Regex.Base throws exceptions with makeRegexOptsM
by Omari Norman 30 Dec '11

30 Dec '11

Hi folks, I'm using Text.Regex.Base with the TDFA and PCRE backends. I want to compile regular expressions first and make sure the patterns were actually valid, so I used makeRegexOptsM, which indicates a bad regular expression by calling fail. That allows you to use makeRegexOptsM with Maybe or with (Either String) (assuming that Either String is an instance of Monad, which of course is defined in Control.Monad.Error.) Doing this with Maybe Regex works like it should--bad pattern gives you a Nothing. But if you want to see the error message by using Either String, an exception gets thrown with the bad pattern, rather than getting a Left String. Why is this? Seems like an odd bug somewhere. I am a Haskell novice, but I looked at the code for Text.Regex.Base and for the TDFA and PCRE backends and there's nothing in there to suggest this kind of behavior--it should work with Either String. The attached code snippet demonstrates the problem. I'm on GHC 7.0.3 (though I also got the problem with 6.12.3) and regex-base-0.93.2 and regex-tdfa-1.1.8 and regex-pcre-0.94.2. Thanks very much for any tips or ideas. --Omari

3 3

IO typeclasses
by David Thomas 30 Dec '11

30 Dec '11

Is there any particular reason IO functions in the standard libraries aren't grouped into type-classes? This might allow for: 1) Testing IO code without actual input and output. (I have done this on a small scale, but it presently involves much ugliness). 2) Redirecting output of a function that neglects to take a handle without a bunch of calls to dup. 3) Forwarding IO over a connection to a remote system, allowing code written to work locally to be applied remotely, or vice-versa. 4) Wrapping dangerous IO actions in additional sanity checks. Thoughts?

2 1

Re: [Haskell-cafe] On the purity of Haskell
by Chris Smith 30 Dec '11

30 Dec '11

Sorry to cut most of this out, but I'm trying to focus on the central point here. On Thu, 2011-12-29 at 22:01 +0000, Steve Horne wrote: > In pure functional terms, the result should be equivalent to a fully > evaluated value - but putStrLn isn't pure. It cannot be fully > evaluated until run-time. And here it is, I think. You're insisting on viewing the performing of some effect as part of the evaluation of an expression, even though the language is explicitly and intentionally designed not to conflate those two ideas. Effects do not happen as a side-effect of evaluating expressions. Instead they happen because you define the symbol 'main' to be the effect that you want to perform, and then set the runtime system to work on performing it by running your program. Evaluation and effects are just not the same thing, and it makes no sense to say something isn't "evaluated" just because the effect it describes haven't been performed. It's exactly that distinction -- the refusal to conflate evaluation with performing effects -- that is referred to when Haskell is called a pure language. -- Chris Smith

4 7

ANN: ekg-0.2 - Remote monitoring of processes
by Johan Tibell 30 Dec '11

30 Dec '11

(I forgot to announce v0.1 so this is a combined announcement.) I'm proud to announce the ekg [1] library. The library lets you remotely monitor any running Haskell program, using your web browser or an automated monitoring program. The library lets you monitor garbage collector and memory usage statistics (similar to what's provided by +RTS -s, but live), but also lets you defined your own counters that you can update from within your program. For some more examples see: http://blog.johantibell.com/2011/12/remotely-monitor-any-haskell.html http://blog.johantibell.com/2011/12/more-monitoring-goodies.html 1. http://hackage.haskell.org/package/ekg

1 0

Re: [Haskell-cafe] On the purity of Haskell
by Никитин Лев 29 Dec '11

29 Dec '11

Of course we take in matter what computation "getStr :: IO [Char]" means. Of course we take in matter what computation "putStr :: String -> IO () means (I know, putStr is not computation, puStr x is computation, but it's not important) And If I want to write "echo" program, I have to combine these computation in such manner: echo = do s <- getStr putStr s But for geometry I have similarly situation. I know arithmetics and I know Pythagoras theorem and I combine arithmetics operations to get length of hypotéinusa: h x y = sqrt $ x * x + y * y. What is difference of IO actions and PURE operation *? I have to know meaning of getStr action but I have to know meaning of * operation. Side effects appears in impure languages when we can different results of function (procedure etc) with same parameters. For example, when our function use global (modifible) variable. But we WANT that ours function (Int -> Int, Char -> [a], b -> IO a - it's not matter) will be PURE, becourse it makes life of programmers easy. But I don't understand importance of thinking about "side effects" in dilemma of language vs compiled pogramm. > 30.12.2011, 02:21, "Heinrich Apfelmus" <apfelmus(a)quantentunnel.de>: > >> Gregg Reynolds wrote: >>> Donn Cave wrote: >>>> Quoth Gregg Reynolds wrote: >>>> >>>> Look again at the sentence you trimmed off the end: >>>>>> Of course, the point is that this result is an *IO action* of >>>>>> type IO Int, it's not the Int you would get "when executing >>>>>> this action". >>>> I believe that more or less points to the key to this discussion. >>>> If it didn't make sense to you, or didn't seem relevant to the >>>> question of pure functions, then it would be worth while to think >>>> more about it. >>> Ok, let's parse it out. "…it's not the int you would get 'when >>> executing this action". Close, but no cooky: it's not any kind of >>> int at all (try doing arithmetic with it). "IO Int" is a piece of >>> rhetoric for the mental convenience of the user; Haskell does not and >>> cannot know what the result of an IO action is, because it's outside >>> the scope of the language (and computation). (The "Int" part of "IO >>> Int" refers to the input, not the output; it's just a sort of type >>> annotation.) It's not even a computation, unless you want to take a >>> broad view and include oracles, interaction, etc. in your definition >>> of computation. >> Why would IO Int be something special or mysterious? It's an ordinary >> value like everything else; it's on the same footing as [Char], Maybe >> Int, Int -> String, Bool, and so on. I see no difference between the >> list [1,2,3] :: [Int] and the action "pick a random number between 1 >> and 6" :: IO Int . >> >> Best regards, >> Heinrich Apfelmus >> >> -- >> http://apfelmus.nfshost.com >> >> _______________________________________________ >> Haskell-Cafe mailing list >> Haskell-Cafe(a)haskell.org >> http://www.haskell.org/mailman/listinfo/haskell-cafe

1 0

Convert Double to Data.Fixed
by Eugene Kirpichov 29 Dec '11

29 Dec '11

Hi cafe, How do I most efficiently convert a Double to a Data.Fixed? I'm asking because I want to convert fractional seconds to the seconds field of Data.Time.TimeOfDay, which is Pico = Data.Fixed.Fixed E12. For now the fastest thing I came up with was fromIntegral (round (sec*1000000)) / fromIntegral 1000000, but this frankly sucks and is rather slow, there must be a better way. -- Eugene Kirpichov Principal Engineer, Mirantis Inc. http://www.mirantis.com/ Editor, http://fprog.ru/

2 1

Windows: openFile gives permission denied when file in use
by Michael Snoyman 29 Dec '11

29 Dec '11

Hi all, I just received a bug report from a client that, when an input file is open in FrameMaker, my program gives a "permission denied error". This bug is reproducible with a simple Haskell program: import System.IO main = do putStrLn "here1" h <- openFile "filename.txt" ReadMode putStrLn "here2" I tried writing a simple C program using fopen, and it ran just fine. Does anyone have experience with this issue, and know of a workaround? Thanks, Michael

7 16

data-structure-inferrer, standard library on steroids
by Aleksander Balicki 29 Dec '11

29 Dec '11

Hi, I'm writing a project and was wondering what other people think about it. This project is meant to be a compiler feature/wrapper that analyzes your code and chooses the best data structure depending on your source code. It analyzes the functions used on a wildcard data structure and chooses the type of structure that minimizes the time complexity. It nearly supports C language and hopefully some other languages too. The purpose is that you don't have to care which data structure to use ever again :D (hopefully, if it works well, lol). Maybe some illustrative examples: int main() { ds d; //data structure while(something) { insert(d, 5); } while(!empty(d)) { printf("%d\n, max(d)); delete_max(d); } } Here dsinf would infer some kind of a heap (or possibly a rbt with max element cache). int main() { ds d; //data structure while(something) insert(d, 5); while(something) update(d, 2, 7); while(something) delete(d, 1); printf("25 is in the set", search(d, 25)); } Here it would be hashtable (it differs from the earlier, because we don't need element ordering). if anybody wants to hack it, the C api is in dsimp/ds.h and some tests in C/tests/. I have some ideas how to extend it from trivial cases, the ideas are in github issues. repo: git clone https://github.com/alistra/data-structure-inferrer.git hackage: http://hackage.haskell.org/package/data-structure-inferrer-1.0 So just let me know what you think ;] Also does anybody know a good ~MIT licenced library of data structures written in C (they're needed for the auto-compile option)?

1 0

[ANNOUNCEMENT] SBV 0.9.24 is out
by Levent Erkok 28 Dec '11

28 Dec '11

Hello all, SBV 0.9.24 is out: http://hackage.haskell.org/package/sbv In short, SBV allows for scripting SMT solvers directly within Haskell, with built-in support for bit-vectors and unbounded integers. (Microsoft's Z3 SMT solver, and SRI's Yices can be used as backends.) New in this release are SMT based optimization (both quantified and iterative), and support for explicit domain constraints with vacuity check. Full release notes: http://github.com/LeventErkok/sbv/blob/master/RELEASENOTES Happy new year! -Levent.

1 0

[ANNOUNCE] HaskellNet-0.3 released
by Jonathan Daugherty 28 Dec '11

28 Dec '11

Hi all, I'm pleased to announce the release of HaskellNet, version 0.3. Get it on Hackage: http://hackage.haskell.org/package/HaskellNet-0.3 This release has quite a few changes; to get a comprehensive summary, see the CHANGELOG included in the package. My aim with this release was to get the code to a state where I could do further work on it and split it up into protocol-specific packages. As a result, 0.3 is likely to be the last release of this code under this name. -- Jonathan Daugherty

1 0

Haskell meta-programming
by John Lato 28 Dec '11

28 Dec '11

> From: Heinrich Apfelmus <apfelmus(a)quantentunnel.de> > > * Meta-programming / partial evaluation. When designing a DSL, it is > often the case that you know how to write an optimizing compiler for > your DSL because it's usually a first-order language. However, trying to > squeeze that into GHC rules is hopeless. Having some way of compiling > code at run-time would solve that. Examples: > ** Conal Elliott's image description language Pan > ** Henning Thielemann's synthesizer-llvm I've been thinking about this, and I suspect that meta-programming in Haskell may not be that far off. Suppose you have a Meta monad data Meta a = Meta { runMeta :: a} with the magical property that the compiler will optimize/recompile expressions of type `Meta a` when they are run via `runMeta`. That would provide usable metaprogramming, and I think it would have all the desired type properties etc. Of course no compiler currently has that facility, but we could use a different monad, perhaps something like this: data ThMeta a = ThMeta { runThMeta :: Language.Haskell.TH.ExpQ } now we just need to get the compiler to run an arbitrary TH splice and check that the types match after `runThMeta` is called. I think this is already possible via the GHC api. It would have the undesirable property that some expressions could be ill-typed, and this wouldn't be known until run-time, but it's a start. That's about as far as I got before I discovered a much more worked-out version on Oleg's site (with Chung-chieh Shan and Yukiyoshi Kameyama). Of course they've tackled a lot of the awkward typing issues that my simple construct rudely pushes onto the user. I'm probably showing my naivety here, and I haven't fully digested their papers yet, but I wouldn't be surprised to see applications using Haskell metaprogramming within a relatively short time. John L.

2 1

Re: [Haskell-cafe] If you'd design a Haskell-like language, what would you do different?
by AUGER Cédric 28 Dec '11

28 Dec '11

Le Mon, 26 Dec 2011 19:30:20 -0800, Alexander Solla <alex.solla(a)gmail.com> a écrit : > So we give meaning to syntax through our semantics. That is what this > whole conversation is all about. I am proposing we give Haskell > bottoms semantics that bring it in line with the bottoms from various > theories including lattice theory, the theory of sets, the theory of > logic, as opposed to using denotational semantics' bottom semantic, > which is unrealistic for a variety of reasons. Haskell bottoms can't > be compared, due to Rice's theorem. Haskell bottoms cannot be given > an interpretation as a Haskell value. There is no problem with Rice Theorem, you can perfectly "compare" bottoms between them, all you cannot do is to make this "compare" function both "correct" and "complete" in Haskell. By correct, I mean "(⊥==⊥)≠False", and by complete, I mean "(⊥==⊥)≠⊥". But incompleteness is very common in Haskell, and correctness is the only "real worry" when computing (comparing two non terminating values, and expecting the comparison to terminate is a mistake from the programmer). On purely theoretical side (so not in Haskell), there is no problem either. For instance, the "halting-problem" can be turned into a mathematical function φ (ie., φ ∈ ⅋(TM×{true,false}) satisfying the criteria of functionnal total relation); the only thing is that this set is not "computable". > as opposed to using denotational semantics' bottom semantic, > which is unrealistic for a variety of reasons. Indeed, it is realistic, since in real world, things are not always expected to terminate, so we have to take this into account into the semantics. Don't forget that semantics is something "upper" Haskell evaluation, it is in the purely mathematical world and can rely on non computable things as far as they are consistent with the theory. That is you cannot define a complete and correct function in pure Haskell which takes a String which can be interpreted as a Haskell function, and return a String which can be interpreted as the semantics of the Haskell function. (Of course the following function would be correct: semantics :: String -> String semantics s = semantics s and this one would be complete semantics :: String -> String semantics s = [] and there is many possible functions which are complete and correct for many inputs and many possible functions which are correct and terminate for many inputs) > Haskell bottoms cannot be given an interpretation as a Haskell > value. As a lot of others said, Haskell bottoms ARE values, so they have an interpretation as a Haskell value (itself). If a whole community doesn't agree with you, either you are right and know it and should probably run away from this community or publish a well argumented book (you won't solve in 2 lines, what the community believes in for years) either the other case (you are right but not sure, or simply you are wrong) and in this case don't try to impose your point of view, rather ask questions on the points you don't understand. For me your actual behaviour can be considered as trolling. Note that I don't say the semantics you have in mind is "wrong", I only say that the semantics of ⊥ as described in the community's paper is not "wrong"; but two different "formal" semantics can exist which give the same "observationnal" semantics.

1 0

MIDI-controlled application
by Tim Baumgartner 28 Dec '11

28 Dec '11

Hi Haskellers! I'm writing my first non-trivial Haskell application. I have an electronic drum set that generates MIDI events that I process with Haskell. A simple application of this kind might have fixed drums associated with fixed commands (I've done that). The next step would be to display menus (with very large font...) that show commands and the associated drums. The menu structure should be derived from the commands active in each context. Up to this point, I implemented this already in Java. But now after some successful attempts in Haskell, I plan for more features: the user should ultimately be able to record his own "triggers", i.e. short drum rhythms, and associate them with actions. Since I'm still a beginner with only some basic experience in Monads, Arrows and their transformers, there is infinite knowledge to be gained by working on this problem (both library and concrete apps). Currently I'm using a monad that combines Parsec (with MIDI event stream) and a Writer (that writes commands that should result in IO). It's done in a way that during running the monad, many parses can be done and failing parses roll back the parser state so that a new parse can be tried. Now my questions: I have read about Yampa, but I have not mastered it yet. E.g. I don't understand switches. Could my "triggers" be realized with Yampa's events and switches? Would you recommend any other approach? Is there something similar somewhere? Regards Tim

5 6

How hard is it to start a web startup using Haskell?
by Gracjan Polak 28 Dec '11

28 Dec '11

Hi all, The question 'How hard is it to start a technical startup with Haskell?' happened a couple of times on this list. Sometimes it was in the form 'How hard is to find Haskell programmers?' or 'Are there any Haskell jobs?'. I'd like to provide one data point as an answer: http://www.reddit.com/r/haskell/comments/ngbbp/haskell_only_esigning_startu… Full disclosure: I'm one of two that founded this startup. How are others doing businesses using Haskell doing these days? -- Gracjan

9 13

GHC 7.4 and binutils-gold
by Michael Snoyman 27 Dec '11

27 Dec '11

Hi all, One other little GHC 7.4 note. When I first tried building code with it, I got the following error message: /usr/bin/ld: --hash-size=31: unknown option Once I uninstalled binutils-gold, everything went just fine. Has anyone else experienced this? I'm running Ubuntu Oneiric. Michael

2 1

GHC 7.4: Expected behavior or bug?
by Michael Snoyman 27 Dec '11

27 Dec '11

Thanks to Mark Wright for pointing this out[1]. We have the equivalent of the following code in persistent: {-# LANGUAGE MultiParamTypeClasses #-} data Key backend entity = Key class Monad (b m) => Foo b m where func :: b m (Key b m) This code works fine with GHC 7.0, but I get the following message from GHC 7.4: Expecting two more arguments to `b' In the type `b m (Key b m)' In the class declaration for `Foo' Is this expected behavior, or a bug? If the former, what would be a possible workaround? Thanks, Michael [1] https://github.com/yesodweb/persistent/issues/31

3 5

Haskell Platform and Windows - where's 2011.4?
by Steve Horne 27 Dec '11

27 Dec '11

On haskell.org, the 2011.4.0.0 version is shown as the current stable release - but the most recent download link is for the 2011.2.0.0 version. This is bugging me a little because the documentation in the 2011.2 Haskell Platform download for Windows is broken - there's at least one bug report about this already. There's online documentation, but it's (1) online, where I need something I can read on an old no-internet laptop, and (2) I assume for the most recent version, and therefore it potentially misleading. I already fixed the "online" side - sorry, I know slurping a whole site is evil but I had little choice. The fact that the docs relate to a version of the platform that I can't access remains. I just have to hope that the changes are few and won't affect me. Extra annoying - there's no mention of why 2011.4 is missing from the Windows download page - no "temporarily delayed" or "skipped due to an awkward technical issue" or "not enough Windows developers volunteering". For all I know, it could just be an oversight updating haskell.org itself, but I think that's unlikely. So... what's the situation with the Haskell Platform on Windows? - both WRT my specific bit of whinging and whining, and in general? Is Windows a low priority niche from the Haskell POV? If I intend to take Haskell more seriously, do I need to make Linux or some other *nix my primary OS? Please say no - I've been an on-and-off Linux user for around 10 years, with the most recent 2 years on ending around May this year. For all the pros, the cons of endless graphics card driver issues, awkward configuration hassles and so on have defeated me yet again.

3 4

[ANNOUNCEMENT] github 0.1.1
by Mike Burns 27 Dec '11

27 Dec '11

The Github API now has a fancy Haskell library for accessing it, and this library is named: github. http://hackage.haskell.org/package/github https://github.com/mike-burns/github The module structure reflects the Github API v3 documentation. It currently only supports the non-authenticated parts of the API. It does not support a few API endpoints which are documented by Github but which don't work under a command-line curl. I love pull requests, so send 'em!

1 0

ANNOUNCE: hxournal-0.5.0.0 - A pen notetaking
by Greg Weber 27 Dec '11

27 Dec '11

I got the program installed after creating the libstdc++.so symlink. No ink shows up from my drawing though. I am on a Thinkpad X201 Tablet and xournal works. I am glad you are experimenting with window splits. I think the worst part of xournal is it constrains you to a notebook-width piece of paper.

2 2

ANNOUNCE: xournal-convert-0.1
by Ian-Woo Kim 27 Dec '11

27 Dec '11

Hi, all, I have uploaded a utility program xournal-convert which is a command-line utility for changing xournal file format to various other formats. Currently, converting xournal file format (xoj) to several SVG files for each page and index.html for navigating all those pages are implemented. I will support more output formats as I implement. I think that SVG/html support must be useful to some people as it is now. This program depends on xournal-types, xournal-render and xournal-parser libraries which are also used for hxournal program ( a notetaking program written in haskell. similar to xournal) Installation should be simple. Just type > cabal update > cabal install xournal-convert In command line, you can run the program like > xournal-convert makesvg --dest=[destination folder] xojfilename Currently, this program only accepts gunzipped xoj file. For xoj file you generated from xournal program, you need to rename the file as xxx.xoj.gz (xxx is some filename) and gunzip xxx.xoj.gz to make gunzipped xoj format file. For files from hxournal, you can just use the file directly. By this program, you can simply generate static webpages for each xournal file. I personally found this useful for reading my notes on the web. Note: As for hxournal, the current version is 0.6.1.0. It currently supports pdf background and has undo/redo and smoother scrolling (not completed yet though). If you are interested, please try the latest version. Thank you for your interest. Happy holidays. best regards, Ian-Woo Kim

1 0

Re: [Haskell-cafe] If you'd design a Haskell-like language, what would you do different?
by Hans Aberg 27 Dec '11

27 Dec '11

On 26 Dec 2011, at 16:11, AUGER Cédric wrote: >> There is >> http://www.stixfonts.org/ >> For typesetting with Xe[La]TeX or Lua[La]TeX, use XITS (in the >> TeXLive package). >> >>> (And then we'll have to deal with folks trying to use the letter, >>> because everyone knows the Roman alphabet is the only one that >>> matters and of *course* Greek letters are symbol characters.... >>> Pfeh.) >> >> This is the big problem right now: how to enter these symbols >> efficiently. > > Under Xorg, "XCompose" might be your friend! I have a whole bunch of > them for Coq programing. > > Having something like: > > ---------8<--------------------------------------------------------- > # ~/.XCompose contents: > > # the Compose file of the xorg distribution to have a lot > # of useful symbols such as "☭" ^^ > include "/usr/local/lib/X11/locale/en_US.UTF-8/Compose" > # the Compose file that could be included in Haskell distributions > include "/usr/local/share/haskell/Compose" > # other personnal notations > ------->8----------------------------------------------------------- > # /usr/local/share/haskell/Compose contents: > > # maybe to be downloaded via a Hackage cabal package? > # of course "<Multi_key> <H>" should be replaced by a > # user specified combo > <Multi_key> <H> <colon> <colon> : "∷" > <Multi_key> <H> <greater> <greater> <greater> : "⋙" > <Multi_key> <H> <less> <less> <less> : "⋘" > <Multi_key> <H> <less> <minus> <less> : "↢" U2919 > <Multi_key> <H> <greater> <minus> <greater> : "↣" U291A > <Multi_key> <H> <minus> <less> <less> : U291B > <Multi_key> <H> <greater> <greater> <minus> : U291C > <Multi_key> <H> <a> <l> <l> : "∀" > <Multi_key> <H> <e> <x> : "∃" > <Multi_key> <H> <a> <n> <d> : "∧" > <Multi_key> <H> <o> <r> : "∨" > <Multi_key> <H> <a> <b> <s> <t> : "λ" > <Multi_key> <H> <c> <o> <m> <p> : "∘" > <Multi_key> <H> <minus> <greater> : "→" > --------8<---------------------------------------------------------- > > But if you are under Windows, or Mac OS, I cannot tell (as well as I > cannot tell if you are under a POSIX system not running xorg, such as > the tty1..ttyn consoles) On OS X one can make ones owns key maps, like with the program on the link below, but it is very time consuming. Hans http://scripts.sil.org/cms/scripts/page.php?site_id=nrsi&id=ukelele

3 4

Non-exhaustive pattern match warning (incorrect?)
by Michael Orlitzky 26 Dec '11

26 Dec '11

I'm cleaning up some old projects, and hit this: src/Octet.hs:47:27: Warning: Pattern match(es) are non-exhaustive In a record-update construct: Patterns not matched: Octet.None But in the source, I've checked for that case: class Maskable a where apply_mask :: a -> Maskbits -> Bit -> a instance Maskable Octet where apply_mask _ Maskbits.None _ = Octet.None apply_mask Octet.None _ _ = Octet.None apply_mask oct mask bit | mask == Eight = oct | mask == Seven = oct { b8 = bit } -- Line 47 ... | otherwise = Octet.None Am I overlooking something, or did I already match Octet.None?

2 4

[ANNOUNCE] HaskellNet has a new maintainer
by Jonathan Daugherty 26 Dec '11

26 Dec '11

Hi all, I recently took over maintenance duties for the HaskellNet library from its previous maintainer, Robert Wills: http://hackage.haskell.org/package/HaskellNet The codebase has been moved to GitHub: https://github.com/jtdaugherty/HaskellNet So far my focus on HaskellNet has been code cleanup and pruning. Once I'm confident I didn't introduce any silly bugs, I'll do a new release on Hackage. After that, I plan to: - Write protocol tests against scripted installations of popular implementations, such as Dovecot - Split up HaskellNet into SMTP, IMAP, and POP packages So, if you are a HaskellNet user and have an interest in these changes, speak up! In addition, if you are interested in maintaining one or more of the resulting smaller packages (especially POP), let me know! Thanks, -- Jonathan Daugherty

1 0

Re: [Haskell-cafe] If you'd design a Haskell-like language, what would you do different?
by Hans Aberg 26 Dec '11

26 Dec '11

On 26 Dec 2011, at 19:29, AUGER Cédric wrote: > Le Mon, 26 Dec 2011 18:20:55 +0100, > Hans Aberg <haberg-1(a)telia.com> a écrit : > >> On 26 Dec 2011, at 16:11, AUGER Cédric wrote: >> >>> Under Xorg, "XCompose" might be your friend! I have a whole bunch of >>> them for Coq programing. >>> >>> Having something like: >>> >>> ---------8<--------------------------------------------------------- >>> # ~/.XCompose contents: >>> >>> # the Compose file of the xorg distribution to have a lot >>> # of useful symbols such as "☭" ^^ >>> include "/usr/local/lib/X11/locale/en_US.UTF-8/Compose" >>> # the Compose file that could be included in Haskell distributions >>> include "/usr/local/share/haskell/Compose" >>> # other personnal notations >>> ------->8----------------------------------------------------------- >>> # /usr/local/share/haskell/Compose contents: >>> >>> # maybe to be downloaded via a Hackage cabal package? >>> # of course "<Multi_key> <H>" should be replaced by a >>> # user specified combo >>> <Multi_key> <H> <colon> <colon> : "∷" >>> <Multi_key> <H> <greater> <greater> <greater> : "⋙" >>> <Multi_key> <H> <less> <less> <less> : "⋘" >>> <Multi_key> <H> <less> <minus> <less> : "↢" U2919 >>> <Multi_key> <H> <greater> <minus> <greater> : "↣" U291A >>> <Multi_key> <H> <minus> <less> <less> : U291B >>> <Multi_key> <H> <greater> <greater> <minus> : U291C >>> <Multi_key> <H> <a> <l> <l> : "∀" >>> <Multi_key> <H> <e> <x> : "∃" >>> <Multi_key> <H> <a> <n> <d> : "∧" >>> <Multi_key> <H> <o> <r> : "∨" >>> <Multi_key> <H> <a> <b> <s> <t> : "λ" >>> <Multi_key> <H> <c> <o> <m> <p> : "∘" >>> <Multi_key> <H> <minus> <greater> : "→" >>> --------8<---------------------------------------------------------- >>> >>> But if you are under Windows, or Mac OS, I cannot tell (as well as I >>> cannot tell if you are under a POSIX system not running xorg, such >>> as the tty1..ttyn consoles) >> >> On OS X one can make ones owns key maps, like with the program on the >> link below, but it is very time consuming. >> http://scripts.sil.org/cms/scripts/page.php?site_id=nrsi&id=ukelele >> > I have heard of ukelele (but I didn't remembered the name as I am not > a Mac OS user); I have heard it was a rather dirty solution, but that > should work. I think so, too. > I guess that having a Haskell (or any script language by > the way) patching the xml file (and able to "unpatch" if we want to > uninstall) and make possible to get that patch via Hackage could be a > solution (it would be time consuming for the patch writer, but then > any Mac OS user would benefit it). > > Of course it would only work for the basic Haskell notations, for > custom ones, I guess it would be interesting to have a program which > reads a "XCompose like" file (which is quite easy to edit) and generate > the xml file for ukelele. > > Note that the rest of the Haskell cafe mailing list won't be able to > read my response since it seems that I cannot post on the list (I > subscribed 2 years ago and never posted; waiting to learn and Haskell > and then read the mailing list, but I learnt Haskell only about one > month ago). If one had a way to replace ASCII multicharacter symbols, that might be easier. Hans

1 0

parListChunk problem
by Burak Ekici 26 Dec '11

26 Dec '11

Hi there, I was not able to parallelize the below code by "parListChunk" strategy. Actually, code works fine without ant mistake in the result but no improvement in the performance handled. Threadscope demonstrates that parallelization happens after the sequential run of the program which is meaningless. In short, parListChunk is not working as intended. As far as I know, it should divide an arbitrarily given list into its chunks and then apply the given function to each sub-list (chunk) in parallel with reducing the evaluation of each element of each chunk into head normal form, if you use "rdeepseq" as the input strategy. In the below code, I want to divide the given list into 2000 chunks and then apply "ersa" function to each chunk in parallel with evaluating each element into its head normal form in serial internally. However, as I wrote, it first runs in serial after than the parallel scenario I admire to happen at the beginning happens. How can I solve this problem? Thanks in advance, Burak. ersa :: RSAPublicKey -> [Integer] -> [Integer] ersa (PUB n e) (x:xs) = ersa (PUB n e) (xs) ++ [expm n x e] ersa (PUB n e) [] = [] splitToEnc :: RSAPublicKey -> [Integer] -> [Integer] splitToEnc (PUB n e) [] = [] splitToEnc (PUB n e) (x:xs) = (ersa (PUB n e) (x:xs)) `using` parListChunk 2000 rdeepseq

1 0

Siege, a DBMS written in Haskell
by Daniel Waterworth 25 Dec '11

25 Dec '11

Hi all, This is what I've been working on recently in my spare time, https://github.com/DanielWaterworth/siege . It's a DBMS written in Haskell, it's in a partially working state, you can start it up and interact with it using the redis protocol, it implements a subset of redis's commands. It stores it's data in immutable trees and supports two backends, one where it stores data to disk and another where it stores it's immutable nodes in a redis cluster and the head reference in zookeeper; the plan is to be CP in CAP theory. Feel free to butcher it for your own needs and I'd be really grateful to anyone who'd like to contribute. Daniel

1 0

Images in Haddock documentation: best practices?
by Brent Yorgey 25 Dec '11

25 Dec '11

Hi all, Although it doesn't seem to be documented in the user manual (!), Haddock supports inline images, using a <<url>> syntax. I'd like to include some images in the documentation for a package I'm writing, but not sure of the best way. I can, of course, just make the images available under my UPenn personal web space, and link to them from the documentation. But this seems fragile and ad-hoc. Ideally, I'd like to bundle the images along with the cabal package, and reference them locally from within the documentation. But I haven't figured out a way to do this. Any ideas? Has anyone ever included images in Haddock docs before? Is it possible to bundle them with the package and refer to them locally? Or does anyone have any other suggestions? Are there specific ways Haddock and/or cabal could be improved to make this easier? -Brent

3 2

book.realworldhaskell.org is down
by Eugene Kirpichov 25 Dec '11

25 Dec '11

See subject. Is this expected? -- Eugene Kirpichov Principal Engineer, Mirantis Inc. http://www.mirantis.com/ Editor, http://fprog.ru/

2 2

Parallel Karatsuba - A Weird speed up value greater than 4 on an Intel Quadcore CPU!
by Burak Ekici 25 Dec '11

25 Dec '11

Dear List, I am trying to parallelize Karatsuba multiplication with Haskell's second generation strategies. Although, I am running the code on an Intel quad-core CPU, I abnormally have a speedup much greater than 4, around 10, which means a weird parallelization or something occurs. I would be appreciated, if anyone make some comments on the issue explaining the possible reasons why this weird incident occurs? Here is the basic parallel portion of the code: karatsuba :: Int -> [Bool] -> [Bool] -> [Bool] karatsuba _ [] _ = [] karatsuba _ _ [] = [] karatsuba currentDepth xs ys | (l < 32 || currentDepth >= limit) = mul xs ys | otherwise = (x `add` (replicate l False ++ (z `add` (replicate l False ++ y)))) `Main.using` strategy where l = (min (length xs) (length ys)) `div` 2 (xs0, xs1) = splitAt l xs (ys0, ys1) = splitAt l ys x = (normalize (karatsuba (currentDepth+1) xs0 ys0)) y = (normalize (karatsuba (currentDepth+1) xs1 ys1)) z = ((karatsuba (currentDepth+1) (add xs0 xs1) (add ys0 ys1)) `sub` (normalize (karatsuba (currentDepth+1) xs0 ys0)) `sub` (normalize (karatsuba (currentDepth+1) xs1 ys1))) strategy res = do (Main.rpar) (x) (Main.rpar) (y) (Main.rpar) (z) Main.rdeepseq res Many thanks in advance and kind regards. Saluti, Burak.

3 6

Parallel Haskell Digest 7
by Eric Kow 24 Dec '11

24 Dec '11

Parallel Haskell Digest 7 ========================= 2011-12-24 Hello Haskellers! GHC 7.4 is coming! There is loads to look forward to, but sometimes, it's the little things that count. For example, do you hate the fact that you can't just flip on an `+RTS -N` without having to first recompile your program, this time remembering to throw an `-rtsopts` on it? Duncan Coutts has relaxed the requirement so that commonly used RTS options can be used without it. This flag was originally implemented to counter security problems for CGI or setuid programs; however, it was also a hassle for regular users because it got in the way of common options like `-eventlog`, `-N`, or `-prof`. The GHC 7.4 RTS will make a better tradeoff between security and convenience, allowing a common set of benign flags without needing `-rtsopts`. That's the sort of thing that the Parallel GHC Project is about. We want to push parallel Haskell out into the real world, first by helping real users (our ~~guinea pigs~~ industrial partners) to apply it to their work, second by making it easier to use (tools, libraries), and finally communicating more about it (this digest). In this month's digest, we'll be catching up on news from the community. After the holidays, we'll be back with some new words of the month exploring a bit of concurrent Haskell. In the meantime, happy hacking and Merry Christmas! News ---------------------------------------------------------------------- [Job Opportunity at Parallel Scientific][ph-job] Peter Braam wants you, parallel Haskeller! > Parallel Scientific, LLC is a Boulder, CO based early stage, but funded > startup company working in the area of scalable parallelization for > scientific and large data computing. We are implementing radically new > software tools for the creation and optimization of parallel programs > benefiting applications and leveraging modern systems architecture. We > build on our mathematical knowledge, cutting edge programming languages and > our understanding of systems software and hardware. We are currently > working with the Haskell development team and major HPC laboratories world > wide on libraries and compiler extensions for parallel programming. Note the mandatory Haskell experience and the desirability of “in depth knowledge of core Haskell libraries for parallel programming (NDP, REPA etc)”. Parallel GHC Project Update ---------------------------------------------------------------------- The Parallel GHC Project is an MSR-funded project, run by Well-Typed, with the aim of demonstrating that parallel Haskell can be employed successfully in real world projects. Our most recent work has been in polishing the upcoming ThreadScope release that we previewed this September at the Haskell Implementor's Workshop. This new release comes with goodies for users of Strategies or the basic `par/pseq` parallelism: spark creation/conversion graphs, visualisations showing your spark pools filling and emptying, and histograms displaying the distribution of spark sizes. All this with the aim of helping you gain deeper insight, not just what your program is doing but *why*. We've also done backend work to make ThreadScope even more useful further down the road. First, we have improved the ghc-events package by encoding the meanings of events in state machines. This makes it possible to validate eventlogs, and doubles as an always up-to-date source of code as documentation. Second, we have extended the GHC RTS to emit the startup wall-clock time and Haskell threads labels to the eventlog. The wall-clock time event allows us to synchronise logs for simultaneous processes, brining us a step closer to using ThreadScope on distributed programs. Named Haskell thread make it easier to distinguish threads from each other. Finally, we have been exploring the use of Cloud Haskell for high performance computing on clusters. To do this we would need to abstract Cloud Haskell over different transport mechanisms, that is to develop a robust Cloud Haskell implementation sitting on top of a swappable transport layer. We have posted an [initial design][mc3] for this layer on the parallel-haskell list. We have taken the substantial feedback into consideration and will be sending a revised design and recording it in a page on the GHC wiki. Meanwhile, we are working to further validate our design on simple models of both the transport layer and a cloud Haskell layer on top. Longer term, we aim to implement some transports, an IP transport in particular and perhaps a single-node multi-process transport using forks and pipes. Tutorials and Papers ---------------------------------------------------------------------- * [Tutorial: Deterministic Parallel Programming in Haskell][hal6] (7 Oct) Well-Typed's Andres Löh presented a parallel programming tutorial at the recent Haskell in Leipzig meeting. The tutorial comes with slides, exercises, sample code. It paints a picture of the parallel Haskell landscape, and then focuses on one of the many possible approaches (namely, strategies). One nice feature of the tutorial is an emphasis on practicalities, for example, on using ThreadScope to figure out where performance goes wrong in a program. So if you're looking for a way to get started using on parallelism to speed up your Haskell code, give Andres' tutorial a try! * [Parallel Genome Assembly with Software Transactional Memory][stm-ketil] (27 Oct) Ketil Malde wrote up some of his experiences using STM to parallelise an inherently complicated program best solved with multiple interacting threads. His article demonstrates that a program using STM is able to successfully parallelize the genome scaffolding process with a near linear speedup. Ketil would be interested in any feedback the community may have. Blogs and Packages ---------------------------------------------------------------------- ### Actors, actors everywhere * [remote: Cloud Haskell is here!][b1] (27 Oct) You may have been hearing a lot about Cloud Haskell lately, the new Erlang-ish distributed programming library for Haskell. Now's your chance to see what all the fuss is about! Jeff Epstein has uploaded the remote package to Hackage, so take it for a spin by doing cabal update cabal install remote Library documentation is on the Hackage page, and more details are available in the paper [Towards Haskell in the Cloud][ch-paper] * [Distributed storage in Haskell][b2] (30 Oct) So what are people doing with Cloud Haskell? Julian Porter for one has been working on a distributed monadic MapReduce implementation. Along the way he's produced a general proof of concept for distributed storage. Have a look at Julian's page for a short paper and GitHub page. * [simple-actors 0.1.0 released][b3] (11 Oct) Brandon Simmons accounced simple-actors, an EDSL-style library for writing more structured concurrent programs, based on the Actor Model. It was designed for local concurrency, as an alternative to ad-hoc use of Chans, but could be extended to a distributed system by defining appropriate [SplitChan][SplitChan] instances for some network "channel". * [Haskell Actors][b4] (28 Oct) Martin Sulzmann wishes he'd named his [actor package][mh-actor] “multi-headed-actor”. With the recent interest in actor style concurrency in Haskell, there may be some confusion about the various packages that are out there. The point in Martin's library is being to pattern match over multiple events in the message queue, which makes it easier elegantly express ideas like a marketplace actor which matchmakes buyer/seller messages. While Martin's library is built on concurrent channels, it could be adapted to use distributed channels provided by haskell-mpi or Cloud Haskell. See the paper for more information [Actors with Multi-Headed Message Receive Patterns][mh-actor-pdf]. ### More concurrency * [stm-stats: Retry statistics for STM transaction][b5] (9 Oct) Joachim Breitner blogged about the stm-stats package, which provides wrappers around `atomically` to track how often a transaction was initiated and how often it was retried. The stm-stats library is used interally by Factis research, but recently released to the wider Haskell community. In fact, Factis have recently hired Joachim to help them contribute back to the Free Software community where possible. So, thanks, Factis and congratulations, Joachim! * [How to deal with concurrent external events?][b6] (11 Oct) Apfelmus has been scratching his head over a design problem for event-based frameworks such as GUI libraries: how do you deal with events that occur while you are currently handling another event? Apfelmus gave a simple wxHaskell demonstrator illustrating the problem, (A) reacting to an event while handling another one may expose internal invariants but (B) reacting to an event after finishing another one may render it “impossible”, i.e. it should not have happened in the first place. Any thoughts on the dilema? * [Concurrency And Foreign Functions In The Glasgow Haskell Compiler][b7] (24 Oct) Leon P. Smith posted an overview of the interaction between Haskell concurrency and FFI calls in GHC. Leon's post walks us through some the basic concepts: capabilities, Haskell threads, OS threads, and bound threads. This could be good place to start before delving into papers or library documentation. * [iteratee-stm][b8] (4 Nov) John Lato announced the new iteratee-stm library recently uploaded to Hackage. Iteratee-stm provides an iteratee interface that uses bounded TChans for communication. This makes it simple to run IO in a separate thread from processing. ### Parallelism * [Automatic deparallelization][b9] (17 Nov) Ken Takusagawa explored a different perspective on parallelism. Instead of adding parallelism to programs, what if we started with too much parallelism and stripped it away to fit reality? > Consider always writing code in a style using egregious fine > grained parallelism: assume lots of cores with no communication > latency and no overhead. > > It is the compiler's job to deparallelize (unparallelize, > serialize) the program to run on the actual number of cores > available, taking into account communication latency and the > overhead of parallelization Oh, and [qkhsskbg] ([Document Refinding Key][doc-refind]) * [Introducing Speculation][b10] (22 Jul 2010) Recently, I got a chance to catch up with Edward Kmett, getting my mind twisted into delightful funny shapes in the process. Edward mentioned his speculation library, yet more parallelism in Haskell! The library is based on the paper [Safe Programmable Speculative Parallelism][sps-par] by Prakash Prabhu et al. It provides a way to parallelise inherently sequential algorithms (eg. lexing, Huffman decoding) by guessing the value of intermediate results. You start working in parallel to build work off the guess, only discarding it if the guess turns out to be wrong later on. Check out Edward's blog and slides for more details. * [Quasicrystals as sums of waves in the plane][b11] (24 Oct) Keegan McAllister posted an somewhat hypnotic animation of quasicrystals. His post comes with complete source code for his program using the Repa parallel arrays library. Repa was useful to Keegan because it provides * Immutable arrays, supporting clean, expressive code * A fast implementation, including automatic parallelization * Easy output to image files, via repa-devil * [Simple library for CAS posted][b12] (7 Dec) Ryan Newton released IORefCAS, which provides a drop-in replacement for atomicModifyIORef that takes advantage of the new `casMutVar#` primop from GHC 7.2. Ryan says that “[b]ecause it's an easy change it might be worth trying that for hot IOrefs in your parallel app.” * [OpenCL 10.2.2][b13] (23 Nov) Luis Cabellos has updated the Haskell OpenCL package with better documentation and improved error handling using Control.Exception instead of Either error. Mailing list discussions --------------------------------------------------------------------- ### Help wanted * [Alternative STM implementation][mh1] (10 Dec) Daniel Waterworth shared his [alternative STM implementation][stm-danielw], written as a learning exercise. Could anybody provide Daniel with some criticism and pointers to STM benchmarks for comparison? His replacement should drop right in if you only use TVars. * [Parallel Matrix Multiplication][mh2] (10 Dec) Mukesh Tiwari is trying to teach himself parallel Haskell (welcome!). He's gone through Real World Haskell and the [tutorial][afp08] by Simon Peyton-Jones and Satnam Singh, but now trying to implement a parallel matrix multiplication function, he finds himself with no sparks converted. Can anybody give Mukesh a hand? Mukesh also asked about resources for Parallel Haskell, which would be where I come in. Mukesh, have a look at the parallel Haskell portal: <http://www.haskell.org/haskellwiki/Parallel> ### Cloud Haskell * [Cloud Haskell now on Hackage][mc1] (27 Oct) Jeff Epstein's announcement that he had uploaded “remote” to Hackage was greeted with joy and a somewhat lengthy discussion on package/module naming. It looks like the modules will be moved from 'Remote' to 'Control.Distributed.Actor' or 'Control.Distributed.Process' to match the approach used for the concurrency packages. The final package name seems to be [distributed-process][ch-dp]. ![Anyone got a paintbrush?](bikeshed.jpg) * [Haskell Cloud and Closures][mc2] (1 Oct) Fred Smith gave Cloud Haskell a try, using it to remotely compute the plus function. Now he wants to be able to send a function to a remote host, no matter if the function is locally declared or at the top level. Erik de Castro Lopo replied that this was a known limitation with the only known workaround being to move the required function to the top-level. Chris Smith pointed out that while the current restrictions may be too tight, there is good reason to have them. As for alternatives approaches to serialising functions, David Barbour suggested maybe looking at the [tangible values][tv] work by Conal Elliot. * [Feedback on Cloud Haskell transport layer interface][mc3] (2 Nov) As I mentioned in the Parallel GHC Project update, we've been looking quite a bit into Cloud Haskell lately. Duncan Coutts posted a request for feedback on the design for a Cloud Haskell transport layer interface. We're hoping one day to make use of Cloud Haskell on for high performance computing on clusters. To do this, we hope to develop a robust Cloud Haskell implementation sitting on top of a swappable transport layer, for example, an IP transport, or a single-node multi-process transport using forks and pipes. One issues that emerged from the discussion is how to deal with potentially a plethora of paramaters (eg. buffered vs eager? ordered? reliable?) associated with connection/endpoint creation. It doesn't help that each connection type may have its own set of parameters. Is it enough to be able to set and forget them during transport session initialisation, or is it essential for Cloud Haskell be able to set these parameters differently for different connections in the same session? * [Parallel Haskell in industry][mc4] (7 Nov) Sébastien Lannez also got a chance to try out Cloud Haskell. The remote package uploaded by Jeff seems to work well and — dabblers take note — the examples shipped with the code are very easy to adapt. Before digging deeper, Sébastien wanted to know more about 1. performance limitations 2. communication requirements/overheads 3. stability 4. already developed applications Jeff cautioned that while he thinks Cloud Haskell could be a good platform to develop distributed applications, it's still very much research software and a work in progress. Don't stake your company on Cloud Haskell just yet. That said, Duncan Coutts added, we are pretty happy with the design and optimistic about developing a robust implementation, because we can build it as an ordinary Haskell library without requiring tricky extensions to the runtime system. As for Sébastien's fourth question, a couple of Parallel GHC Project partners are rather keen on Cloud Haskell. We are working on the implementation and will hopefully have more to report on performance, overheads and other issues we encounter. ### Multicore performance * [SMP parallelism increasing GC time dramatically][mm1] (5 Oct) It takes a village to tune a program. Tom Thorne has a program with a function does some fairly intensive calculations on with hmatrix. When Tom tries to get some simple parallelism on his 12 core machine, replacing a `map` with a `parMap rdeepseq`, he finds GC time going through the roof, from 1s (1.7%) to 248s (40.5%). Is the big scary number just an artefact of how GC time is reported, or is something really wrong? ThreadScope is a good first response here and Tom was duly nagged by the community. Tom promises to give it a go, although the last time he tried, the event log output produced about 1.8GB, and then crashed. The ThreadScope team would love to get hold of any hints about reproducing the crash Ryan Newton observed that GC aside, the program does not appear to be scaling; the mutator time itself isn't going down with parallelism. Tom improved the parallelism a bit, breaking the work into chunks and spreading it around more evenly, and provided he disables the parallel GC, it turns much faster and outperforms the sequential version. Having loads of RAM to play and code that doesn't use much memory, Tom then tried telling the RTS to perform GC less often. This worked. Increasing the minimum allocation area size from its default 512K with `+RTS -A32M` allows Tom to get performance with the parallel GC comparable to that without. Hooray! But there's still this little problem… now Tom's program intermittently segfaults. Getting a bug report out of this may take a while though as Tom attempts to boil it down. Meanwhile, Oliver Batchelor offered his experience that enabling more threads than he has cores makes his program get drastically slower. Alexander Kjeldaas and Austin Seipp commented that this is due to GC needing to co-ordinate with blocked threads, and that the problem of oversaturating is well known. There's also the "dreaded last core slowdown" bug which once affected Linux users but seems to have gone away in recent Linux/GHC. * [AMD Bulldozer modules and Haskell parallelism][mm2] (13 Oct) Herbert Valerio Riedel has been eyeing the AMD FX-8120 [Bulldozer processor][bulldozer]. Bulldozer cores are not independent from each other, but grouped into pairs. So Herbert wanted to know how this might affect Haskell parallelism; would 8 cores *really* mean 8 or just 4 with slightly better SMT capability? Simon Marlow does not know (benchmarks). Duncan Coutts believes that it should be all fine as the pairing is not at all like hyperthreading. * [Estimating contention on an IORef hammered with atomicModifyIORef][mm3] (27 Oct) Ryan Newton starts us off with a hypothetical scaling bottleneck: all threads frequently accessing a single IORef using `atomicModifyIORef` (Data.IORef). This is commonly understood to be likely a bad idea, but how do we go about measuring just *how* bad it is? This sort of design appears in monad-par, as pointed out by Johan Tibbell, in the GHC IO manager, so it would be good to know how much it really hurts. (See also Ryan's [IORefCAS][b12] package which seems to be partly a result of this discussion) One approach is to use GHC events to count operations on particular IORefs, then put that through a model that reports whether if the IORef is being used acceptably, or is "hot". Duncan Coutts suggests a simple way to get partway there: stick something like a `traceEvent "IORef #3"` on each use of `atomicModifyIORef` and do something like a `ghc-events show | grep IORef` to at least get an idea which `IORefs` are hotter than others and some orders of magnitude. We'll hear back from Ryan when he's had a chance to try it. Meanwhile, Duncan's suggestion made Ryan curious about the overheads from the `traceEvent`s. He attached a microbenchmark showing some strange behaviour on one of his machines. Check the thread out for a little magic from Simon Marlow and perhaps some clues for your own benchmarking. Also for the interested, it's worth mentioning that GHC 7.4 will be sporting a new and improved `traceEvent`, this time exported through `Debug.Trace` and offering versions for use in pure code and IO both. * [Way to expose BLACKHOLES through an API?][mm4] (7 Nov) A BLACKHOLE in GHC acts as a placeholder for a thunk that is currently being evaluated. When the thunk is forced, GHC replaces it with a BLACKHOLE object, which it later replaces when it has the evaluation result. In a parallel/concurrent setting, it may happen that two threads are trying to evaluate the same thunk at the same time. In that case, the first thread creates the blackhole, which the second thread notices and blocks on until the evaluation result is available. Ryan Newton observes that this blocking is implicit, whereas “[w]hen implementing certain concurrent systems-level software in Haskell it is good to be aware of all potentially blocking operations”. He proposes a mechanism to expose blackholes, for example with a `evaluateNonblocking :: a -> IO (Maybe a)` that returns `Nothing` if the value is blackholed. Simon Marlow points out that this may be slightly problematic as thunks depend on each other and “you might be a long way into evaluating the argument and have accumulated a deep stack before you encounter the BLACKHOLE” See the discussion for a counter-proposal. ### Data structures and concurrency * [Efficient mutable arrays in STM][md1] (25 Oct) Ben Franksen has large arrays (millions of elements) with mostly small elements (Int or Double) and largely chunk-wise access patterns. The current implementation of `Control.Concurrent.STM.TArray` as `Array ix (TVar e)` is not nearly efficient enough for his use case. A more efficient implementation would be most welcome, but for now Ben is eyeing `Data.Vector.Unboxed` from the vector package instead. The idea is to use `unsafeIOToSTM` to provide shared transactional access to his arrays. Ben thinks he can live with the consequences: IO code being rerun, aborting, and inconsistent views. But does the STM transaction actually "see" that he changed part of the underlying array so that the transaction is retried? If not, how does he go about manually implementing this behaviour? Antoine Latter reports that no `unsafeIOToSTM` is not transactional - IO actions will be performed immediately and are not rolled back, and are then re-performed on retry. David Barbour and Ketil Malde suggested possible implementations, either keeping an extra `TVar Int` for every chunk in the array, or (B) cleaner and safer: create a “chunked” `TArray` that works with fixed-width immutable chunks in a spine. Another issue that came up is that transactions scale quadratically with the number of TVars touched. Bryan O'Sullivan and Ryan Ingram explained that this is due to choice of data structure (a list) for the STM transaction log, and should be easy to fix. * [High performance threadsafe mutable data structures in Haskell?][md2] (27 Oct) Ryan Newton wanted to know if anybody else was working on threadsafe mutable data structures in Haskell. He and the monad-par team were planning to replace their work stealing deques with something more efficient. If anybody else is working in the same general area, teaming up would be great! Ryan will be exploring both a pure Haskell approach and one based on wrapping foreign data structures with the FFI. Ultimately, Ryan is aiming for an "abstract-deque" parameterizable interface that abstracts over many variants (bounded/unbounded, concurrent/ non-concurrent, single/1.5/double-ended, etc). His current prototype makes use of phantom types and the type families extension to handle all this abstraction, with the intended end result being that someone can create a new queue by setting all the switches on the type (eg. `q :: Deque NT T SingleEnd SingleEnd Bound Safe Int <- newQ`), but this brings up a set of Haskell language and type system questions. More details in the thread! * [Persistent Concurrent Data Structures][md3] (1 Nov) Like Ryan, Dmitri Kondratiev is interested in concurrent mutable data structures, but this time with persistence to boot. His goal is to program at a higher level of abstraction, avoiding the detail bloat that would result from directly using some data storage API (eg. SimpleDB). Dmitri's idea: a module tree of data structures mirroring Data.List, Data.Map, etc but with concurrency and persistence. One would be able to configure through the type interfaces: 1. media to persist data (file? DBMS?) 2. caching policy 3. concurrency configuration (optimistic/pessimistic locking?). Dmitri's post prompted some suggestions for packages to look into: * [safecopy][safecopy]: addresses both the issues of serializing the data and migrating it when the datastructure changes * [acid-state][acid-state]: builds on top of safecopy to add a notion of transactions to any Haskell data structure * [TCache][TCache]: a transactional cache with configurable persistence * Haskell web server frameworks (eg. Yesod, Happstack [acid-state was formerly happstack-state]), as some come with persistence support Jeremy Shaw and David Barbour had reservations about what Dmitri had in mind when he said "concurrent". How would he deal with transaction boundaries, and would a concurrently modified Data.List variant still be a list? Evan Laforge also expressed skepticism about the viability of abstracting over data stores with potentially very different needs. ### Threads, blocking * [Waiting on input with `hWaitForInput' or `threadWaitRead'][mt1] (17 Oct) Jason Dusek would like to use evented I/O for a proxying application, in particular, to fork a thread for each new connection and then to wait for data on either socket in this thread, writing to one or the other socket as needed. He's found two functions which could help, `System.IO.hWaitForInput` and `Control.Concurrent.threadWaitRead` but each comes with some difficulties. Is there something like `select()` that works with handles rather than file descriptors? Ertugrul Soeylemez suggested an alternative approach, just plain Concurrent Haskell because “[a] hundred Haskell threads reading from Handles are translated to one or more OS threads using whatever polling mechanism (select(), poll(), epoll) your operating system supports”. He pasted a small [echo server][ertu-echo] to demonstrate the idea. It wasn't entirely clear for Jason how to apply this to a proxy server. Jason has a `lazyBridge :: Handle -> Handle -> IO ()` which writes everything it reads from one handle into the other and vice-versa, but it blocks and does not allow packets to go back and forth. Gregory Collins sketched out a possible solution: how about `forkIO`ing two threads (one for the read end, one for the write end), with a loop over lazy I/O? [This works][jd-bridge], but is still somewhat surprising. * [System calls and Haskell threads][mt2] (3 Nov) Andreas Voellmy noticed this in Kazu Yamamoto's [Monad Reader][mr-kazu] article on a high performance web server. > When a user thread issues a system call, a context switch occurs. > This means that all Haskell user threads stop, and instead the > kernel is given the CPU time. Can that be right? Andreas thought, and Johan Tibell confirms, that when a Haskell thread is blocking a particular OS threads, other Haskell threads can continue run concurrently on other OS threads on other CPUs (see [Extending the Haskell Foreign Function Interface with Concurrency][conc-ffi]). Further clarification comes from David Barbour, who points out why Kazu's original statement was correct in the context of the article. While Mighttpd uses Haskell threads for concurrency; it does not go the traditional route of using the RTS `-Nx` argument to generate OS threads. Instead it gets its parallelism from a "prefork" model that creates separate processes to balance user invocations (each process may itself be running multiple Haskell threads). This unusual approach is chosen to avoid issues with garbage collection. * [Where threadSleep is defined?][mt3] (6 Dec) Dmitri Kondratiev was looking for a function to make the current process (executing thread) go to sleep for a given time. Felipe Almeida Lessa pointed to the `threadDelay` function in Control.Concurrent. Stack Overflow and Reddit ---------------------------------------------------------------------- * [Space analysis for parfib in monad-par example][s1] * [Using the Par monad with STM and Deterministic IO][s2] * [Haskell: thread blocked indefinitely in an STM transaction][s3] * [How to install haskell Parallel on mac?][s4] * [Mutable, (possibly parallel) Haskell code and performance tuning][s5] * [Why does my concurrent Haskell program terminate prematurely?][s6] * [Parallel Matrix Multiplication][s7] * [Yo /r/haskell, I heard you like monads... : haskell][r1] * [GHC commit: Allow the number of capabilities to be increased at runtime : haskell][r2] * [Haswell processor (hardware transactional memory) : haskell][r3] Help and Feedback ---------------------------------------------------------------------- If you'd like to make an announcement in the next Haskell Parallel Digest, then get in touch with me, Eric Kow, at <parallel(a)well-typed.com>. Please feel free to leave any comments and feedback! [Bikeshed image][bikeshed] by banlon1964 available under a CC-NC-ND-2.0 license. [acid-state]: http://hackage.haskell.org/package/acid-state [afp08]: http://research.microsoft.com/en-us/um/people/simonpj/papers/parallel/AFP08… [bh-intro]: http://mainisusuallyafunction.blogspot.com/2011/10/thunks-and-lazy-blackhol… [bikeshed]: http://www.flickr.com/photos/banlon1964/6337069654/ [bulldozer]: http://en.wikipedia.org/wiki/Bulldozer_%28processor%29 [ch-dp]: https://github.com/haskell-distributed/distributed-process [ch-paper]: http://research.microsoft.com/en-us/um/people/simonpj/papers/parallel/remot… [conc-ffi]: http://community.haskell.org/~simonmar/papers/conc-ffi.pdf [doc-refind]: http://kenta.blogspot.com/2004/07/document-refindingkey.html [ertu-echo]: http://hpaste.org/52742 [ghc-gc-tune]: http://hackage.haskell.org/package/ghc-gc-tune [hal6]: http://www.well-typed.com/Hal6/ [heist-tut]: http://www.nadineloveshenry.com/haskell/heistTutorial.html [jd-bridge]: http://hpaste.org/52814 [mh-actor-pdf]: http://ww2.cs.mu.oz.au/~sulzmann/publications/multi-headed-actors.pdf [mh-actor]: http://hackage.haskell.org/package/actor [mr-kazu]: http://themonadreader.files.wordpress.com/2011/10/issue19.pdf [ph-job]: http://www.haskell.org/pipermail/haskell-cafe/2011-November/097008.html [safecopy]: http://hackage.haskell.org/package/safecopy [SplitChan]: http://hackage.haskell.org/package/chan-split [sps-par]: http://research.microsoft.com/apps/pubs/default.aspx?id=118795 [stm-danielw]: https://gist.github.com/1454995 [stm-ketil]: http://malde.org/~ketil/papers/stmcluster.pdf [TCache]: http://hackage.haskell.org/package/TCache [tv]: http://www.haskell.org/haskellwiki/TV [wool]: http://www.sics.se/~kff/wool/ [b1]: http://hackage.haskell.org/package/remote [b2]: http://jpembeddedsolutions.wordpress.com/2011/10/30/distributed-storage-in-… [b3]: http://www.haskell.org/pipermail/haskell-cafe/2011-October/095970.html [b4]: http://sulzmann.blogspot.com/2011/10/haskell-actors.html [b5]: http://factisresearch.blogspot.com/2011/10/stm-stats-retry-statistics-for-s… [b6]: http://apfelmus.nfshost.com/blog/2011/10/11-frp-concurrent-events.html [b7]: http://blog.melding-monads.com/2011/10/24/concurrency-and-foreign-functions… [b8]: https://plus.google.com/115372308262579808851/posts/PKrA4817zJB [b9]: http://kenta.blogspot.com/2011/11/qkhsskbg-automatic-deparallelization.html [b10]: http://comonad.com/reader/2010/introducing-speculation/ [b11]: http://mainisusuallyafunction.blogspot.com/2011/10/quasicrystals-as-sums-of… [b12]: https://groups.google.com/d/msg/parallel-haskell/ETUJFOjuspU/NVPKnNdL2gcJ [b13]: http://www.haskell.org/pipermail/haskell-cafe/2011-November/097058.html [mh1]: http://www.haskell.org/pipermail/haskell-cafe/2011-December/097428.html [mh2]: http://www.haskell.org/pipermail/haskell-cafe/2011-December/097434.html [mc1]: https://groups.google.com/forum/#!msg/parallel-haskell/8YelldrF0QI/TZaoFGjw… [mc2]: http://www.haskell.org/pipermail/haskell-cafe/2011-October/095731.html [mc3]: https://groups.google.com/d/msg/parallel-haskell/wUmoSxdAmhE/2fX7OmYtzlwJ [mc4]: https://groups.google.com/d/msg/parallel-haskell/UnClyLc8GXI/DZpIIof3bhcJ [mm1]: http://www.haskell.org/pipermail/haskell-cafe/2011-October/095845.html [mm2]: https://groups.google.com/d/msg/parallel-haskell/pLxsTRJijJg/SKCne1L2tSkJ [mm3]: https://groups.google.com/d/msg/parallel-haskell/UcWJFW-eUsI/nexQ1_6A5BcJ [mm4]: https://groups.google.com/d/msg/parallel-haskell/b8Yo8HNRnks/noNMm-RLvgEJ [md1]: http://www.haskell.org/pipermail/haskell-cafe/2011-October/096343.html [md2]: https://groups.google.com/forum/#!topic/parallel-haskell/9NqyXYo1VRg [md3]: http://www.haskell.org/pipermail/haskell-cafe/2011-November/096533.html [mt1]: http://www.haskell.org/pipermail/haskell-cafe/2011-October/096104.html [mt2]: http://www.haskell.org/pipermail/haskell-cafe/2011-November/096597.html [mt3]: http://www.haskell.org/pipermail/haskell-cafe/2011-December/097329.html [m3]: http://www.haskell.org/pipermail/haskell-cafe/2011-October/095970.html [m5]: http://www.haskell.org/pipermail/haskell-cafe/2011-October/096199.html [m8]: http://www.haskell.org/pipermail/haskell-cafe/2011-October/096392.html [s1]: http://stackoverflow.com/questions/7704580/space-analysis-for-parfib-in-mon… [s2]: http://stackoverflow.com/questions/7769996/using-the-par-monad-with-stm-and… [s3]: http://stackoverflow.com/questions/7862372/haskell-thread-blocked-indefinit… [s4]: http://stackoverflow.com/questions/8056880/how-to-install-haskell-parallel-… [s5]: http://stackoverflow.com/questions/8155929/mutable-possibly-parallel-haskel… [s6]: http://stackoverflow.com/questions/8272241/why-does-my-concurrent-haskell-p… [s7]: http://stackoverflow.com/questions/8480087/parallel-matrix-multiplication [r1]: http://www.reddit.com/r/haskell/comments/ldu36/yo_rhaskell_i_heard_you_like… [r2]: http://www.reddit.com/r/haskell/comments/n2mws/ghc_commit_allow_the_number_… [r3]: http://www.reddit.com/r/haskell/comments/n7iv1/haswell_processor_hardware_t… -- Eric Kow <http://erickow.com>

1 0

State Machine Composition
by Daniel Waterworth 24 Dec '11

24 Dec '11

I made this simple state machine combinator library today. I think it works as a simple example of a good use for GADTs. https://gist.github.com/1507107 Daniel

3 4

Re: [Haskell-cafe] The Riddle of the Buddhist Monk
by Patrick Browne 23 Dec '11

23 Dec '11

3 4

How to define Storable instance for data constructor with storable vectors
by Sanket Agrawal 21 Dec '11

21 Dec '11

I am trying to write a union data structure which can store vectors - a simplified definition of data structure is below: --------------------- -- V is Data.Vector.Storable data Elems = I {-# UNPACK #-} !GHC.Int.Int32 | S {-# UNPACK #-} !GHC.Int.Int32 {-# UNPACK #-} !(Ptr CChar) | T {-# UNPACK #-} !(V.Vector Elems) --------------------- What I can't figure out is how to store Vector elements when defining Storable instance for Elems type - the main stumbling block is that my approach requires defining a Storable instance of ForeignPtr. Snippets of code below: --------------------- instance Storable Elems where sizeOf _ = ... alignment _ = ... {-# INLINE poke #-} poke p x = case x of ... T x -> do poke (castPtr p :: Ptr Word8) 3 -- store a tag for data constructor T. We will check it when doing peek let (fp,_,n) = V.unsafeToForeignPtr x poke (castPtr p1) n poke (castPtr (p1 `plusPtr` 8)) fp where p1 = (castPtr p :: Ptr Word8) `plusPtr` 1 -- get pointer to start of the element. First byte is type of element {-# INLINE peek #-} peek p = do let p1 = (castPtr p::Ptr Word8) `plusPtr` 1 -- get pointer to start of the element. First byte is type of element t <- peek (castPtr p::Ptr Word8) case t of .... -- handle all data constructors except T here _ -> do x <- peek (castPtr p1 :: Ptr Int) y <- peek (castPtr (p1 `plusPtr` 8) :: Ptr (ForeignPtr Elems)) return (T (V.unsafeFromForeignPtr y 0 x)) -- return vector elements --------------------- If I use above approach, I will need to define Storable instance of ForeignPtr for Elems data type. Is it possible to define peek/poke operations for storing vectors, using something other than ForeignPtr? I prefer using ForeignPtr because it has finalizer associated with it. I guess it might be possible to store Ptr through withForeignPtr, but then how do you convert back from the Ptr to Vector in peek? If storing the ForeignPtr is a cleaner approach, how would Storable definition for ForeignPtr look like? GHC code for ForeignPtr seems to export only ForeignPtr constructor. I am aware above code is not portable (e.g., assumption that Int is 8 bytes). That is not really an issue because I am writing code for a very specific platform. If there is a library defined somewhere which has already dealt with similar issue, I will very much appreciate pointers.

1 0

Alternative versus Monoid
by Gregory Crosswhite 21 Dec '11

21 Dec '11

Hey everyone, First, thank you all for this great discussion! I unfortunately have been home due to health concerns which gets really boring after a while, so being able to participate in such a fun intellectual exercise like has really been making my day. :-D Sorry that this has resulted in such a flood of commentary on the list! Antoine Latter has pointed out to me that (using my own words here) essentially entire parser libraries are built around the assumption that many and some are sensibly defined the way that they are, and that as a result much of their functionality simply doesn't make sense for Maybe and []. So maybe the best approach to take really is to remove the instance for Maybe and [] from Alternative. After all, some and many simply are not well-behaved for them, and if you are using Alternative you are expecting them to be well-behaved. Now, on the other hand, one might argue: but Maybe and [] have well-defined functions for empty and <|>, so since some and many are defined in terms of these operations, shouldn't that make Maybe and [] natural instances of Alternative anyway? And *this* is where Haskell separates its way from other languages. In others language we may very well just say, "Well, good point, why not make them instances of Alternative, and simply not worry about the fact that some and many don't behave well --- just don't use them like that!" But in Haskell we don't do things this way. When we make something be an instance of a typeclass, we want that to *mean* something. In the case of Alternative, we want, among other things, for it to mean that our type has sensible meanings for some and many --- and if Maybe and [] simply do not meet this criteria, then THEN THEY DESERVE TO BE CAST OUT! I know, I know, I can hear you all shouting: This is blasphemy! This is madness! Madness? This... IS HASKELL! But on a more serious note, it turns out that we *already* have a typeclass that does everything that Alternative does but without the "some" and "many" baggage: it's called "Monoid"! So we can already get all of the features that we need (and most likely have been using anyway) by using the Monoid instances for Maybe and [] and just forgetting about the existence of Alternative entirely. So at the end of the day... what is the point of even making Maybe and [] instances of Alternative? Cheers, Greg

10 23

Re: [Haskell-cafe] Alternative versus Monoid
by Matthew Farkas-Dyck 21 Dec '11

21 Dec '11

On 21/12/2011, Bas van Dijk <v.dijk.bas(a)gmail.com> wrote: > On 16 December 2011 16:26, Yves Parès <limestrael(a)gmail.com> wrote: >> "1) What about the First type? Do we {-# DEPRECATE #-} it?" >> >> Personnaly, I'm in favor of following the same logic than Int: >> Int itself is not a monoid. You have to be specific: it's either Sum or >> Mult. >> >> It should be the same for Maybe: we remove its instance of Monoid, and we >> only use First and Last. > > The reason you need to be specific with Int is that it's not clear > which semantics (sum or product) you want. The semantics of Maybe are > clear: it's failure-and-prioritized-choice. > > Changing the order of the arguments of mappend should be the job of Dual. > > If we really want to drop the Monoid instance for Maybe and keep First > and Last and also want to be consistent we should also drop the Monoid > instances of [a], a->b, Endo a and of all the tuples. And instead > define Monoid instance for First [a], Last [a], First (a->b), Last > (a->b), etc. I don't think this is what we want. > > Regards, > > Bas > > _______________________________________________ > Haskell-Cafe mailing list > Haskell-Cafe(a)haskell.org > http://www.haskell.org/mailman/listinfo/haskell-cafe > Fair point. I concede. If Monoid were necessarily inner-type-gnostic then we'd also have to drop instance Monoid [a]. Cheers, Matthew Farkas-Dyck

1 0

"mapping" an Enumerator
by Kannan Goundan 21 Dec '11

21 Dec '11

I'm using the Data.Enumerator library. I'm trying to write a "map" function that converts an Enumerator of one type to another. Something like: mapEnum :: Monad m => (a -> b) -> Enumerator a m r -> Enumerator b m r Any hints? (My exact use case is that I have a ByteString enumerator and I need to pass it to something that requires a Blaze.Builder enumerator.)

4 6

[Alternative] change some/many semantics
by Gregory Crosswhite 21 Dec '11

21 Dec '11

Hey everyone, This is even more out there than my previous posts, but the following just occurred to me: is it absolutely necessary that some/many have produced the entire list of results before returning? Couldn't we change their semantics so that the list of results is computed and/or extracted lazily? For example, if this were the case, then we would have that (some (Just 1)) returns an infinite list rather than running in an infinite loop (even without defining a special case "some" implementation), which is exactly what my intuition would expect. Of course, this is not a simple change at all because it would have to be done in such a way as to respect the ordering of actions --- that is, we can't have each action executed only when the corresponding element of the list demanded is forced, or else actions would undesirably interleave. For example, in a parser when we use "many v" we expect everything matching v to be consumed by the time "many v" returns, but if instead "many v" only consumed as much of the input as we demanded from its result list then we might see a chunk of input matching v in another part of our parser despite having assumed we'd gotten rid of it, which would cause our parser to be broken. Nonetheless, if there were some way that we could use magic fairy dust to have the results returned by some and many be lazily generated lists, then this might solve many of the problems that come up with them performing infinite loops in cases where it seems like they shouldn't. :-) Cheers, Greg

6 19

Interruptible threads with IO loops
by Fedor Gogolev 21 Dec '11

21 Dec '11

Hello. I'm trying to get some threads that I can stop and get last values that was computed (and that values are IO values, in fact). Here is my first approach: module Main where import Control.Concurrent (MVar, threadDelay, forkIO, newMVar, putMVar, readMVar) tick :: Int -> IO Int tick v = return $ v + 1 loop :: MVar Bool -> a -> (a -> IO a) -> IO a loop var init loopfun = do next <- loopfun init shouldStop <- readMVar var case shouldStop of True -> return next False -> loop var next loopfun runLoop :: Int -> IO () runLoop timeout = do var <- newMVar False forkIO $ threadDelay timeout >> putMVar var True value <- loop var 0 tick print value main :: IO () main = runLoop 30000000 The problem is that it looks a little messy and what's worse it leaks memory. So I'm wondering if there is a better approach to do so or some fix to memory leak.

6 7