April 2014 - Haskell-Cafe

Re: [Haskell-cafe] ANN: set-cover solves Sudoku, Soma cube, 8 Queens etc.
by Johannes Waldmann 22 Jun '14

22 Jun '14

Henning Thielemann <lemming <at> henning-thielemann.de> writes: > .. package set-cover for solving exact set cover problems. > http://hackage.haskell.org/package/set-cover It's hard to evaluate whether one could use the library because there's essentially no visible documentation. E.g., what does Math.SetCover.Exact.search do? Its type refers to "State" which seems implementation-dependent, and hides the connection to the specification of the set cover problem. Putting some text and examples into the haddocks might help. But of course putting the specification there would be even better. Also, care to explain what algorithm your solver uses, and give some performance data (e.g., N-queens for N=10,20,40,..)? - J.W.

2 1

ZuriHac 2014 - Updates
by Bas van Dijk 05 Jun '14

05 Jun '14

Dear (potential) ZuriHac 2014 attendees, I would like to make a few announcements regarding ZuriHac 2014, a Haskell hackathon taking place in Zurich from Friday 6 June 2014 to Sunday 8 June 2014. Besides hacking on Haskell projects with core members of the community you will hear talks by Simon Marlow and Edward Kmett. Note that this event is open to any experience level, from beginners to gurus. In fact, one of the goals is to bring beginners in contact with experts so that the former can get a quick start in the Haskell community and the latter more help with their projects. For more information see: http://www.haskell.org/haskellwiki/ZuriHac2014 Registration ------------ I'm happy and sad to inform you that we've almost reached capacity for ZuriHac 2014. Happy because it looks like this might be the biggest Haskell Hackathon ever. Sad because I soon have to start adding new registrations to a waiting list. So if you want to join us, and haven't registered already, then please do so soon at: http://bit.ly/ZuriHac2014. Also if you've already registered but know you won't be able to make it, please cancel by emailing me to make room for others. T-Shirt ------- Like last year, each attendee will get a free ZuriHac T-shirt. If you've already registered, please tell me which sizes and model you would like to have: Male: S, M, L, XL, XXL Female: S, M, L, XL, XXL Host ---- Erudify, the company which is hosting ZuriHac, recently changed its name to Better. Do note that we haven't changed location. See our new website on why we have rebranded: http://better.com/en/rebranding Regards, The ZuriHac 2014 organizers

5 4

How to write fast for loops
by Niklas Hambüchen 26 May '14

26 May '14

As you probably now, `forM_ [1..n]` is incredibly slow in Haskell due to lack of list fusion [1]; a manually written loop is 10x faster. How do you people work around this? I keep defining myself something like loop :: (Monad m) => Int -> (Int -> m ()) -> m () loop bex f = go 0 where go !n | n == bex = return () | otherwise = f n >> go (n+1) Is there a function for this somewhere already? Or do you have another way to deal with this problem? Thanks! [1]: https://ghc.haskell.org/trac/ghc/ticket/8763

11 29

Imports at bottom, why not?
by Thiago Negri 20 May '14

20 May '14

When reading code, I find it quite distracting to have to get past the import list to reach the actual module code, as the import list can be (and often is) quite big. So, why not issue import statements at the bottom of a module file? Likewise, we can use "where" statements to define names used in a function after using them, so they don't distract the reader. I'm against imports at the middle of the file. But I guess being able to issue them at the end of the module could make sense if you want to get the reader straight to the code. A language pragma could be used to select between top imports or bottom imports (can't use both). What do you think? Example: """ {-# LANGUAGE LateImports #-} module Foo where bar :: String bar = "quux" baz :: Fiz baz = mkFiz import Fiz (Fiz, mkFiz) """

13 16

Unicode Haskell source -- Yippie!
by Rustom Mody 09 May '14

09 May '14

I'm mighty pleased to note that the following is valid Haskell code! Do others find this useful/appealing? Any possibilities on making the commented out parts work? [Pragmatics about typing this at the same speed and facility as we do with Ascii is a separate and (IMHO) solvable problem though its not the case at the moment] -------------------- import qualified Data.Set as Set -- Experimenting with Unicode in Haskell source -- Numbers x ≠ y = x /= y x ≤ y = x <= y x ≥ y = x >= y x ÷ y = divMod x y x ⇑ y = x ^ y x × y = x * y -- readability hmmm !!! π = pi -- ⌊ x = floor x -- ⌈ x = ceiling x -- Lists xs ⤚ ys = xs ++ ys -- Bools x ∧ y = x && y x ∨ y = y || y -- ¬x = not x -- Sets x ∈ s = x `Set.member` s -- or keep ∈ for list elem? s ∪ t = s `Set.union` t s ∩ t = s `Set.intersection` t s ⊆ t = s `Set.isSubsetOf` t s ⊂ t = s `Set.isProperSubsetOf` t s ⊈ t = not (s `Set.isSubsetOf` t) -- ∅ = Set.null

24 41

Re: [Haskell-cafe] Haskell Programming Font with Ligatures
by Garrett Mitchener 03 May '14

03 May '14

I just tried this in gedit and it looks *really* nice! Thanks for putting this together. Doesn't work in emacs though :-(

4 4

forLoop + strict State monad is much faster than foldl'
by Niklas Hambüchen 01 May '14

01 May '14

This is just a short notice that using foldl' (+) 0 [0..100000::Int] is over 10 times slower than using flip execState 0 $ forLoop (0 :: Int) (< n) (+1) $ \i -> do x <- get put $! x + i with `loopFor` as on https://github.com/nh2/loop. Even using an IORef is twice as fast as the pure foldl' (but still 5 times slower than strict State). The benchmark is at http://htmlpreview.github.io/?https://github.com/nh2/loop/blob/master/resul…. (All benchmarks are linked from https://github.com/nh2/loop.) You can see there that the problem is gone when using Vector.foldl', but only for Int - for Word32 it persists. It seems that manual looping is beneficial even when dealing with prime examples of pure code that GHC ought to optimize well. Niklas

8 20

ANN: reinterpret-cast - byte-casting word-size numbers
by Niklas Hambüchen 30 Apr '14

30 Apr '14

Announcing the first version of the reinterpret-cast package: Hackage: http://hackage.haskell.org/package/reinterpret-cast Github: https://github.com/nh2/reinterpret-cast Takes the bit representation of a number and uses it for a different numeric type. This is reinterpret_cast from C++ and float f = 1.23; int i = * (int *) &f; from C. I started writing this because the PointCloudLibrary project (PCL) makes RGB colours available as an int-packed format cast to a float value - that's silly but oh the legacy. I was surprised that fast reinterpret casts are not readily available in base or at least GHC, but there are improvements going on (see links in the README). Meanwhile this package is for dealing with it. The way implemented here is the fastest possible way known to me as of now. In particular, it is faster than what data-binary-ieee754 does at the moment. Contributions are very welcome.

1 0

Escaping phantom type
by Miguel Mitrofanov 30 Apr '14

30 Apr '14

Hi cafe! Assume I have some function foo :: A x -> B x Now, the type B is somewhat complicated. It consists of several parts. So, if we call foo twice, like let b1 = foo a b2 = foo a then it's possible that we'd use some parts of b1 and b2 together, mistakenly assuming they are from the same B, not from different ones. I want to exclude this possibility. So I introduce a phantom type, and the signature becomes this: foo :: A x -> exists y. B x y (of course that's not a legitimate Haskell, in reality I'll use some GADT) Now b1 and b2 would have different types, and we can't mix them up by mistake. So far so good. But let's assume that we want to use "foo" recursively. Without the safety precautions it would be easy: generateA :: B x -> OtherArgs -> A x ... b = foo (generateA b otherArgs) Unfortunately, we can't do the same thing with this safety net in place. If we do generateA :: B x y -> OtherArgs -> A x where x doesn't depend on y, then generateA would loose the phantom type, so let b = foo (generateA b otherArgs) in b and let b1 = foo (generateA b1 otherArgs) b = foo (generateA b1 otherArgs) -- sic! in b would be indistinguishable. And that is definitely not what we want. In reality, we want x to depend on y. Unfortunately, there are lots of possibilities regarding the way x would depend on y. I know for sure that there would be many different "generateA" functions, and I don't want to encode them all in types. I've come up with one solution: foo :: (forall y. exists x. ((B x y -> A x), (B x y -> z))) -> z This would work, as in the end I would be interested not in B, but in something that would have nothing to do with this phantom types. But that requires explicit CPS transformation, which makes the code difficult to read. Is there some way to simplify things? To make them easier to use?

1 0

How to create a background program that monitors input (linux)
by EatsKittens 29 Apr '14

29 Apr '14

Essentially, I want to create a program that is simply ran in the background, not in a terminal, that monitors keypresses and mouse presses and takes certain actions on specific keypresses. Where to start?

4 5