August 2019 - Haskell-Cafe

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

[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

Book reviewers wanted
by John Whitington 31 Aug '19

31 Aug '19

Hello, I've prepared a book "Haskell from the Very Beginning" in the same manner as my earlier "OCaml from the Very Beginning". It would be useful to find some people to look it over before release. I did this with the OCaml book, and it improved it markedly. I'm particularly looking for people who have taught or learned Haskell as a first programming language (either in an academic setting or not). I should point out that the book has already benefited from a full, paid, technical review, so you would not be being used as a substitute for that. Do drop me an email if you're interested. There would be, of course, no obligation. Thanks, John -- John Whitington Director, Coherent Graphics Ltd

4 3

[CFP] Final Day for submissions to Functional Conf 2019 in Bengaluru!
by John Sinclair 31 Aug '19

31 Aug '19

Are you using Haskell in innovative ways? Do you have expertise the community would benefit from? Functional Conf 2019 is India's premier Functional programming conference, and we would love to hear from you! Submit your session proposal here: https://confng.in/zmRYXh7N <https://llink.to/?u=https:%2F%2Fconfng.in%2FzmRYXh7N&e=b3dafcbd9791228f91b8…> Hurry! Submissions close today (Aug 31)! 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. 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

A faithful strictly-accumulating writer
by David Feuer 30 Aug '19

30 Aug '19

It's widely known that the classic WriterT tends to leak space, and that in some cases this leak can be resolved by using StateT instead. The implementations I've seen of this idea both use the module system to prevent the computation from gaining unauthorized access to the state. I believe I've found a way to avoid this. Does this look right? {-# language RankNTypes, FlexibleInstances, MultiParamTypeClasses #-} import qualified Control.Monad.Writer.Class as W import Control.Monad.State.Strict import Control.Monad.Reader import Control.Applicative -- The key idea is that the computation -- can't inspect the state because it doesn't know the type newtype WriterT w m a = WriterT { unWriterT :: forall s. ReaderT ((w -> w) -> s -> s) (StateT s m) a } runWriterT :: Monoid w => WriterT w m a -> m (a, w) runWriterT m = runStateT (runReaderT (unWriterT m) id) mempty instance Functor m => Functor (WriterT w m) where fmap f m = WriterT $ fmap f (unWriterT m) instance Monad m => Applicative (WriterT w m) where pure a = WriterT (pure a) liftA2 f m n = WriterT $ liftA2 f (unWriterT m) (unWriterT n) instance Monad m => Monad (WriterT w m) where m >>= f = WriterT $ unWriterT m >>= unWriterT . f instance MonadTrans (WriterT w) where lift m = WriterT $ lift . lift $ m tell :: (Monad m, Semigroup w) => w -> WriterT w m () tell w = WriterT $ do p <- ask modify' $ p (<> w) pass :: Monad m => WriterT w m (a, w -> w) -> WriterT w m a pass m = WriterT $ do p <- ask (a, ww) <- unWriterT m modify' (p ww) pure a instance (Monoid w, Monad m) => W.MonadWriter w (WriterT w m) where tell = tell listen m = do aw@(_a, w) <- lift $ runWriterT m tell w pure aw pass = pass

3 7

Call for scholarship applications: PLMW @ POPL 2020
by Robbert Krebbers 30 Aug '19

30 Aug '19

CALL FOR SCHOLARSHIP APPLICATIONS (** DEADLINE: OCTOBER 7 **) ACM SIGPLAN Programming Languages Mentoring Workshop, New Orleans, Louisiana Tuesday, January 21, 2020 Co-located with POPL 2020 Web page: https://popl20.sigplan.org/home/PLMW-POPL-2020 After the success of the first eight Programming Languages Mentoring Workshops at POPL 2012-2019 we are announcing the 9th SIGPLAN Programming Languages Mentoring Workshop (PLMW), co-located with POPL 2020 and organized by Stephanie Balzer, Justin Hsu, Robbert Krebbers, and Nobuko Yoshida. The purpose of this mentoring workshop is to encourage graduate students and senior undergraduate students to pursue careers in programming language research. This workshop will bring together world leaders in programming languages research and teaching from academia and industry to provide (a) technical sessions on cutting-edge PL research and (b) mentoring sessions on how to prepare for a research career. The workshop will help students imagine how they might contribute to our research community. We especially encourage women and underrepresented minority students, and people with disabilities to attend PLMW. This workshop is part of the activities surrounding POPL, the Symposium on Principles of Programming Languages, and takes place the day before the main conference. One goal of the workshop is to make the POPL conference more accessible to newcomers. We hope that participants will stay through the entire conference. A number of sponsors (listed below) have generously donated scholarship funds for qualified students to attend PLMW. These scholarships should cover reasonable expenses (airfare, hotel, and registration fees) for attendance at both the workshop and the POPL conference. Students attending this year will get one year free student membership of SIGPLAN, unless they prefer to opt out during their application. The workshop registration is open to all. Students with alternative sources of funding are welcome as well. APPLICATION for PLMW scholarship: The scholarship application can be accessed at the following URL: https://forms.gle/dzV8ELgQUx2xfEjm9 The deadline for full consideration of funding is Monday, October 7. Selected participants will be notified by October 21. Confirmed speakers (so far): * Adriana Compagnoni, Stevens Institute of Technology * Isil Dillig, UT Austin * Derek Dreyer, MPI-SWS * Marco Gaboardi, SUNY Buffalo * Lindsey Kuper, UC Santa Cruz * Xavier Leroy, Inria Confirmed sponsors (so far): * An Anonymous Donor * NSF * ACM SIGPLAN * Amazon

1 0

Haskell internship at Tsuru Capital
by Mikhail Baykov 29 Aug '19

29 Aug '19

Hi Cafe It's that time of year again and we are looking for more interns. Haskell knowledge is required, experience with pricing futures/options would be nice but not necessary. Located in Tokyo, company language is English. Casual environment, nice monitors and a big coffee machine. Duration 3-6 months, starting at your convenience. We will help you with visa and looking for a place to stay. There's some salary. Details how to apply are on our website: http://www.tsurucapital.com/en/ Feel free to ask questions here, on Reddit or #tsurucapital on freenode. https://www.reddit.com/r/haskell/comments/cx8yei/tsuru_capital_is_looking_f…

1 0

First call for draft papers for TFPIE 2020 (Trends in Functional Programming in Education)
by Jurriaan Hage 28 Aug '19

28 Aug '19

Hello, Please, find below the final call for draft papers for TFPIE 2020. Please forward these to anyone you think may be interested. Apologies for any duplicates you may receive. best regards, Jurriaan Hage Chair of TFPIE 2020 ======================================================================== TFPIE 2020 Call for papers http://www.staff.science.uu.nl/~hage0101/tfpie2020/index.html February 12th 2020, Krakow, Poland (co-located with TFP 2020 and Lambda Days) TFPIE 2020 welcomes submissions describing techniques used in the classroom, tools used in and/or developed for the classroom and any creative use of functional programming (FP) to aid education in or outside Computer Science. Topics of interest include, but are not limited to: FP and beginning CS students FP and Computational Thinking FP and Artificial Intelligence FP in Robotics FP and Music Advanced FP for undergraduates FP in graduate education Engaging students in research using FP FP in Programming Languages FP in the high school curriculum FP as a stepping stone to other CS topics FP and Philosophy The pedagogy of teaching FP FP and e-learning: MOOCs, automated assessment etc. Best Lectures - more details below In addition to papers, we are requesting best lecture presentations. What's your best lecture topic in an FP related course? Do you have a fun way to present FP concepts to novices or perhaps an especially interesting presentation of a difficult topic? In either case, please consider sharing it. Best lecture topics will be selected for presentation based on a short abstract describing the lecture and its interest to TFPIE attendees. The length of the presentation should be comparable to that of a paper. On top of the lecture itself, the presentation can also provide commentary on the lecture. Submissions Potential presenters are invited to submit an extended abstract (4-6 pages) or a draft paper (up to 20 pages) in EPTCS style. The authors of accepted presentations will have their preprints and their slides made available on the workshop's website. Papers and abstracts can be submitted via easychair at the following link: https://easychair.org/conferences/?conf=tfpie2020 . After the workshop, presenters will be invited to submit (a revised version of) their article for review. The PC will select the best articles that will be published in the Electronic Proceedings in Theoretical Computer Science (EPTCS). Articles rejected for presentation and extended abstracts will not be formally reviewed by the PC. Dates Submission deadline: January 14th 2020, Anywhere on Earth. Notification: January 17th 2020 TFPIE Registration Deadline: January 20th 2020 Workshop: February 12th 2020 Submission for formal review: April 19th 2020, Anywhere on Earth. Notification of full article: June 6th 2020 Camera ready: July 1st 2020 Program Committee Olaf Chitil - University of Kent Youyou Cong - Tokyo Institute of Technology Marko van Eekelen - Open University of the Netherlands and Radboud University Nijmegen Jurriaan Hage (Chair) - Utrecht University Marco T. Morazan - Seton Hall University, USA Sharon Tuttle - Humboldt State University, USA Janis Voigtlaender - University of Duisburg-Essen Viktoria Zsok - Eotvos Lorand University Note: information on TFP is available at http://www.cse.chalmers.se/~rjmh/tfp/

1 0

GHC: Policy on -O flags?
by Andreas Klebinger 27 Aug '19

27 Aug '19

Hello ghc-devs and haskell users. I'm looking for opinions on when an optimization should be enabled by default. -O is currently the base line for an optimized build. -O2 adds around 10-20% compile time for a few % (around 2% if I remember correctly) in performance for most things. The question is now if I implement a new optimization, making code R% faster but slowing down the compiler down by C% at which point should an optimization be: * Enabled by default (-O) * Enabled only at -O2 * Disabled by default Cheap always beneficial things make sense for -O Expensive optimizations which add little make sense for -O2 But where exactly is the line here? How much compile time is runtime worth? If something slows down the compiler by 1%/2%/5% and speeds up code by 0.5%/1%/2% which combinations make sense for -O, -O2? Can there even be a good policy with the -O/-O2 split? Personally I generally want code to either: * Typecheck/Run at all (-O0, -fno-code, repl) * Not blow through all my RAM when adding a few Ints while developing: -O ? * Make a reasonable tradeoff between runtime/compiletime: -O ? * Give me all you got: -O2 (-O99999) The use case for -O0 is rather clear, so is -O2. But what do people consider the use case for -O What trade offs seem acceptable to you as a user of GHC? Is it ok for -O to become slower for faster runtimes? How much slower? Should all new improvements which might slow down compilation be pushed to -O2? Or does an ideal solution add new flags? Tell me what do you think. Cheers, Andreas Klebinger

4 3

Munich Haskell Meeting, 2019-08-29 @ 19:30
by Leah Neukirchen 27 Aug '19

27 Aug '19

Dear all, This week, our monthly Munich Haskell Meeting will take place again on Thursday, August 29 at Augustiner-Gaststätte Rumpler at 19h30. For details see here: http://muenchen.haskell.bayern/dates.html If you plan to join, please add yourself to this dudle so we can reserve enough seats! It is OK to add yourself to the dudle anonymously or pseudonymously. https://dudle.inf.tu-dresden.de/haskell-munich-aug-2019/ Everybody is welcome! cu, -- Leah Neukirchen <leah(a)vuxu.org> https://leahneukirchen.org/

1 0