- Haskell-Cafe - Haskell.org

PLDI workshop and proposal deadline - Jan 30
by Tobias Grosser 24 Jan '17

24 Jan '17

Reminder! The final deadline for PLDI W&T proposals is coming up on January 30. Please see the PLDI website for more information. http://conf.researchr.org/track/pldi-2017/pldi-2017-workshops-and-tutorials. Tobias Grosser PLDI Publicity Chair

1 0

is it normal for docs to be pending for 24 hours?
by Patrick Pelletier 24 Jan '17

24 Jan '17

This is only my second time uploading a package to Hackage, so I don't yet have a feel for how it's supposed to go. I uploaded normalization-insensitive-2.0.0.1 about 24 hours ago: https://hackage.haskell.org/package/normalization-insensitive-2.0.0.1 Under "Status", it says "Docs pending". (And the module names are all non-clickable.) Is it normal to take this long to build the docs? Is there some way to find out where in the queue my job is? Is this an indication that something has gone wrong? How do I fix it? Thanks, --Patrick

12 35

[ANN] FastPush 0.1.0.0
by William Yager 24 Jan '17

24 Jan '17

In response to a bit of an obscure use case I had, I created this very simple library which gives you a Monad with a single operation, `push :: a -> m ()`. This operation pushes an item onto a stack (represented under the hood by a mutable ST vector). When you run the monad, you get the stack out as a vector. The library is quite fast. It's about 2x faster than C++'s std::vec::push_back compiled without optimizations, and about 40% as fast as std::vec::push_back when compiled with G++ -O2. There's almost certainly some low-hanging optimization fruit for anyone skilled at Haskell optimizing. The library is parametric over choice of mutable vector. You can use Unboxed, Storable, or normal vectors. I've even included a Push Monad Transformer based on Control.Monad.ST.Trans, but that's almost certainly unsafe, per the caveats listed in the Control.Monad.ST.Trans docs. https://hackage.haskell.org/package/FastPush-0.1.0.0 https://github.com/wyager/FastPush/ Cheers, Will

2 3

[ANN] wiringPi-1.0
by Patrick Pelletier 24 Jan '17

24 Jan '17

https://hackage.haskell.org/package/wiringPi-1.0 https://github.com/ppelleti/hs-wiringPi I released wiringPi-0.1.0.0 less than two weeks ago, but already I have a new major version, with a breaking change. wiringPi-0.1.0.0 kept close to the C wiringPi library, which required calling a setup function. There were four different setup functions, and the choice of setup function determined the pin numbering scheme, which would affect all subsequent functions which used pin numbers. This sort of far-reaching global state felt very un-Haskell-like, and antithetical to modularity. So, in wiringPi-1.0, the setup function is called automatically the first time a wiringPi function is used. The wiringPi binding always configures the underlying C library to use the "Broadcom GPIO" pin numbering scheme. However, the Pin type now has three different constructors, to allow a pin to use any of the three pin-numbering schemes. These pin numbers are automatically converted to the "Broadcom GPIO" scheme internally. So now you can use any pin numbering scheme on a case-by-case basis, without having to make a global choice. About wiringPi: This is a Haskell binding to the wiringPi library, which allows you to interface with the GPIO pins on the Raspberry Pi. Unlike some other solutions for using the Raspberry Pi's GPIO pins, wiringPi provides access to more advanced features, such as enabling the internal pull-up or pull-down resistors. --Patrick

1 0

Re: [Haskell-cafe] A proof that the list monad is not a free monad
by Olaf Klinke 23 Jan '17

23 Jan '17

On a mostly unrelated note, Dan Doel elaborated [1] that the list monad is not the monad of free monoids either, even though mathematically the free monoid over x is the set of words of finite length with alphabet x. Briefly, the reason is that Haskell types are domains, not sets. Below is a proof that the free monad is not the free algebra. One approximant to free algebraic structures is to look at the free F-algebra for a functor F. This approach does not take into account any equations between the algebraic operations. {-# LANGUAGE Rank2Types,MultiParamTypeClasses,FlexibleInstances,FlexibleContexts #-} module FreeFAlg where import Control.Applicative import Control.Monad -- F-algebras (sans laws). class Functor f => Alg f a where alg :: f a -> a -- The free F-algebra over x, following Dan Doel's ideas, -- with the universal property baked in. newtype FreeAlg f x = FreeAlg (forall a. Alg f a => (x -> a) -> a) runFree :: Alg f a => FreeAlg f x -> (x -> a) -> a runFree (FreeAlg f) = f universal :: Alg f a => (x -> a) -> FreeAlg f x -> a universal = flip runFree instance Functor f => Alg f (FreeAlg f x) where alg ff = FreeAlg (\f -> alg (fmap (($f).runFree) ff)) instance Functor (FreeAlg f) where fmap h (FreeAlg fx) = FreeAlg (\f -> fx (f.h)) instance Monad (FreeAlg f) where return x = FreeAlg ($x) (FreeAlg fx) >>= k = FreeAlg (\f -> fx (\x -> runFree (k x) f)) instance Applicative (FreeAlg f) where pure = return (<*>) = ap data FreeMonad f x = Pure x | Roll (f (FreeMonad f x)) instance Functor f => Alg f (FreeMonad f x) where alg = Roll -- This looks like the same universal property... universal' :: Alg f a => (x -> a) -> FreeMonad f x -> a universal' f (Pure x) = f x universal' f (Roll ffree) = alg (fmap (universal' f) ffree) freeAlg2freeMonad :: Functor f => FreeAlg f x -> FreeMonad f x freeAlg2freeMonad = universal Pure freeMonad2freeAlg :: Functor f => FreeMonad f x -> FreeAlg f x freeMonad2freeAlg = universal' return The free monad is not the free F-algebra, because uniqueness fails. Consider the constant functor data Point a = Point instance Functor Point where fmap f Point = Point -- universal' f (Pure x) = f x -- universal' f (Roll Point) = alg Point -- but we have another function with the same type as universal': notUnique :: Alg Point a => (x -> a) -> FreeMonad Point x -> a notUnique f = const (alg Point) For classes like Monoid, which have equations between the algebraic operations (such as mappend mempty = id), we'd need the language extension that allows constraints as type parameters. I'd like to write Free Monoid x = Free (forall a. Monid a => (x -> a) -> a) but I am not experienced with the ConstraintKinds extension. Anyone help? Olaf [1] http://comonad.com/reader/2015/free-monoids-in-haskell/

1 0

Dropbox sdk
by Pieter Laeremans 23 Jan '17

23 Jan '17

Hi all, I've tried using the dropbox sdk package from package today. But it is a bit outdated I can't get it to compile. I 've tried using stack init, with various resolvers. One of the problems seems to be that the dependencies for the certificate package used to by dropbox-sdk, enforces base < 4.8. How should I best tackle this problem ? Should I assume that the certificate package should be replaced by something else? And just try to modify the code ? I know it's open source, so I would prefer trying out a fix, and submitting a patch request, rather than bothering the maintainers. Thanks for your help, Pieter -- Pieter Laeremans pieter(a)laeremans.org

2 2

gloss from ghci
by Johannes Waldmann 23 Jan '17

23 Jan '17

Dear Cafe - I am trying to use gloss https://hackage.haskell.org/package/gloss from ghci. The "display" command will open a window and draw the picture on it just fine. But when I close this window by hitting ESC, ghci prints <interactive>: interrupted and exits, so I'm back at the shell from where I started ghci. This is somewhat annoying - especially since ghci's command line history does not get written, so when I re-start it, I have to re-type (work-around: before "display", close ghci, this will write history, then restart and draw. Ugly.) The gloss FAQ suggests ghci -fno-ghci-sandbox but this does not help (ghci still exits, this time, without printing the message). - J.

2 1

A proof that the list monad is not a free monad
by Ingo Blechschmidt 23 Jan '17

23 Jan '17

Dear lovers of generalized abstract nonsense, recall that we can construct, for any functor f, the free monad over f: data Free f a = Pure a | Roll (f (Free f a)) Intuitively, Free f a is the type of f-shaped trees with leaves of type a. The join operation merely grafts trees together and doesn't perform any further computations. Values of the form (Roll _) shall be called "nontrivial" in this posting. Some of the usual monads are in fact free monads over some functor: * The Tree monad is the free monad over the functor Pair, where data Pair a = MkPair a a. The intuition as Pair-shaped trees is most strong in this example. Every parent node has a pair of children. * The Maybe monad is the free monad over the functor Unit, where data Unit a = MkUnit. In the graphical picture parent nodes have a Unit of children, so no children at all. So there are exactly two Unit-shaped trees: the tree consisting only of a leaf (corresponding to Just _) and the three consisting of a childless parent node (corresponding to Nothing). * The Identity monad is the free monad over the functor Void, where Void a is a type without constructors. * The Partiality monad is the free monad over Maybe. * The Writer [r] monad is the free monad over the functor (r,). In an (r,)-shaped tree, a parent node is decorated with a value of type r and has exactly one child node. Traversing such a path yields a list of r's and a leaf value of type a, so in total a value of type ([r],a) = Writer r a. (In particular, Free (r,) () is isomorphic to [r]. This observation led to the claim that the list monad is free. But this claim is false and indeed doesn't follow from the observation. To show that a monad m is free, one has to exhibit a monad isomorphism forall a. m a -> Free f a for some functor f. In contrast, exhibiting an isomorphism of m a with Free (f a) () is neither sufficient nor required.) Even more monads are quotients of free monads. For instance, State s is a quotient of Free (StateF s), where data StateF s a = Put s a | Get (s -> a). -- NB: This functor is itself a free functor over a type constructor -- which is sometimes called StateI [1], rendering Free (StateF s) what -- Oleg and Hiromi Ishii call a "freer monad" [2]. The quotient is exhibited by the following monad morphism, which gives semantics to the purely syntactical values of the free monad. run :: Free (StateF s) a -> State s a run (Pure x) = return x run (Roll (Put s m)) = put s >> run m run (Roll (Get k)) = get >>= run . k This point of view is the basis of the operational package by apfelmus [1] and is also talked about in an StackOverflow thread [3]. It's the main reason why free monads are useful in a programming context. So, is the list monad a free monad? Intuitively, it's not, because the join operation of the list monad (concatenation) doesn't merely graft expressions together, but flattens them [4]. Here is a proof that the list monad is not free. I'm recording it since I've been interested in a proof for quite some time, but searching for it didn't yield any results. The threads [3] and [5] came close, though. In the free monad over any functor, the result of binding a nontrivial action with any function is always nontrivial, i.e. (Roll _ >>= _) = Roll _ This can be checked directly from the definition of (>>=) for the free monad or alternatively with Reid Barton's trick of exploiting a monad morphism to Maybe, see [3]. If the list monad was isomorphic-as-a-monad to the free monad over some functor, the isomorphism would map only singleton lists [x] to values of the form (Pure _) and all other lists to nontrivial values. This is because monad isomorphisms have to commute with "return" and return x is [x] in the list monad and Pure x in the free monad. These two facts contradict each other, as can be seen with the following example: do b <- [False,True] -- not of the form (return _) if b then return 47 else [] -- The result is the singleton list [47], so of the form (return _). After applying a hypothetical isomorphism to the free monad over some functor, we'd have that the binding of a nontrivial value (the image of [False,True] under the isomorphism) with some function results in a trivial value (the image of [47], i.e. return 47). Cheers, Ingo [1] http://projects.haskell.org/operational/Documentation.html [2] http://okmij.org/ftp/Haskell/extensible/more.pdf [3] http://stackoverflow.com/questions/14641864/what-monads-can-be-expressed-as… [4] https://hackage.haskell.org/package/free-4.12.4/docs/Control-Monad-Free.html [5] https://www.reddit.com/r/haskell/comments/50zvyb/why_is_liststate_not_a_fre…

1 0

interfacing to C library - c2hs/hsc2hs/GreenCard?
by Brian Sammon 23 Jan '17

23 Jan '17

I'd like to write a haskell app that calls a C library that I wrote. This is my first time trying to do something like this. What would people here recommend I start with? c2hs? hsc2hs? GreenCard? One of the newer tools like bindings-dsl or inline-c? It's a relatively small library -- a handful of structs and a bunch of functions that take them as input, often returning another as output, and ultimately doing some libcurl to exchange data with websites. Also, can anyone recommend some documentation to read, that's applicable to GHC 8? A lot of the stuff I found on google predates GHC 8 (and a fair amount predates GHC 7)--not sure if that's likely to be a problem.

2 1

free monad versus operational for blackjack game
by Michael Litchard 23 Jan '17

23 Jan '17

I'm studying the code for a blackjack game: See marked answer. http://codereview.stackexchange.com/questions/46809/blackjack-in-haskell It uses the operational package, and mentions one could write equivalent code using a free monad. But my question is, for this use case is there any benefit for using a free monad?

3 2