- Haskell-Cafe - Haskell.org

ANNOUNCE: dbus 0.10
by John Millikin 23 Jun '12

23 Jun '12

This is completing the merger of the "dbus-core" and "dbus-client" packages. The new package does everything they can do, but better. Hackage: http://hackage.haskell.org/package/dbus Homepage: https://john-millikin.com/software/haskell-dbus/ API reference: https://john-millikin.com/software/haskell-dbus/reference/haskell-dbus/0.10/ Examples: Included in the tarball, and also at https://john-millikin.com/branches/haskell-dbus/0.10/head:/examples/ Notable changes: * The module hierarchy was simplified. Most users will only ever need the "DBus" and "DBus.Client" modules. * Exports which were not used or useful have been removed. * Much better documentation -- most exports now have a description, and several have examples. * The source code isn't "literate" any more. Too many people expressed frustration at trying to contribute, so I just converted it all to standard flat .hs files. * Better support for custom socket transports and authentication mechanisms. * Added support for listening for socket connections. This allows users to implement both sides of a peer-peer session. * Various improvements to performance, including moving from "binary" to "cereal". * Various minor improvements to correctness.

2 1

Re: [Haskell-cafe] transformers problem: Could not deduce MonadTrans (StateT s) ??
by Anton Kholomiov 23 Jun '12

23 Jun '12

No, it wants me to define an instance for (StateT s) which is supposed to be defined be the authors of the library. Actually I discovered that I have two libraries called transformers. transformers-0.2.2.0 transformers-0.3.0.0 So when I'm doing import Control.Monad.Trans (0.2.2.0) I get the error And when I'm doing import Control.Monad.Trans.Class (0.3.0.0) It compiles. Anton

2 4

transformers problem: Could not deduce MonadTrans (StateT s) ??
by Anton Kholomiov 23 Jun '12

23 Jun '12

Why this function doesn't compile? phi :: Monad m => StateT s m () phi = lift $ return () I get (ghc-7.4.1) Could not deduce (MonadTrans (StateT s)) arising from a use of `lift' from the context (Monad m) bound by the type signature for phi :: Monad m => StateT s m () at FSMt.hs:28:1-22 Possible fix: add (MonadTrans (StateT s)) to the context of the type signature for phi :: Monad m => StateT s m () or add an instance declaration for (MonadTrans (StateT s)) In the expression: lift In the expression: lift $ return () In an equation for `phi': phi = lift $ return () Failed, modules loaded: none. Anton

2 1

[ANN] GenCheck - a generalized property-based testing framework
by Jacques Carette 23 Jun '12

23 Jun '12

Test.GenCheck is a Haskell library for /generalized proposition-based testing/. It simultaneously generalizes *QuickCheck* and *SmallCheck*. Its main novel features are: * introduces a number of /testing strategies/ and /strategy combinators/ * introduces a variety of test execution methods * guarantees uniform sampling (at each rank) for the random strategy * guarantees both uniqueness and coverage of all structures for the exhaustive strategy * introduces an /extreme/ strategy for testing unbalanced structures * also introduces a /uniform/ strategy which does uniform sampling along an enumeration * allows different strategies to be mixed; for example one can exhaustively test all binary trees up to a certain size, filled with random integers. * complete separation between properties, generators, testing strategies and test execution methods The package is based on a lot of previous research in combinatorics (combinatorial enumeration of structures and the theory of Species), as well as a number of established concepts in testing (from a software engineering perspective). In other words, further to the features already implemented in this first release, the package contains an extensible, general framework for generators, test case generation and management. It can also be very easily generalized to cover many more combinatorial structures unavailable as Haskell types. The package also provides interfaces for different levels of usage. In other words, there is a 'simple' interface for dealing with straightforward testing, a 'medium' interface for those who want to explore different testing strategies, and an 'advanced' interface for access to the full power of GenCheck. See http://hackage.haskell.org/package/gencheck for further details. In the source repository (https://github.com/JacquesCarette/GenCheck) the file tutorial/reverse/TestReverseList.lhs shows the simplest kinds of tests (standard and deep for structures, or base for unstructured types) and reporting (checking, testing and full report) for the classical list reverse function. The files in tutorial/list_zipper show what can be done with the medium level interface (this tutorial is currently incomplete). The brave user can read the source code of the package for the advanced usage -- but we'll write a tutorial for this too, later. User beware: this is gencheck-0.1, there are still a few rough edges. We plan to add a Template Haskell feature to this which should make deriving enumerators automatic for version 0.2. Jacques and Gordon

5 8

Question on proper use of Data.IORef
by Captain Freako 22 Jun '12

22 Jun '12

Hi experts, I fear I don't understand how to properly use *Data.IORef*. I wrote the following code: 1 -- Testing Data.IORef 2 module Main where 3 4 import Data.IORef 5 6 bump :: IORef Int -> IO() 7 bump theRef = do 8 tmp <- readIORef theRef 9 let tmp2 = tmp + 1 10 writeIORef theRef tmp2 11 12 main = do 13 let theValue = 1 14 print theValue 15 theValueRef <- newIORef theValue 16 bump theValueRef 17 return theValue and got this, in ghci: *Main> :load test2.hs [1 of 1] Compiling Main ( test2.hs, interpreted ) Ok, modules loaded: Main. *Main> main 1 *1* I was expecting this: *Main> :load test2.hs [1 of 1] Compiling Main ( test2.hs, interpreted ) Ok, modules loaded: Main. *Main> main 1 *2* Can anyone help me understand what I'm doing wrong? Thanks! -db

4 4

ICFP 2012 programming contest
by Kevin Hammond 22 Jun '12

22 Jun '12

jPlease consider putting together a team/encourage your students, friends, colleagues to put together a team for the ICFP 2012 programming contest. Entries can be made in ANY LANGUAGE (including one of your own invention) as long as the submitted program can be run by the judges on a standard Linux environment with no network connection (sorry, Vixo!). The competition will run from 1200 UTC on July 13th for 72 hours. There will also be a lightning (24 hour) division for those who can't dedicate a full 72 hours to the contest. This is an open contest. Anybody may participate except for the contest organisers and members of the same group as the the contest chairs. http://icfpcontest2012.wordpress.com/ Did we mention that the contest is sponsored by Facebook and there will be cash prizes (and no entry fee)! What do you have to lose? Book your holiday time and pizza deliveries now! Best Wishes, Kevin -------- Kevin Hammond, Professor of Computer Science, University of St Andrews T: +44-1334 463241 F: +44-1334-463278 W: http://www.cs.st-andrews.ac.uk/~kh In accordance with University policy on electronic mail, this email reflects the opinions of the individual concerned, may contain confidential or copyright information that should not be copied or distributed without permission, may be of a private or personal nature unless explicitly indicated otherwise, and should not under any circumstances be taken as an official statement of University policy or procedure (see http://www.st-and.ac.uk) The University of St Andrews is a charity registered in Scotland : No SC013532

1 0

ANNOUNCE: set-monad
by George Giorgidze 22 Jun '12

22 Jun '12

I would like to announce the first release of the set-monad library. On Hackage: http://hackage.haskell.org/package/set-monad The set-monad library exports the Set abstract data type and set-manipulating functions. These functions behave exactly as their namesakes from the Data.Set module of the containers library. In addition, the set-monad library extends Data.Set by providing Functor, Applicative, Alternative, Monad, and MonadPlus instances for sets. In other words, you can use the set-monad library as a drop-in replacement for the Data.Set module of the containers library and, in addition, you will also get the aforementioned instances which are not available in the containers package. It is not possible to directly implement instances for the aforementioned standard Haskell type classes for the Set data type from the containers library. This is because the key operations map and union, are constrained with Ord as follows. map :: (Ord a, Ord b) => (a -> b) -> Set a -> Set b union :: (Ord a) => Set a -> Set a -> Set a The set-monad library provides the type class instances by wrapping the constrained Set type into a data type that has unconstrained constructors corresponding to monadic combinators. The data type constructors that represent monadic combinators are evaluated with a constrained run function. This elevates the need to use the constraints in the instance definitions (this is what prevents a direct definition). The wrapping and unwrapping happens internally in the library and does not affect its interface. For details, see the rather compact definitions of the run function and type class instances. The left identity and associativity monad laws play a crucial role in the definition of the run function. The rest of the code should be self explanatory. The technique is not new. This library was inspired by [1]. To my knowledge, the original, systematic presentation of the idea to represent monadic combinators as data is given in [2]. There is also a Haskell library that provides a generic infrastructure for the aforementioned wrapping and unwrapping [3]. The set-monad library is particularly useful for writing set-oriented code using the do and/or monad comprehension notations. For example, the following definitions now type check. s1 :: Set (Int,Int) s1 = do a <- fromList [1 .. 4] b <- fromList [1 .. 4] return (a,b) -- with -XMonadComprehensions s2 :: Set (Int,Int) s2 = [ (a,b) | (a,b) <- s1, even a, even b ] s3 :: Set Int s3 = fmap (+1) (fromList [1 .. 4]) As noted in [1], the implementation technique can be used for monadic libraries and EDSLs with restricted types (compiled EDSLs often restrict the types that they can handle). Haskell's standard monad type class can be used for restricted monad instances. There is no need to resort to GHC extensions that rebind the standard monadic combinators with the library or EDSL specific ones. [1] CSDL Blog: The home of applied functional programming at KU. Monad Reification in Haskell and the Sunroof Javascript compiler. http://www.ittc.ku.edu/csdlblog/?p=88 [2] Chuan-kai Lin. 2006. Programming monads operationally with Unimo. In Proceedings of the eleventh ACM SIGPLAN International Conference on Functional Programming (ICFP '06). ACM. [3] Heinrich Apfelmus. The operational package. http://hackage.haskell.org/package/operational

3 6

Why does (++ "!") "bla" return "bla!" and not "!bla"?
by Hilco Wijbenga 21 Jun '12

21 Jun '12

Hi all, I'm going through the excellent http://learnyouahaskell.com tutorial. So far it's been pretty easy to follow but now I ran into something that (when I later started reading about maps) do not seem to fully grasp. I think I'm close to understanding why (++ "!") "bla" returns "bla! instead of "!bla" but I seem to be missing the last step. :-) I noticed that ((++) "!") "bla" does indeed return "!bla". So it seems to be related to the infix property of ++? The types of (++) "!", ((++) "!"), and (++ "!") are all the same so that doesn't tell me much. Would someone please nudge me in the right direction? Cheers, Hilco

4 4

Re: [Haskell-cafe] [Haskell] ANNOUNCE: set-monad
by George Giorgidze 21 Jun '12

21 Jun '12

Hi Derek, Thanks for clarifying your point. You are right that (fromList . toList) = id is a desirable and it holds for Data.Set. But your suggestions that this property does not hold for Data.Set.Monad is not correct. Please check out the repo, I have just pushed a quickcheck definition for this property. With a little bit of effort, one can also prove this by hand. Let me also clarify that Data.Set.Monad exports Set as an abstract data type (i.e., the user cannot inspect its internal structure). Also the run function is only used internally and is not exposed to the users. Cheers, George On 19 June 2012 02:21, Derek Elkins <derek.a.elkins(a)gmail.com> wrote: > > On Jun 18, 2012 4:54 PM, "George Giorgidze" <giorgidze(a)gmail.com> wrote: >> >> Hi Derek, >> >> On 16 June 2012 21:53, Derek Elkins <derek.a.elkins(a)gmail.com> wrote: >> > The law that ends up failing is toList . >> > fromList /= id, i.e. fmap g . toList . fromList . fmap h /= fmap g . >> > fmap h >> >> This is not related to functor laws. The property that you desire is >> about toList and fromList. > > Sorry, I typoed. I meant to write fromList . toList though that should've > been clear from context. This is a law that I'm pretty sure does hold for > Data.Set, potentially modulo bottom. It is a quite desirable law but, as > you correctly state, not required. If you add this (non)conversion, you > will get the behavior to which Dan alludes. > > The real upshot is that Prim . run is not id. This is not immediately > obvious, but this is actually the key to why this technique works. A > Data.Set.Monad Set is not a set, as I mentioned in my previous email. > > To drive the point home, you can easily implement fromSet and toSet. In > fact, they're just Prim and run. Thus, you will fail to have fromSet . > toSet = I'd, though you will have toSet . fromSet = I'd, i.e. run . Prim = > id. This shows that Data.Set.Set embeds into but is not isomorphic to > Data.Set.Monad.Set.

2 3

The use of continuation monad in C++
by Bartosz Milewski 21 Jun '12

21 Jun '12

I published a blog for C++ programmers about the advantages of using the continuation monad in dealing with asynchronous API, concurrency, and parallelism. I explained the concepts in Haskell and the translated them into C++. http://fpcomplete.com/asynchronous-api-in-c-and-the-continuation-monad/ -- [:Bartosz:]

3 3