July 2017 - Haskell-Cafe

ANN: (unofficial) nightly cabal-install builds for OSX
by Oleg Grenrus 26 Jul '17

26 Jul '17

Dear Haskellers, I set up a semi-automatic system to provide you with `cabal` head builds for OSX / macOS at: https://haskell.futurice.com/ As a single highlight, these builds are useful if you need to setup OSX CI; multi-travis-ghc [1] can be used almost as is, see [2]. Hopefully you find these useful! [1]: https://github.com/hvr/multi-ghc-travis [2]: https://github.com/futurice/haskell-futurice-site/commit/3d9b40c6c61788589d… Best regards, Oleg "phadej" Grenrus

1 0

ANN: stack-1.5.0 released
by Emanuel Borsboom 25 Jul '17

25 Jul '17

See https://haskellstack.org for installation and upgrade instructions. ## 1.5.0 Behavior changes: * `stack profile` and `stack trace` now add their extra RTS arguments for benchmarks and tests to the beginning of the args, instead of the end. See [#2399](https://github.com/commercialhaskell/stack/issues/2399) * Support for Git-based indices has been removed. Other enhancements: * `stack setup` allow to control options passed to ghcjs-boot with `--ghcjs-boot-options` (one word at a time) and `--[no-]ghcjs-boot-clean` * `stack setup` now accepts a `--install-cabal VERSION` option which will install a specific version of the Cabal library globally. * Updates to store-0.4.1, which has improved performance and better error reporting for version tags. A side-effect of this is that all of stack's binary caches will be invalidated. * `stack solver` will now warn about unexpected cabal-install versions. See [#3044](https://github.com/commercialhaskell/stack/issues/3044) * Upstream packages unpacked to a temp dir are now deleted as soon as possible to avoid running out of space in `/tmp`. See [#3018](https://github.com/commercialhaskell/stack/issues/3018) * Add short synonyms for `test-arguments` and `benchmark-arguments` options. * Adds `STACK_WORK` environment variable, to specify work dir. See [#3063](https://github.com/commercialhaskell/stack/issues/3063) * Can now use relative paths for `extra-include-dirs` and `extra-lib-dirs`. See [#2830](https://github.com/commercialhaskell/stack/issues/2830) * Improved bash completion for many options, including `--ghc-options`, `--flag`, targets, and project executables for `exec`. * `--haddock-arguments` is actually used now when `haddock` is invoked during documentation generation. * `--[no-]haddock-hyperlink-source` flag added which allows toggling of sources being included in Haddock output. See [#3099](https://github.com/commercialhaskell/stack/issues/3099) * `stack ghci` will now skip building all local targets, even if they have downstream deps, as long as it's registered in the DB. * The pvp-bounds feature now supports adding `-revision` to the end of each value, e.g. `pvp-bounds: both-revision`. This means that, when uploading to Hackage, Stack will first upload your tarball with an unmodified `.cabal` file, and then upload a cabal file revision with the PVP bounds added. This can be useful—especially combined with the [Stackage no-revisions feature](http://www.snoyman.com/blog/2017/04/stackages-no-revisions-field)&… a method to ensure PVP compliance without having to proactively fix bounds issues for Stackage maintenance. * Expose a `save-hackage-creds` configuration option * On GHC <= 7.8, filters out spurious linker warnings on windows See [#3127](https://github.com/commercialhaskell/stack/pull/3127) * Better error messages when creating or building packages which alias wired-in packages. See [#3172](https://github.com/commercialhaskell/stack/issues/3172). * MinGW bin folder now is searched for dynamic libraries. See [#3126](https://github.com/commercialhaskell/stack/issues/3126) * When using Nix, nix-shell now depends always on git to prevent runtime errors while fetching metadata * The `stack unpack` command now accepts a form where an explicit Hackage revision hash is specified, e.g. `stack unpack foo-1.2.3@gitsha1:deadbeef`. Note that this should be considered _experimental_, Stack will likely move towards a different hash format in the future. * Binary "stack upgrade" will now warn if the installed executable is not on the PATH or shadowed by another entry. * Allow running tests on tarball created by sdist and upload [#717](https://github.com/commercialhaskell/stack/issues/717). Bug fixes: * Fixes case where `stack build --profile` might not cause executables / tests / benchmarks to be rebuilt. See [#2984](https://github.com/commercialhaskell/stack/issues/2984) * `stack ghci file.hs` now loads the file even if it isn't part of your project. * `stack clean --full` now works when docker is enabled. See [#2010](https://github.com/commercialhaskell/stack/issues/2010) * Fixes an issue where cyclic deps can cause benchmarks or tests to be run before they are built. See [#2153](https://github.com/commercialhaskell/stack/issues/2153) * Fixes `stack build --file-watch` in cases where a directory is removed See [#1838](https://github.com/commercialhaskell/stack/issues/1838) * Fixes `stack dot` and `stack list-dependencies` to use info from the package database for wired-in-packages (ghc, base, etc). See [#3084](https://github.com/commercialhaskell/stack/issues/3084) * Fixes `stack --docker build` when user is part of libvirt/libvirtd groups on Ubuntu Yakkety (16.10). See [#3092](https://github.com/commercialhaskell/stack/issues/3092) * Switching a package between extra-dep and local package now forces rebuild (previously it wouldn't if versions were the same). See [#2147](https://github.com/commercialhaskell/stack/issues/2147) * `stack upload` no longer reveals your password when you type it on MinTTY-based Windows shells, such as Cygwin and MSYS2. See [#3142](https://github.com/commercialhaskell/stack/issues/3142) * `stack script`'s import parser will now properly parse files that have Windows-style line endings (CRLF) Thanks to all our contributors for this release: * Aayush Kapoor * Albert Netymk * Alexey Kuleshevich * Anders Kaseorg * Arash Rouhani * Bryan Richter * Dawei LIU * Dmitry Nikulin * Domen Kožar * Emanuel Borsboom * Felix Yan * Ivan Lazar Miljenovic * James Hamilton * Luke Murphy * Marcin Tolysz * Martin Kolinek * Mateusz Kowalczyk * Michael Sloan * Michael Snoyman * Niklas Hambüchen * Noah Doersing * Omari Norman * Paolo G. Giarrusso * Peter Stuart * Ryan Scott * Sergey Vinokurov * Sibi Prabakaran * Tej Chajed * Tim Dysinger * Tomáš Janoušek * Vassil Keremidchiev

1 0

Parallel QuickCheck testing with live counter
by Henning Thielemann 25 Jul '17

25 Jul '17

I like pretty much how QuickCheck counts the number of successful tests until it reports that all tests are performed. It gives me feedback on the difficulty of the tests quickly or how long the tests will still run. I also want to run tests in parallel on multiple computing cores. There are dozens of test frameworks now. I have only tried 'pqc' and 'tasty' so far, both of them only show completed test runs but no live counters. Is there a package that runs QuickCheck tests in parallel and shows test counts live?

1 0

Avoiding ad-hoc with yesod-form
by Yotam Ohad 24 Jul '17

24 Jul '17

Hello cafe, I have a custom data type: data Foo = Foo | Bar | Baz deriving (Show, Bounded, Enum) In my yesod app I need to have two forms, one that get two Foo and a second that recieve three Foo. From What I've seen online I need to create two new data types: data Foo2 = { foo1 :: Foo, foo2 :: Foo } data Foo3 = { foo1 :: Foo, foo2 :: Foo, foo3 :: Foo } This is tedious and very much ad-hoc. In my actual app it goes up to Foo6 :( Is there a better way to do it? This is how I defined the forms: foo2AForm :: AForm Handler Foo2 foo2AForm = Foo2 <$> areq (selectFieldList foos) "foo1" Nothing <*> areq (selectFieldList foos) "foo2" Nothing where foos:: [(Text, Role)] foos= map (pack . show &&& id) [minBound..] foo2Form :: Html -> MForm Handler (FormResult Foo2, Widget) foo2Form = renderTable teamAForm foo3AForm :: AForm Handler Foo3 foo3AForm = Foo3 <$> areq (selectFieldList foos) "foo1" Nothing <*> areq (selectFieldList foos) "foo2" Nothing <*> areq (selectFieldList foos) "foo3" Nothing where foos:: [(Text, Role)] foos= map (pack . show &&& id) [minBound..] foo3Form :: Html -> MForm Handler (FormResult Foo2, Widget) foo3Form = renderTable teamAForm Thanks

2 2

[Hiring] Part-time student job in Mannheim, Germany (remote possible)
by Dr. Jann Müller 24 Jul '17

24 Jul '17

We are working on a new approach to financial risk modelling based on recent research. Having obtained some initial funding, we are now looking for a developer to help us implement a prototype. The work will be mostly on the frontend using GHCJS and probably the miso framework (but we are open to other suggestions if you have previous experience in that space). - 10-20h per week at market rates - Flexible hours, remote work possible, but must be able to come to Mannheim for one day each month. Train tickets from anywhere in Germany will be paid for. - Start date: First week of October There is also a lot of potential for thesis projects, if you are interested in domain-specific languages, interpreters, or in dealing with uncertainty, please get in touch. Please send your inquiries and applications to jobs(a)lbrm.de<mailto:jobs@lbrm.de> Regards, Jann Müller

1 0

Peformance digression when using "proc" notation for arrows
by Artem 23 Jul '17

23 Jul '17

2 1

Re: [Haskell-cafe] Feeding a monad into itself
by Olaf Klinke 23 Jul '17

23 Jul '17

MarLinn, you observed well, I swept something under the carpet. So here are the definitions in full glory. Apologies to all the not-so mathematically minded in Haskell-Cafe, the mail has grown rather long. A partially ordered set is a type X together with a function (≤) :: X -> X -> Bool obeying three laws. ∀ x. x ≤ x x ≤ y and y ≤ z implies x ≤ z x ≤ y and y ≤ x implies x == y Note that total orders, like the Ord typeclass, require that either x ≤ y or y ≤ x hold, but not so partial orders. Now suppose you have two partially ordered types, say X and A. By abuse of notation we use ≤ for each of the orders. Suppose we have functions f :: X -> A g :: A -> X Suppose further that f and g are order-preserving, that is x ≤ x' implies f x ≤ f x' a ≤ a' implies g a ≤ g a'. Then f is said to be left adjoint to y if for all x :: X and a :: A, f x ≤ a precisely when x ≤ g a. If X is partially ordered, so is each function space (as you suggested correctly), namely pointwise. Define for f, g :: Z -> X f ≤ g when ∀ z. f z ≤ g z If you like, (->) Z is an applicative functor and the ≤ function for the type Z -> X is built using liftA2 (≤). A bounded lattice is a partially ordered type L that has two nullary and two binary operations: least :: L greatest :: L min :: L -> L -> L max :: L -> L -> L subject to the following laws. ∀ x. least ≤ x ∀ x. x ≤ greatest z ≤ x and z ≤ y precisely when z ≤ min x y x ≤ z and y ≤ z precisely when max x y ≤ z An example is the type Bool where False ≤ True, least = False, greatest = True, min = (&&) and max = (||). Observe that for each x :: L, the partial application (min x) is a monotone function of type L -> L. Hence we can ask when each such function has a right adjoint. If each such right adjoint exists, we call L a Heyting algebra and denote the right adjoint to (min x) by (-->) x. For every MonadPlus m, we can embed Bool into m () using the function Control.Monad.guard. In this reading, False is represented by Nothing and True is represented by Just (). We thus obtain partial orders on Maybe () as well as on any function type X -> Maybe (). Recall that my (/\) function had type m a -> (a -> m ()) -> m a Specialising to a = () we obtain meet = \x y -> x /\ (const y) :: m () -> m () -> m () which you can convince yourself produces the (&&) operator in case of Maybe () == Bool. Likewise, my arrow (-->) has type m a -> m a -> a -> m () from which we can build impl = \x y -> (x --> y) () :: m () -> m () -> m () Now, in the bounded distributive lattice Bool the right adjoint to (&&) x is the logical implication (→) x and we check ghci> guard True `impl` guard True :: Maybe () Just () ghci> guard True `impl` guard False :: Maybe () Nothing ghci> guard False `impl` guard False :: Maybe () Just () ghci> guard False `impl` guard True :: Maybe () Just () Summarising, for some MonadPlus monads m, the type m () looks like a bounded lattice with least = mzero greatest = return () max = mplus min = meet and for a subclass of these monads, including m = Maybe, m () is a Heyting algebra with the right adjoint to min defined as the impl function above. On to a more complicated example. Let R = [0,∞] denote the type of non-negative real numbers, including positive infinity, (totally) ordered by the obvious ≤ relation. Observe that for each r :: R, the multiplication function (*) r :: R -> R is order-preserving if we define 0 * ∞ = 0. Hence we can ask for its right adjoint, which will be a function of type R -> R as well. Exercise: Prove that the right adjoint is division (/) of real numbers, with boundary cases r / 0 = ∞ = ∞ / x for all r and x. This demonstrates the parallels between logical implication and divison: They are both right adjoints in a certain sense. Is there a monad m with m () = R? Yes: The monad G of measures, a.k.a. the Giry monad. Is is not a Haskell monad, though. There is no Haskell type which has R as denotational semantics. But let's pretend. Let's pretend all sets are finite and of Eq class. Then a measure on X can be encoded by a list of type [(X,R)]. It is what packages like probable do. What is (/\) for this monad of measures? Look at the type: (/\) :: G a -> (a -> R) -> G a It modifies a measure by a real-valued function. If x :: X previously had the weight r, then the new weight is r * (f x). Obviously, for each measure dx the operator \f -> dx /\ f is order-preserving, since multiplication is monotone. Hence we can ask for a right adjoint. It must be a function of type G a -> G a -> (a -> R) associating a real-valued function to a pair of measures. For a = () we already know the answer: It is division. For all other types, the right adjoint is known as the Radon-Nikodym derivative [*]. It is an important gadget in machine learning because it can be used to build conditional probabilites. Intuitively, you can see the connection: For a conditional probability, you first filter the list [(X,R)] for all the allowed x, then divide by the sum of all remaining weights to make the total weight 1 again. Hence without division there is no conditional probability. Moral of the story: Logical implication and conditional probabilities are both instances of the same problem, only for different monads. -- Olaf [*] Again, I am sweeping stuff under the carpet. On function space (X -> R), the order ≤ is defined up to sets of measure zero.

1 0

benchmark regression/improvement reporting
by Harendra Kumar 23 Jul '17

23 Jul '17

Hi Cafe, I am looking for a package/tool/way that can tell me the difference in criterion benchmarks that a particular change introduced? If there is a way to just diff two criterion benchmark reports and show the difference in each benchmark result that should also do, I can write a CI script on top of that. Thanks, Harendra

1 0

Haskell modules: Morton's fork?
by Nikita Churaev 22 Jul '17

22 Jul '17

Option 1: module App.Component (Foo, Bar, Qux) -- re-exports module App.Component.Foo (Foo, make, func1, func2) module App.Component.Bar (Bar, make, func1, func2) module App.Component.Qux (Qux, make, func1, func2) API clients will have to write long import lists: import App.Component import qualified App.Component.Foo as Foo import qualified App.Component.Bar as Bar import qualified App.Component.Qux as Qux Option 2: module App.Component (module Foo, module Bar) -- re-exports module App.Component.Foo (Foo, makeFoo, fooFunc1, fooFunc2) module App.Component.Bar (Bar, makeBar, barFunc1, barFunc2) module App.Component.Qux (Qux, makeQux, quxFunc1, quxFunc2) Now you can import easily: import App.Component But now you have to prefix your functions, just like in C... Is there another, cleaner option?

2 1

Re: [Haskell-cafe] Feeding a monad into itself
by Olaf Klinke 22 Jul '17

22 Jul '17

Joshua Grosso wrote: >Could MonadPlus (with mzero) or Alternative (with empty) provide the >termination condition, if this pattern turned out to be more generally >useful? MonadPlus and Alternative provide a way to put the zero into the monad, but no way to check for zeroness. In the Maybe type you have the isNothing function, but the MonadPlus and Alternative classes don't require such a thing, and probably shouldn't. In the following I present a class that allows to do stuff conditional on mzero. The starting observation is that in logic, False => anything == True. Hence the implication arrow is a (binary) function that turns nothing into something. Consider the following binary operation. (Logicians: think conjunction) (/\) :: Monad m => m a -> (a -> m ()) -> m a ma /\ f = (\a -> liftM (const a) (f a)) =<< ma It's a bit like Control.Monad.mfilter but deletes stuff by mapping it to mzero instead of False. For example, ghci> [0,1,2,3] /\ (\n -> replicate n ()) [1,2,2,3,3,3] Some MonadPlus monads are set-like. Think of Nothing as the empty set, Just x as the singleton set {x} and think of the list [x,y,z] as the finite set {x,y,z}, disregarding muliplicities. For such monads m, the types m a have a preorder ≤ which is set inclusion under the "set interpretation". For example, Nothing ≤ Just () [1,2,3] ≤ [1,2,3,4] but not [1,2] ≤ [1,4]. Now consider the following type class. class (Monad m) => Heyting m where (-->) :: (Eq a) => m a -> m a -> a -> m () We reqire that for all x, y and f x /\ f ≤ y if and only if f ≤ x --> y That is, (x /\) is left adjoint to (x -->), which reminds the logician of the Heyting implication arrow. For MonadPlus instances, we suggest that (mzero -->) == const (const (return ())) Here are some instances: instance Heyting [] where ys --> xs = \a -> if (a `notElem` ys) || (a `elem` xs) then [()] else [] instance Heyting Maybe where y --> x = listToMaybe.((maybeToList y) --> (maybeToList x)) Without the Eq constraint, I couldn't have used the elem function, hence the Heyting class carries that constraint. (There is also a Heyting instance for the monad of finite distributions [1], see the package probable [2] and its siblings.) Heyting monads have a sort of negation, turning mzero into something: neg :: (MonadPlus m, Heyting m) => m a -> m () neg x = ((liftM (const ()) x) --> mzero) () Using neg, we can do stuff on mzero: ghci> neg Nothing Just () ghci> neg (Just ()) Nothing ghci> neg [1,2,3] [] ghci> neg [] [()] Finally we implement Jake's function, but more general. untilMZero :: (Heyting m, MonadPlus m) => (a -> m a) -> a -> m a untilMZero f x = (liftM (const x) (neg (f x))) `mplus` ((f x) >>= (untilMZero f)) ghci> untilMZero (\n -> if n > 5 then Nothing else Just (n+1)) 0 Just 6 ghci> untilMZero (\n -> if n > 5 then [] else [n+1,2*n]) 1 [6,10,8,6,6,10,8,6,10,8,6,6,10,8] -- Olaf [1] For the Giry monad, --> computes the Radon-Nikodym derivative. It type-checks. [2] https://hackage.haskell.org/package/probable-0.1.2/docs/Math-Probable-Distr…

2 1