November 2012 - Haskell-Cafe

more sharing in generated code
by Peter Divianszky 06 Nov '12

06 Nov '12

Hi Joachim, > > ... > > I think one problem with this approach is that now, until "x r'" is > evaluated, you keep both r and r' alive. If r was _not_ retained by > anything else, then you are now preventing the GC from freeing it and > hence increasing the memory footprint. Good remark, this can be solved with weak pointers, although I don't know how efficient they are. ---------------------- The next version of the proposal Replace every record update r' = r { x = y } with r' = r { x = update (weak r) r' (x r) y) } in generated code if some sharing aware optimization flag is enabled. Auxilary functions: weak :: a -> Weak a -- make a weak pointer which is not followed by GC update :: Weak r -> r -> x -> x update r_old r_new x_old x_new = unsafePerformIO $ do eval x_new b <- x_old === x_new when b (replace r_new r_old) return x_new (===) :: a -> a -> IO Bool -- pointer-equality for boxed values, equality for unboxed values replace :: a -> Weak a -> IO () -- replace thunks in the heap -- do nothing if the weak pointer was gone Cheers, Peter

2 1

Re: [Haskell-cafe] Partial application in case expression rules
by Patrick Premont 05 Nov '12

05 Nov '12

I had not thought of this record syntax. But it does not perform the currying effect shown in the example; it just drops the omitted fields. Brandon Allbery <allbery.b(a)gmail.com> wrote: >On Mon, Nov 5, 2012 at 4:15 PM, Stephen Tetley <stephen.tetley(a)gmail.com>wrote: > >> There is a long extant GHC extension to elide constructor arguments >> >f (Leaf {}) = ... >> f (Node {}) = ... >> > >I don't think that's an extension, it falls out directly from how Haskell >builds records on top of ADTs and is specified in the standard as such. > See http://www.haskell.org/onlinereport/decls.html at the end of the >"Labelled Fields" section for Haskell98, or the middle of section 3.15.2 in >http://www.haskell.org/onlinereport/haskell2010/haskellch3.html#x8-490003.1… >the H'2010 version. > >-- >brandon s allbery kf8nh sine nomine associates >allbery.b(a)gmail.com ballbery(a)sinenomine.net >unix/linux, openafs, kerberos, infrastructure http://sinenomine.net

1 0

[ANNOUNCE] network-bitcoin
by Clark Gaebel 05 Nov '12

05 Nov '12

Hello Cafe, You've heard of the neat crypto-currency bitcoin[1], haven't you? Well, I've just released network-bitcoin[2] which provides Haskell bindings to the bitcoin daemon. Hopefully, this will make your bitcoin-related goals easier to achieve. Who knows, it might even make bitcoin integration for the various web frameworks a bit easier. Special thanks to Michael Hendricks who wrote the original version of network-bitcoin, which I used as a base for this release. Regards, - Clark [1] http://bitcoin.org [2] http://hackage.haskell.org/package/network-bitcoin-1.0.1

2 1

Partial application in case expression rules
by Patrick Premont 05 Nov '12

05 Nov '12

Occasionally I find it would be nice to be able to omit some or all constructor parameters from a pattern matching rule. Perhaps the compiler could put them in for you and apply them to the right hand side of the rule ? data Tree a = Leaf a| Node (Tree a) (Tree a) treeFold :: (a -> a -> a) -> Tree a -> a treeFold f = \case Leaf -> id Node -> f `on` treeFold f This could be desugared at some point to treeFold f = \case Leaf a -> id a Node a b -> (f `on` treeFold f) a b I suppose such an extension has been considered before, but I could not find such a discussion. (In http://haskell.1045720.n5.nabble.com/Partial-pattern-matching-td3087200.html the thread focused instead on case expressions over functions) Any pointers to previous discussions ? Comments ? Thank you! Patrick Prémont

3 3

How to handle exceptions in conduit?
by Hiromi ISHII 05 Nov '12

05 Nov '12

Hi, there I'm writing a program communicating with external process, which can be sometimes fail, using conduit and process-conduit package. Consider the following example, which reads paths from the config file, and passes their contents to external process, and output the results: ```exc.hs module Main where import qualified Data.ByteString.Char8 as BS import Data.Conduit import qualified Data.Conduit.Binary as BC import qualified Data.Conduit.List as LC import Data.Conduit.Process main :: IO () main = runResourceT $ BC.sourceFile "paths.dat" $$ BC.lines =$= myConduit =$= LC.mapM_ (unsafeLiftIO . BS.putStrLn) myConduit :: MonadResource m => Conduit BS.ByteString m BS.ByteString myConduit = awaitForever $ \path -> BC.sourceFile (BS.unpack path) =$= conduitCmd "./sometimes-fail" ``` ```sometimes-fail.hs module Main where import System.Random main :: IO () main = do b <- randomRIO (1,10 :: Int) if b < 9 then interact id else error "error!" ``` ```paths.dat txt/a.dat txt/b.dat txt/c.dat ...bra, bra, bra... ``` As you can see, `sometimes-fail` is a simple echoing program, but sometimes fail at random. Successful result is below: ``` $ ./exc this is a! this is b! this is c! this was d! this was e! and this is f. ``` but if `sometimes-fail` fails in some place, `exc` exits with exception like below: ``` $ ./exc this is a! this is b! this is c! sometimes-fail: error! ``` But I want to write the program acts like below: ``` $ ./exc this is a! this is b! this is c! sometimes-fail: error! this was e! and this is f. ``` that is, ignore the exception and continue to process remaining streams. So, the question is: how to handle the exception in `myConduit` and proceed to remaining works? In `conduit` package, `Pipe` type is not an instance of `MonadBaseControl IO` so it cannot handle exceptions within it. I think this is necessary to make `ResourceT` release resources correctly. So, how to write the Conduit that ignores some kind of exceptions and proceed to remaining works? One sometimes want to ignore the invalid input and/or output and just continue to process the remaining stream. One solution is that libraries using conduit provide "failure-ignore" version for all the `Pipe`s included in the library, but I think it is too heavy solution. It is ideal that `conduit` can package provides combinator that makes exsiting `Pipe`s "failure-ignore". -- Hiromi ISHII konn.jinro(a)gmail.com

2 4

Does this have a name?
by Jacques Carette 05 Nov '12

05 Nov '12

The function > app1 f x = f >>= ($ x) or equivalently > app2 f x = join (f <*> pure x) with type Monad m => m (a -> m b) -> a -> m b ? Hoogle did not help. Jacques PS: a nice point-free version would be appreciated as well. I can easily change app1 and app2 myself to point-free with enough applications of flip, . and $, but none of those are 'nice'.

1 0

ANN: OpenGL packages update
by Jason Dagit 04 Nov '12

04 Nov '12

The updates include: * All of the newtypes in OpenGLRaw have been changed to type aliases (credit to Trevor Elliott and Mike Ledger) * OpenGLRaw's TypesInternal module has gone away * NVidia path rendering extensions have been added by "ozelis" on github This release changes OpenGLRaw to use type aliases instead of newtype wrappers for the GLfoo types, such as GLenum/GLfloat/GLdouble. Using newtypes had the following downsides: * The CPP macros to make these definitions are borrowed verbatim from GHC sources and required updates with new GHC releases in order to stay compatible. Although, it hasn't been a problem yet, it's conceivable this will conflict with supporting different versions of GHC at some point. * Optimization rules have to be written against these newtypes and forgetting them can lead to significant performance degradation or extra verbosity for people using the bindings. * You have to reach pretty deep into GHC to make it possible for the newtypes to work in the unboxed vectors provided by the vector package. This is again, another missed opportunity for high performance code. You can find the source and bug trackers for these packages here: https://github.com/haskell-opengl/ Feedback, pull requests, and bug reports are always welcome! Thanks! Jason

1 0

Help: Main: thread blocked in MVar operation
by "José A. Lopes" 04 Nov '12

04 Nov '12

Hey everyone, I changed my code I now I get the following error message Main: thread blocked indefinitely in an MVar operation Before the change, I was using the State monad with runState. Then, I changed the code to use the StateT monad transformer wrapped around IO monad and runStateT. And this change introduced the error message. BTW I am using DoRec extension, maybe it is the source of the problem, but I don't know. Here are some specs: ghc 7.4.2 mtl 2.1.1 If you need any other information please don't hesitate to ask. Any help is greatly appreciated! Cheers, José -- José António Branquinho de Oliveira Lopes Instituto Superior Técnico Technical University of Lisbon

2 2

more sharing in generated code
by Peter Divianszky 04 Nov '12

04 Nov '12

Hi, I have a question about sharing at the Haskell run-time level. Suppose we have a record update r { x = f (r x)} and suppose that most of the time f returns it's argument unchanged. I have the following questions: 1. Does the generated code for the record update build an identical record when f returns it's argument unchanged instead of sharing the old one? (I guess yes.) 2. Can we prevent building identical records? Recently I've heard about Q-combinators. Central idea: Change (f :: a -> a) to (f' :: a -> Maybe a) returning Nothing when the value didn't change. Then we can replace the record update with smarter code which preserves more sharing. My question is: Can (or could) we enable more sharing without changing the source code? Ideally the compiler would generate record update code which checks poiter-equality of the updated field value to decide whether a copy of the original record is needed or it can be shared (given an optimisation flag enabled). Thanks, Peter Background info: There was a discussion on the Agda mailing list about decreasing the Agda compiler memory-usage with more sharing[^1]. (The Agda compiler is written in Haskell.) I had the above idea and I was advised to ask about it on some Haskell mailing list. [^1]: https://lists.chalmers.se/pipermail/agda/2012/004485.html

4 6

Input Handling, Callbacks, State Machines
by Daniel Trstenjak 04 Nov '12

04 Nov '12

Hi all, I'm currently struggling in the search for a nice abstraction for the input handling of a game (it's a simple platformer with rectangular platforms). One good example is the level editor of the game. When pressing the left mouse button the creation of a new platform is started. As long as the mouse button is hold the platform can be resized by moving the mouse. When releasing the mouse button the platform is created with the current shape. The GUI library I'm using is GLFW. There're several callbacks for key, mouse button and mouse move events. Firstly I would like to be able to describe application states, like the creation of a platform or the definition of the movement of a platform. The state might add something to the current level rendering and it changes temporary the callbacks. So in the case of a platform creation, the mouse move callback would just resize the platform, the mouse button callback awaits the button release and the key callback might only allow the quitting of the current creation. Above the application states it would be nice to be able to describe the transition from one state to another. Perhaps FRP might be a solution for this. But I'm still shying away of it, because a game might have some hairy state changes and I still don't see, how FRP makes life in this regard that much easier. Any Ideas? Greetings, Daniel

3 2