October 2019 - Haskell-Cafe

stack: pandoc fails to build as dependency
by Olaf Klinke 07 Aug '20

07 Aug '20

Dear cafe, I am baffled to learn that stack does not provide builds as reproducible as advertised. I have a project that depends on pandoc. It builds fine on my Debian 9 machine. Then I check out the project on a Debian 8 machine. Downloading and building pandoc-2.7.3 with the latest stack-2.1.3 on the Debian 8 machine runs fine. Now I create a new project, using the same stack.yaml as in the pandoc-2.7.3 package, except now pandoc-2.7.3 is an extra-dep. The project's only module contains nothing but: module Test where import Text.Pandoc Building this project with the same stack results in a linker error: pandoc > Preprocessing executable 'pandoc' for pandoc-2.7.3.. pandoc > Building executable 'pandoc' for pandoc-2.7.3.. pandoc > [1 of 2] Compiling Main pandoc > [2 of 2] Compiling Paths_pandoc pandoc > Linking .stack-work/dist/x86_64-linux/Cabal-2.4.0.1/build/pandoc/pandoc ... pandoc > collect2: error: ld returned 1 exit status pandoc > `gcc' failed in phase `Linker'. (Exit code: 1) This seems to be independent of the LTS version (the stack.yaml in pandoc-2.7.3 says lts-13.17 although lts-13.17 contains pandoc-2.5 and pandoc-2.7.3 is available only in 14.9). Can somebody hint what I am doing wrong? Should I file a bug report? Thanks Olaf

3 3

ANN brittany-0.12.0.0
by Evan Borden 28 Nov '19

28 Nov '19

Hello, I am happy to announce the release of brittany version 0.12.0.0. This version includes a number of fantastic improvements from many excellent contributors. Additionally brittany will soon be added back to stackage. In the meantime it can be built with the stack.yaml in its source or with cabal v2-build. https://hackage.haskell.org/package/brittany-0.12.0.0 Contributors ============ * Benjamin Kovach @5outh * Doug Beardsley @mightybyte * Evan Borden @eborden * Lennart Spitzner @lspitzner * Matt Noonan @moatt-noonan * Phil Hazelden @ChickenProp * Rupert Horlick @ruhatch * Sergey Vinokurov @sergv New Collaborators ================= You may be wondering why I am sending this message instead of Lennart. Taylor Fausak and I are taking on some of the maintenance for brittany. We will hopefully lift some of the burden from Lennart so he can remain the guiding light and driving force behind the project. Changes ========== This release includes many bug fixes, additional support for a number of syntactic constructs and a few layouting modifications. For full details check the change log on github: https://github.com/lspitzner/brittany/blob/master/ChangeLog.md Again thank you to brittany's fantastic contributors for helping making this release happen. -- Evan

2 1

Re: [Haskell-cafe] Explicit approach to lazy effects For probability monad?
by Olaf Klinke 15 Nov '19

15 Nov '19

Hi Benjamin, Your example code seems to deal with two distinct types: The do-notation is about the effects monad (on the random number generator?) and the `sample` function pulls whatever representation you have for an actual probability distribution into this effect monad. In my mental model, the argument to `sample` represents a function Double -> x that interprets a number coming out of the standard random number generator as an element of type x. I suggest to consider the following two properties of the mathematical probability monad (a.k.a. the Giry monad), which I will use as syntactic re-write rules in your modeling language. The first property is Fubini's Theorem. In Haskell terms it says that for all f, a :: m x and b :: m y the two terms do {x <- a; y <- b; f x y} do {y <- b; x <- a; f x y} are semantically equivalent. (For state monads, this fails.) Monads where this holds are said to be commutative. If you have two urns, then drawing from the left and then drawing from the right is the same as first drawing from the right and then drawing from the left. Using Fubini, we can swap the first two lines in your example: model = do cond <- bernoulli 0.5 x <- normal 0 1 return (if cond == 1 then x else 0) This desugars to bernoulli 0.5 >>= (\cond -> normal 0 1 >>= (\x -> return (if cond == 1 then x else return 0))) bernoulli 0.5 >>= (\cond -> fmap (\x -> if cond == 1 then x else 0) (normal 0 1)) The second property is a kind of lazyness, namely fmap (const x) and return are semantically equivalent. which holds for mathematical distributions (but not for state monads). Now one could argue that in case cond == 0 the innermost function is constant in x, in which case the whole thing does not depend on the argument (normal 0 1). The Lemma we need here is semantic equivalence of the following two lambda terms. \cond -> \x -> if cond == 1 then x else 0 \cond -> if cond == 1 then id else const 0 If the above is admissible then the following syntactic transformation is allowed: model = do cond <- bernoulli 0.5 if cond == 1 then normal 0 1 else return 0 which makes it obvious that the normal distribution is only sampled when needed. But I don't know whether you would regard this as the same model. Notice that I disregarded your `sample` function. That is, my monadic language is the monad of probabilites, not the monad of state transformations of a random number generator. Maybe you can delay using the random number generator until the very end? I don't know the complete set of operations your modeling language sports. If that delay is possible, then maybe you can use a monad that has the above two properties (e.g. a reader monad) and only feed the random numbers to the final model. As proof of concept, consider the following. type Model = Reader Double model :: Model Int model = do x <- reader (\r -> last [1..round (recip r)]) cond <- reader (\r -> r > 0.5) return (if cond then x else 0) runReader model is fast for very small inputs, which would not be the case when the first line was always evaluated. Cheers, Olaf

3 5

[ANNOUNCE] GHC 8.8.1 is now available
by Ben Gamari 14 Nov '19

14 Nov '19

Hello everyone, The GHC team is pleased to announce the release candidate for GHC 8.8.1. The source distribution, binary distributions, and documentation are available at https://downloads.haskell.org/ghc/8.8.1 This release is the culmination of over 3000 commits by over one hundred contributors and has several new features and numerous bug fixes relative to GHC 8.6: * Visible kind applications are now supported (GHC Proposal #15) * Profiling now works correctly on 64-bit Windows (although still may be problematic on 32-bit Windows due to platform limitations; see #15934) * A new code layout algorithm for amd64's native code generator significantly improving the runtime performance of some kernels * The introduction of a late lambda-lifting pass which may reduce allocations significantly for some programs. * Further work on Trees That Grow, enabling improved code re-use of the Haskell AST in tooling * Users can write `forall` in more contexts (GHC Proposal #7) * The pattern-match checker is now more precise in the presence of strict fields with uninhabited types. * A comprehensive audit of GHC's memory ordering barriers has been performed, resulting in a number of fixes that should significantly improve the reliability of programs on architectures with weakly-ordered memory models (e.g. PowerPC, many ARM and AArch64 implementations). * A long-standing linker limitation rendering GHCi unusable with projects with cyclic symbol dependencies has been fixed (#13786) * Further work on the Hadrian build system * Countless miscellaneous bug-fixes Unfortunately, due to a build issue (#17108) found late in the release process i386 Windows builds are currently unavailable. These will be provided in the coming weeks. As always, if anything looks amiss do let us know. Happy compiling! Cheers, - Ben [1] https://downloads.haskell.org/ghc/8.8.1/docs/html/users_guide/8.8.1-notes.h…

8 14

Explicit approach to lazy effects For probability monad?
by Benjamin Redelings 08 Nov '19

08 Nov '19

Hi, I'm wondering if people could point me to some background on explicitly representing lazy effects in Haskell? The only effect I am concerned about at this point is `seq`. If there is a way to do this with monads, that would be great. (I know that a lot of people hate lazy effects. However, I think this is an orthogonal issue to the question of how to *represent* lazy effects explicitly.) As background, I'm using a lazy probability monad where random sampling is done with unsafeInterleaveST/IO (or something similar), so that random variables are only sampled if they are actually used: model = do x <- sample $ normal 0 1 -- the interpreter does `unsafeInterleaveIO` to implement 'sample' cond <- sample $ bernoulli 0.5 let y = if cond == 1 then x else 0 return y Here, x is only sampled if cond==1. This has a lot of benefits in procedures like Markov chain Monte Carlo. I initially thought that I could model lazy effects by mapping a -> (a,state) as in the ST monad. However, it seems like lazy effects basically require allowing forked state threads to join CONDITIONALLY on if a value is used/forced, and I don't see how to do that without a source-to-source transformation of functions. It seems like lazy effects require tracking state within each closure, and not globally within the monad interpreter. It kind of seems like this can't work if >>= has type 'm a -> (a -> m b) -> mb', assuming m a = (a,state). The second argument needs to have type (m a -> m b) instead of (a -> m b), since the computation needs to have access to the state produced by the first "m a" computation, in order to (optionally) depend on the state thread for first computation. Does this make any sense? I don't know the literature in this area. Q1. Is there a nice way of representing lazy effects that someone could point me to? Q2. Alternatively, is there a proof that either (i) there is not a monadic way to represent lazy effects, or (ii) fmap f requires a source-to-source transformation (for example to explicitly join state threads on strict operations like ($) and case). -BenRI P.S. As even more background, I'm using a probability monad that allows you to e.g. generate an infinite list of random variables, and only instantiate the ones that are looked at: model = do n <- sample $ geometric 0.5 ys <- sample $ list (repeat $ normal 0.0 1.0) zs <- take n ys return (sum zs) Here the number of random variables (n) can change over time, and I ultimately want effects to happen when they are instantiated. There is a brief overview at http://www.bali-phy.org/models.php

2 2

How to build a horse with Haskell (comic extension)
by J Ho 31 Oct '19

31 Oct '19

There was this comics “how to build a horse” with different languages. I’ve always felt Haskell was missing. Found this on Quora - https://www.quora.com/How-do-you-build-a-horse-with-the-Haskell-programming… How to build a horse with Haskell. Building just a horse is boring, so you generalize it to a spherical horse in vacuum that can represent other animals sufficiently well. It takes 5 years, 43 research papers and only 3 people in the world can ride it (including SPJ). You build a horse. It’s fast, but lazy. You build a beautiful, friendly horse. You call it Monadic Quadro-pedo-functorial Transporter. People are afraid to touch it and it dies of loneliness. You build something that is Maybe a horse. All your horses come in boxes with bottom. You were a java programmer so you build a horse factory. It gives you Either a horse or a terrible runtime abomination. You build an existential horse. You can’t see or access its hoofs, tail, back, anything. It just sort of sits there and stares at you. You build an infinitely large horse. You can still ride it, because it’s lazy (it just sits there, just like the existential, and you crawl on its back slowly). You tease Java programmers who can’t possibly ride infinite horses. You build an even faster horse that is unboxed. You notice it is eager. You build a higher-kinded Horsificator. It turns anything else into horses. data Horsificator a = Horse a | Abomination You want to ride a rhino, but they normally would kill you. You build a horse typeclass. You make rhinos an instance of Horse. Polymorphic domestication!

1 0

Call for Workshop Proposals: ICFP 2020
by Sam Tobin-Hochstadt 30 Oct '19

30 Oct '19

CALL FOR WORKSHOP AND CO-LOCATED EVENT PROPOSALS ICFP 2020 25th ACM SIGPLAN International Conference on Functional Programming August 23 - 28, 2020 Jersey City, NJ, US https://icfp19.sigplan.org/ The 25th ACM SIGPLAN International Conference on Functional Programming will be held in Jersey City, New Jersey on August 23-28, 2020. ICFP provides a forum for researchers and developers to hear about the latest work on the design, implementations, principles, and uses of functional programming. Proposals are invited for workshops (and other co-located events, such as symposiums) to be affiliated with ICFP 2020 and sponsored by SIGPLAN. These events should be less formal and more focused than ICFP itself, include sessions that enable interaction among the attendees, and foster the exchange of new ideas. The preference is for one-day events, but other schedules can also be considered. The workshops are scheduled to occur on August 23rd (the day before ICFP) and 27-28th of August (the two days after ICFP). ---------------------------------------------------------------------- Submission details Deadline for submission: November 15, 2019 Notification of acceptance: December 13, 2019 Prospective organizers of workshops or other co-located events are invited to submit a completed workshop proposal form in plain text format to the ICFP 2020 workshop co-chairs (Jennifer Hackett and Leonidas Lampropoulos) via email to icfp-workshops-2020(a)googlegroups.com by November 15, 2019. (For proposals of co-located events other than workshops, please fill in the workshop proposal form and just leave blank any sections that do not apply.) Please note that this is a firm deadline. Organizers will be notified if their event proposal is accepted by December 13, 2019, and if successful, depending on the event, they will be asked to produce a final report after the event has taken place that is suitable for publication in SIGPLAN Notices. The proposal form is available at: http://www.icfpconference.org/icfp2020-files/icfp20-workshops-form.txt Further information about SIGPLAN sponsorship is available at: http://www.sigplan.org/Resources/Proposals/Sponsored/ ---------------------------------------------------------------------- Selection committee The proposals will be evaluated by a committee comprising the following members of the ICFP 2020 organizing committee, together with the members of the SIGPLAN executive committee. Workshop Co-Chair: Jennifer Hackett (University of Nottingham) Workshop Co-Chair: Leonidas Lampropoulos (University of Maryland) General Chair: Stephanie Weirich (University of Pennsylvania) Program Chair: Adam Chlipala (MIT) ---------------------------------------------------------------------- Further information Any queries should be addressed to the workshop co-chairs (Jennifer Hackett and Leonidas Lampropoulos), via email to icfp-workshops-2020(a)googlegroups.com.

1 0

A Haskell meetup in San Francisco today
by Dimitri DeFigueiredo 29 Oct '19

29 Oct '19

After a long wait, there's a haskell meetup in San Francisco today. https://www.meetup.com/Bay-Area-Haskell-Users-Group/events/265110367/ Exciting! :-) Dimitri -- 2E45 D376 A744 C671 5100 A261 210B 8461 0FB0 CA1F

1 0

ANN: reflex-basic-host-0.2.0.1, reflex-backend-socket-0.2.0.0
by Jack Kelly 29 Oct '19

29 Oct '19

I have just pushed two packages to hackage: 1. reflex-basic-host-0.2.0.1[1], a reflex host library for backend work, and 2. reflex-backend-socket-0.2.0.0[2] a reflex-flavoured wrapper around TCP sockets. The most important changes to reflex-basic-host are: * Hosts no longer needlessly fork a thread, meaning that it is safe to call native code which expects all library calls to come from a common thread; and * Each host runs in a separate Reflex timeline, which makes it possible to run multiple Reflex hosts in parallel. There is an example[3] on GitHub demonstrating two hosts passing messages to each other. I hope people find it useful. GitHub issues and PRs welcome[4, 5]. Best, -- Jack [1] https://hackage.haskell.org/package/reflex-basic-host-0.2.0.1 [2] https://hackage.haskell.org/package/reflex-backend-socket-0.2.0.0 [3] https://github.com/qfpl/reflex-basic-host/blob/master/example/Multithread.hs [4] https://github.com/qfpl/reflex-basic-host [5] https://github.com/qfpl/reflex-backend-socket

1 0

Functional Conference 2019 with Edward Kmett keynote | Bengaluru, 13-17 November
by John Sinclair 29 Oct '19

29 Oct '19

Hi haskell-cafe! If you're in India, you'll be interested in Functional Conference 2019. It's an opportunity to meet up with other functional programmers and Haskell users. You'll learn from Edward Kmett who is chairman of the Haskell Core Libraries Committee. He'll be delivering a keynote, a workshop and more. https://confng.in/Kmg8m-Tx Michael Snoyman from Israel will be giving an Applied Haskell workshop. https://confng.in/24haPWyw All up their are 15 sessions covering Haskell to broaden your horizons and deepen your knowledge. Functional Conf is the premiere event for Functional programmers in India. Our goal is to support the community with access to high quality speakers, who are innovating in this field. Learn more about the conference here: https://confng.in/wAQ41Z4q To get 10% off when you register, use the code: FnConf19Dis$ https://twitter.com/FnConf <https://llink.to/?u=https:%2F%2Ftwitter.com%2FFnConf&e=df52b49527f43fa29bda…> https://www.linkedin.com/showcase/functional-conf <https://llink.to/?u=https:%2F%2Fwww.linkedin.com%2Fshowcase%2Ffunctional-co…>

1 0