June 2018 - Haskell-Cafe

[ANNOUNCE] GHC 8.4.3 released
by Ben Gamari 14 Jul '18

14 Jul '18

Hello everyone, The GHC team is pleased to announce the availability of GHC 8.4.3. The source distribution, binary distributions, and documentation for this release are available at https://downloads.haskell.org/~ghc/8.4.3 This release includes a few bug fixes including: * A code generation bug resulting in crashing of some programs using UnboxedSums has been fixed (#15038). * #14381, where Cabal and GHC would disagree about abi-depends, resulting in build failures, has been worked around. Note that the work-around patch has already been shipped by several distributions in previous releases, so this change may not be visible to you. * By popular demand, GHC now logs a message when it reads a package environment file, hopefully eliminating some of the confusion wrought by this feature. * GHC now emits assembler agreeable to newer versions of Gnu binutils, fixing #15068. * SmallArray#s can now be compacted into a compact region Thanks to everyone who has contributed to developing, documenting, and testing this release! As always, let us know if you encounter trouble. How to get it ~~~~~~~~~~~~~ The easy way is to go to the web page, which should be self-explanatory: http://www.haskell.org/ghc/ We supply binary builds in the native package format for many platforms, and the source distribution is available from the same place. Packages will appear as they are built - if the package for your system isn't available yet, please try again later. Background ~~~~~~~~~~ Haskell is a standardized lazy functional programming language. GHC is a state-of-the-art programming suite for Haskell. Included is an optimising compiler generating efficient code for a variety of platforms, together with an interactive system for convenient, quick development. The distribution includes space and time profiling facilities, a large collection of libraries, and support for various language extensions, including concurrency, exceptions, and foreign language interfaces. GHC is distributed under a BSD-style open source license. A wide variety of Haskell related resources (tutorials, libraries, specifications, documentation, compilers, interpreters, references, contact information, links to research groups) are available from the Haskell home page (see below). On-line GHC-related resources ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Relevant URLs: GHC home page https://www.haskell.org/ghc/ GHC developers' home page https://ghc.haskell.org/trac/ghc/ Haskell home page https://www.haskell.org/ Supported Platforms ~~~~~~~~~~~~~~~~~~~ The list of platforms we support, and the people responsible for them, is here: https://ghc.haskell.org/trac/ghc/wiki/TeamGHC Ports to other platforms are possible with varying degrees of difficulty. The Building Guide describes how to go about porting to a new platform: https://ghc.haskell.org/trac/ghc/wiki/Building Developers ~~~~~~~~~~ We welcome new contributors. Instructions on accessing our source code repository, and getting started with hacking on GHC, are available from the GHC's developer's site: https://ghc.haskell.org/trac/ghc/ Mailing lists ~~~~~~~~~~~~~ We run mailing lists for GHC users and bug reports; to subscribe, use the web interfaces at https://mail.haskell.org/cgi-bin/mailman/listinfo/glasgow-haskell-users https://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-tickets There are several other haskell and ghc-related mailing lists on www.haskell.org; for the full list, see https://mail.haskell.org/cgi-bin/mailman/listinfo Many GHC developers hang out on #haskell on IRC: https://www.haskell.org/haskellwiki/IRC_channel Please report bugs using our bug tracking system. Instructions on reporting bugs can be found here: https://www.haskell.org/ghc/reportabug

5 11

Announce: Haskell Platform 8.4.3
by Gershom B 09 Jul '18

09 Jul '18

On behalf of the Haskell Platform team, I'm happy to announce the release of Haskell Platform 8.4.3 Now available at https://www.haskell.org/platform/ This includes GHC 8.4.3, cabal-install 2.2.0.0, and stack 1.7.1. A full list of contents is available at https://www.haskell.org/platform/contents.html Outside of the update of the GHC to 8.4.3, the only substantive change in this release is to the new version of the primitive library, which includes a range of fixes and improvements. The list of GHC changes is available at: https://ghc.haskell.org/trac/ghc/blog/ghc-8.4.3-released And the list of changes to Primitive is available at: http://hackage.haskell.org/package/primitive-0.6.4.0/changelog There are (still) currently no 32 bit Windows builds available. We're looking into the issues preventing us from building an installer for that platform. The components all appear to work individually in such a case, and can be installed separately by users who so desire. Happy Haskell Hacking all, Gershom

1 1

Measuring memory usage
by Vlatko Basic 04 Jul '18

04 Jul '18

Hello, I've come to some strange results using Weigh package. It shows that HashMap inside 'data' is using much, much more memory. The strange thing is that I'm seeing too large mem usage in my app as well (several "MapData" like in records), and trying to figure out with 'weigh' what's keeping the mem. Noticed that when I change the code to use HashMap directly (not inside 'data', that's the only change), the mem usage observed with top drops down for ~60M, from 850M to 790M. These are the test results for 10K, 5K and 3.3K items for "data MapData k v = MapData (HashMap k v)" (at the end is the full runnable example.) Case Allocated GCs HashMap 262,824 0 HashMap half 58,536 0 HashMap third 17,064 0 MapData 4,242,208 4 I tested by changing the order, disabling all but one etc., and the results were the same. Same 'weigh' behaviour with IntMap and Map. So, if anyone knows and has some experience with such issues, my questions are: 1. Is 'weigh' package reliable/usable, at least to some extent? (the results do show diff between full, half and third) 2. How do you measure mem consumptions of your large data/records? 3. If the results are even approximately valid, what could cause such large discrepancies with 'data'? 4. Is there a way to see if some record has been freed from memory, GCed? module Main where import Prelude import Control.DeepSeq (NFData) import Data.HashMap.Strict (HashMap, fromList) import GHC.Generics (Generic) import Weigh (mainWith, value) data MapData k v = MapData (HashMap k v) deriving Generic instance (NFData k, NFData v) => NFData (MapData k v) full, half, third :: Int full = 10000 half = 5000 third = 3333 main :: IO () main = mainWith $ do value "HashMap" ( mkHMList full) value "HashMap half" ( mkHMList half) value "HashMap third" ( mkHMList third) value "MapData" (MapData $ mkHMList full) mkHMList :: Int -> HashMap Int String mkHMList n = fromList . zip [1..n] $ replicate n "some text"

4 8

ANN: hledger-1.10
by Simon Michael 02 Jul '18

02 Jul '18

hledger (http://hledger.org) is a friendly, robust, cross-platform program for tracking money, time or other commodities, using double-entry accounting, simple plain text file formats, and command-line, curses or web UIs. I'm very pleased to announce hledger 1.10, including work by release contributors: Alex Chen, Everett Hildenbrandt, Jakub Zárybnický, Nolan Darilek, Dmitry Astapov, Jacob Weisz, Peter Simons, Stephen Morgan, Pavlo Kerestey, Trevor Riles, Léo Gaspard, Mykola Orliuk, Wad, Nana Amfo. You'll note this is not 2.0 as previously planned - we will spend a bit more time on that. The next major release is expected to be on 2018/09/30. Please see http://hledger.org/release-notes#hledger-1.10 for the changes (as soon as I can get to those; until then, the package changelogs): http://hackage.haskell.org/package/hledger-1.10/changelog http://hackage.haskell.org/package/hledger-ui-1.10/changelog http://hackage.haskell.org/package/hledger-web-1.10/changelog http://hackage.haskell.org/package/hledger-api-1.10/changelog http://hackage.haskell.org/package/hledger-lib-1.10/changelog How to get started: ------------------- See http://hledger.org/download for all install methods. One of the easiest is the hledger-install script, which requires only bash and will build and install the hledger tools in $HOME/.local/bin/: $ curl -O https://raw.githubusercontent.com/simonmichael/hledger/master/hledger-insta… $ less hledger-install.sh # (do security review) $ bash hledger-install.sh # (add -v for more detail; use bash -x to show commands being run) or (insecure): $ curl https://raw.githubusercontent.com/simonmichael/hledger/master/hledger-insta… | bash After installation, ensure $HOME/.local/bin is in your $PATH, and try some commands: $ hledger -h # quick help $ hledger help # list built-in manuals $ hledger add # record some transactions $ hledger # list available commands Next, I encourage you to at least skim the tutorials and docs at http://hledger.org. Say hello and ask questions in the #hledger IRC channel on Freenode: http://irc.hledger.org. New users and contributors are always welcome! Give feedback, report bugs, send pull requests, write, evangelise, donate. Best! -Simon

1 1

[ANNOUNCE] GHC 8.6.1-alpha1 available
by Ben Gamari 30 Jun '18

30 Jun '18

The GHC development team is pleased to announce the first alpha release leading up to GHC 8.6.1. The usual release artifacts are available from https://downloads.haskell.org/~ghc/8.6.1-alpha1 This is the first release (partially) generated using our new CI infrastructure. One known issue is that the haddock documentation is currently unavailable. This will be fixed in the next alpha release. Do let us know if you spot anything else amiss. As always, do let us know if you encounter any trouble in the course of testing. Thanks for your help! Cheers, - Ben

4 6

need help understanding how to specify constraints on monads
by Dennis Raddle 29 Jun '18

29 Jun '18

I'm writing a program with several functions, some of which depend on certain fields in a state monad, others of which depend on others, but no routine needs all the fields. So I thought I would declare a two classes, one for each type of data need that a function has: -- as an aside, here's an example of data which is parameterized by two types. data ReportData t1 t2 = ... -- this is rolling my own state monad with a random generator class Monad m => RandMonad m where getGen :: m StdGen putGen :: StdGen -> () -- this is a class of state monad which logs ReportData: class Monad m => LogMonad m where putReport :: ReportData t1 t2 -> m () For a particular use case, I declare a type of State monad: data MyStateData t1 t2 = MyStateData t1 t2 { theGen :: StdGen , theReports :: [StepReport t1 t2] } type MyState t1 t2 = State (MyStateData t1 t2) And I try to define my instances: instance RandMonad (MyState t1 t2) where getGen = gets theGen putGen g = modify (\s -> s { theGen = g}) instance LogMonad (MyState t1 t2) where putReport r = modify (\s -> s { theReports = r : theReports s}) I get an error on the LogMonad instance, saying that there's no instance for (MonadState (MyState t1 t2) (StateT (MyState t1 t2) Identity)) I guess I don't really understand typeclasses once you start using higher kinded types, so please enlighten me. Any reading on this subject would be helpful, too.

5 12

(New to Conduits) mixing lazy lists and Conduits?
by Jon Fairbairn 29 Jun '18

29 Jun '18

Suppose I’m writing some code using Conduits, but need to use some old function f::[a]->[b] (defined in a library somewhere) that transforms a lazy list. Is there a way of turning f into a Conduit without ending up with all of the list being in memory? ie something that looks like toConduit:: ([a]->[b]) -> ConduitT a b m () I’ve got nowhere with Hoogle or Hayoo -- Jón Fairbairn Jon.Fairbairn(a)cl.cam.ac.uk

3 7

Re: [Haskell-cafe] Lattice and calculation of Least Upper Bounds
by Olaf Klinke 28 Jun '18

28 Jun '18

Aaron, the lattices package provides some modules to extend a given lattice by some elements, e.g. new top and bottoms. There are also derived typeclass instances for combinations like tuples, endomorphisms and so forth. But the way of choice really depends on what you know about your multiple inheritance hierarchy. In universal algebra one powerful method of constructing (semi-)lattices is by generators and relations. That means you define the lattice as a quotient of a free lattice. The quotient itself is defined as a set of ineqalities on the generators. I don't know how one would implement that without dependent types, though, as the type would be another type together with a function. To make things worse, the word problem is undecidable in general. Looking at Algebra.Lattice.Free I'm surprised that the free (semi-)lattice types don't have a Monad instance. Does anyone know why they are not implemented? Under the hood the free lattice types are identical to the continuation monad. Olaf >Hi, > >I am trying to work out how to use the Algebra.Lattice family of Lattice >data structures. > >Firstly how do I construct a lattice ? > >What I am wanting to do is to be able to construct a lattice to represent a >multiple inheritance hierarchy. Then I to be able to find the Least Upper >Bound of a set of classes/types. This is in order to find the type of a >multiple case expression. > >I am not sure if the Haskell classes are actually applicable ? but if they >are how do I apply them to the following problem please ?

3 3

Deadline extension for FARM 2018 (now July 8) - Workshop on Functional Art, Music, Modelling, and Design
by Brent Yorgey 28 Jun '18

28 Jun '18

The FARM submission deadline for papers and demo proposals has been extended to July 8 (the same as the performance submission deadline). 6th ACM SIGPLAN International Workshop on Functional Art, Music, Modelling and Design St. Louis, Missouri, USA, September 29th 2018 Call for Papers and Performances Key Dates ========= Paper submission deadline (extended) July 8 Performance submission deadline July 8 Author Notification July 21 Camera Ready August 5 Workshop September 29 About FARM ========== The ACM SIGPLAN International Workshop on Functional Art, Music, Modelling and Design (FARM) gathers together people who are harnessing functional techniques in the pursuit of creativity and expression. It is co-located with ICFP 2018, the 23rd ACM SIGPLAN International Conference on Functional Programming, and with Strange Loop, in St. Louis, Missouri, USA. Functional Programming has emerged as a mainstream software development paradigm, and its artistic and creative use is booming. A growing number of software toolkits, frameworks and environments for art, music and design now employ functional programming languages and techniques. FARM is a forum for exploration and critical evaluation of these developments, for example to consider potential benefits of greater consistency, tersity, and closer mapping to a problem domain. FARM encourages submissions from across art, craft and design, including textiles, visual art, music, 3D sculpture, animation, GUIs, video games, 3D printing and architectural models, choreography, poetry, and even VLSI layouts, GPU configurations, or mechanical engineering designs. Theoretical foundations, language design, implementation issues, and applications in industry or the arts are all within the scope of the workshop. The language used need not be purely functional (“mostly functional” is fine), and may be manifested as a domain specific language or tool. Moreover, submissions focusing on questions or issues about the use of functional programming are within the scope. FARM 2018 website : http://functional-art.org/2018/ Call for Performances ===================== Submission deadline: July 8, 2018. Submission URL: https://easychair.org/conferences/?conf=farm2018 . FARM also hosts a traditional evening of performances. For this year’s event, FARM 2018 is seeking proposals for live performances which employ functional programming techniques, in whole or in part. We would like to support a diverse range of performing arts, including music, dance, video animation, and performance art. We encourage both risk-taking proposals which push forward the state of the art and refined presentations of highly-developed practice. In either case, please support your submission with a clear description of your performance including how your performance employs functional programming and a discussion of influences and prior art as appropriate. Call for Papers and Demos ========================= Submission deadline (extended): July 8 Submission URL: https://easychair.org/conferences/?conf=farm2018 . We welcome submissions from academic, professional, and independent programmers and artists. Submissions are invited in three categories: 1) Original papers We solicit original papers in the following categories: - Original research - Overview / state of the art - Technology tutorial All submissions must propose an original contribution to the FARM theme. FARM is an interdisciplinary conference, so a wide range of approaches are encouraged. An original paper should have 5 to 12 pages, be in portable document format (PDF), using the ACM SIGPLAN style guidelines and the ACM SIGPLAN template. [ http://www.sigplan.org/Resources/Author/ -- use the 'sigplan' sub-format. ] Accepted papers will be published in the ACM Digital Library as part of the FARM 2018 proceedings. See http://authors.acm.org/main.cfm for information on the options available to authors. Authors are encouraged to submit auxiliary material for publication along with their paper (source code, data, videos, images, etc.); authors retain all rights to the auxiliary material. 2) Demo proposals Demo proposals should describe a demonstration to be given at the FARM workshop and its context, connecting it with the themes of FARM. A demo could be in the form of a short (10-20 minute) tutorial, presentation of work-in-progress, an exhibition of some work, or even a performance. Demo proposals should be in plain text, HTML or Markdown format, and not exceed 2000 words. A demo proposal should be clearly marked as such, by prepending Demo Proposal: to the title. Demo proposals will be published on the FARM website. A summary of the demo performances will also be published as part of the conference proceedings, to be prepared by the program chair. 3) Calls for collaboration Calls for collaboration should describe a need for technology or expertise related to the FARM theme. Examples may include but are not restricted to: - art projects in need of realization - existing software or hardware that may benefit from functional programming - unfinished projects in need of inspiration Calls for collaboration should be in plain text, HTML or Markdown format, and not exceed 5000 words. A call for collaboration should be clearly marked as such, by prepending Call for Collaboration: to the title. Calls for collaboration will be published on the FARM website. Authors take note ================= The official publication date is the date the proceedings are made available in the ACM Digital Library. This date may be up to two weeks prior to the first day of your conference. The official publication date affects the deadline for any patent filings related to published work. All presentations at FARM 2018 will be recorded. Permission to publish the resulting video (in all probability on YouTube, along with the videos of ICFP itself and the other ICFP-colocated events) will be requested on-site. Questions ========= If you have any questions about what type of contributions that might be suitable, or anything else regarding submission or the workshop itself, please contact the organisers at: farm-2018(a)functional-art.org Workshop Organization ==================== Brent Yorgey (general chair) Donya Quick (program chair) Tom Murphy (performance chair) Program Committee ================= Heinrich Apfelmus (self-employed) Chuck Jee Chau (Hong Kong University of Science and Technology, Hong Kong) Brian Heim (Yale, USA) Can Ince (ince.io) Chris Martens (NC State University, USA) Eduardo Miranda (University of Plymouth, UK) Ivan Perez Dominguez (University of Nottingham, UK) Iris Ren (Utrecht University, Netherlands) Henning Thielemann (self-employed) Didier Verna (EPITA, France) Dan Winograd-Cort (Target, USA) Halley Young (University of Pennsylvania, USA) Code of Conduct =============== FARM adheres to ICFP 2018's Code of Conduct: http://icfp18.sigplan.org/attending/code-of-conduct

1 0

Alternative Preludes
by Hilco Wijbenga 28 Jun '18

28 Jun '18

Hi all, I've been looking for a different Prelude to, at minimum, default to Text instead of String but I'm sure there are other things that would be helpful. E.g., less focus on lists. I had a look at [1] and protolude, classy-prelude, basic-prelude, foundation, safe-prelude, and rio all seem interesting. Maybe even base-noprelude? I'm an advanced beginner (I don't think I qualify as intermediate yet). Going by [1], classy-prelude might not be such a good idea because of "scary error messages". And, I'm guessing, I would need to know Haskell better to take advantage of base-noprelude? I would like to know your thoughts/suggestions/opinions/ideas. Also, if there are other preludes that might be of interest, do tell! Cheers, Hilco [1] https://guide.aelve.com/haskell/alternative-preludes-zr69k1hc

5 4