- Haskell-Cafe - Haskell.org

25th Anniversary of GHC
by Henk-Jan van Tuyl 14 Dec '17

14 Dec '17

L.S., The eleventh of this month was the 25th anniversary of GHC: the first full release of GHC was announced at 1992-12-11; the version number was 0.10 and a Sun 4 workstation was needed to run GHC. The announcement can be read at: http://code.haskell.org/~dons/haskell-1990-2000/msg00960.html Regards, Henk-Jan van Tuyl -- Message from Stanford University: Folding@home What if you could share your unused computer power to help find a cure? In just 5 minutes you can join the world's biggest networked computer and get us closer sooner. Watch the video. http://foldingathome.stanford.edu/ -- http://members.chello.nl/hjgtuyl/tourdemonad.html Haskell programming --

2 1

[ANN] Experimental Windows GHC 8.2.2+ 64-bit binary release. Binary compatible with Visual C/Native Windows SDK.
by kyra 13 Dec '17

13 Dec '17

An experimental Windows GHC 8.2.2+ 64-bit Visual C/Native Windows SDK binary compatible distribution is released. The distro is based on and targets Microsoft Visual C runtime and native Windows SDK. The code it produces is statically linkable with Microsoft Visual C and native Windows SDK libraries. Both Visual Studio 2013 and 2017/2015 are supported. Distribution site: https://awson.github.io/ghc-nw/. Cheers, K. Briantsev (aka awson)

1 0

how to run in bounded space?
by Johannes Waldmann 12 Dec '17

12 Dec '17

Dear Cafe. is there an easy way (in GHC Haskell) to run a computation until it (times out or) requires more than X MB of heap? (the main program has a larger heap, but the computation should use some part of it only) This would be nice for automated tests with predictable resources (time and space). There is Control.Timeout. I guess I want Control.Spaceout. - J.

4 5

Unsubscribe
by Peter Althainz 11 Dec '17

11 Dec '17

Am 11.12.2017 1:32 nachm. schrieb <haskell-cafe-request(a)haskell.org>: Send Haskell-Cafe mailing list submissions to haskell-cafe(a)haskell.org To subscribe or unsubscribe via the World Wide Web, visit http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe or, via email, send a message with subject or body 'help' to haskell-cafe-request(a)haskell.org You can reach the person managing the list at haskell-cafe-owner(a)haskell.org When replying, please edit your Subject line so it is more specific than "Re: Contents of Haskell-Cafe digest..." Today's Topics: 1. ANN: New Haskell.org Committee Members (Gershom B) 2. How to call constructor from Template Haskell (Baa) 3. Who can send a patche to vim project? (Takenobu Tani) 4. Re: Haskell IDE Engine logo poll (Alan & Kim Zimmerman) ---------------------------------------------------------------------- Message: 1 Date: Mon, 11 Dec 2017 01:36:50 -0500 From: Gershom B <gershomb(a)gmail.com> To: haskell-cafe <haskell-cafe(a)haskell.org>, haskell-community(a)haskell.org, Tikhon Jelvis <tikhon(a)jelv.is>, Ryan Trinkle <ryan.trinkle(a)gmail.com>, george(a)wils.online Subject: [Haskell-cafe] ANN: New Haskell.org Committee Members Message-ID: <CAM8RHpGY%2BZ_kG0cM%3DusFDEqX4UNgabWecMv_ZEiP85WmgritOg(a)mail.gmail.com> Content-Type: text/plain; charset="UTF-8" Following the self-nomination period and discussion, the Haskell.org committee has selected the following members for a new three-year term, expiring 2020: * Tikhon Jelvis * Ryan Trinkle (reappointment) * George Wilson As per the rules of the committee, this discussion was held among the current members of the committee, and the outgoing members of the committee who were not seeking reappointment. Thank you to all the many candidates who submitted a self-nomination. We received a number of strong nominations. We would encourage all those who nominated themselves to consider self-nominating again in the future. The outgoing members are: John Wiegley and Alan Zimmerman. Thanks both for your service! Regards, Gershom ------------------------------ Message: 2 Date: Mon, 11 Dec 2017 14:03:48 +0200 From: Baa <aquagnu(a)gmail.com> To: Haskell Cafe <haskell-cafe(a)haskell.org> Subject: [Haskell-cafe] How to call constructor from Template Haskell Message-ID: <20171211140348.2a1610b1@Pavel> Content-Type: text/plain; charset=US-ASCII Hello All! May be topic is not for Haskell beginners, so I'll re-send it to Cafe. I have function which constructs some data type. It has signature `Name -> Q [Dec]`. Somewhere in its body I'm extracting constructors of another type with pattern-matching: case tyCons of DataD ctx nm tyVars mbKind cs derivs -> ... Type of those constructors `cs` instantiates some class like this: class MyClass a where specialValue :: a So, I'm iterating over those `cs` but I want to skip one of them which is equal to `specialValue`. Something like this: [c | c <- cs, c /= specialValue] How to do this with Template Haskell's `Con` type (`c`::Con)? I can't simply call it to compare created value with a `specialValue`. === Best regards, Paul ------------------------------ Message: 3 Date: Mon, 11 Dec 2017 21:16:25 +0900 From: Takenobu Tani <takenobu.hs(a)gmail.com> To: haskell-cafe <haskell-cafe(a)haskell.org> Subject: [Haskell-cafe] Who can send a patche to vim project? Message-ID: <CAPB_NvzMGZS3OYEAXuqRCXyx_hsXYf8JaCj0S6cJ%3DVJeH-KwtQ(a)mail.gmail.com> Content-Type: text/plain; charset="utf-8" Hi cafe, Who can send a patche to vim project? I'd like to update vim syntax file (haskell.vim) to fix numeric literals. I read the vim `CONTRIBUTING.md` file [1]. It instructs me to contact the maintainer of each files. In the header of `haskell.vim`, the maintainor of `haskell.vim` is haskell-cafe@ML. [2] Who is the maintainer of `haskell.vim`? I'd like to make fix on numeric literals extension: [3] * BinaryLiterals * HexFloatLiterals * NumericUnderscores I prepared two kinds of patches. * Exact pattern version [4] * Fast (but approximate) pattern version [5] I visually checked patches with the these files [6][7]. Could you send a patch of [4] or [5] to vim project? P.S. I have already sent patches to two projects. * `language-haskell` for atom and linguist [8] You can already use it on atom. Linghist (which is used from github) will apply it soon. * `pygments` [9] It is pending review. [1]: https://github.com/vim/vim/blob/master/CONTRIBUTING.md# syntax-indent-and-other-runtime-files [2]: https://github.com/vim/vim/blob/master/runtime/syntax/haskell.vim#L3 [3]: https://github.com/ghc-proposals/ghc-proposals/blob/ master/proposals/0009-numeric-underscores.rst#new-syntax-this-proposal [4]: https://github.com/vim/vim/compare/master...takenobu-hs: syntax-haskell-literal-exact [5]: https://github.com/vim/vim/compare/master...takenobu-hs: syntax-haskell-literal-fast [6]: https://github.com/takenobu-hs/ghc/blob/squashed-numeric- underscores/testsuite/tests/parser/should_run/NumericUnderscores0.hs [7]: https://github.com/takenobu-hs/ghc/blob/squashed-numeric- underscores/testsuite/tests/parser/should_run/NumericUnderscores1.hs [8]: https://github.com/atom-haskell/language-haskell/commit/ f90eb7d8662493536f54898e52b4c7b1dc96de41 [9]: https://bitbucket.org/birkenfeld/pygments-main/issues/1399/update-haskell- with-lexer-for-numeric Regards, Takenobu

1 0

Re: [Haskell-cafe] Maintenance of streaming and streaming-bytestring
by David Feuer 11 Dec '17

11 Dec '17

I've added you as a member of haskell-streaming. Feel free to transfer the repo. On Sat, Dec 9, 2017 at 10:10 AM, Boespflug, Mathieu <m(a)tweag.io> wrote: > I'd like to contributed streaming-binary to the streaming GitHub org, if > you're up for it. > > http://hackage.haskell.org/package/streaming-binary > > Best, > > -- > Mathieu Boespflug > Founder at http://tweag.io. > > On 17 September 2017 at 01:24, David Feuer <david.feuer(a)gmail.com> wrote: >> >> Ah, right. Then yes, that sounds like a great approach. >> >> On Sep 15, 2017 1:23 PM, "Carter Schonwald" <carter.schonwald(a)gmail.com> >> wrote: >>> >>> GitHub has a transfer repo ownership toggle you can do to move the main >>> repo and it's assets >>> >>> On Fri, Sep 15, 2017 at 1:05 PM David Feuer <david.feuer(a)gmail.com> >>> wrote: >>>> >>>> Having an organization (with multiple owners and members) makes for much >>>> smoother transitions when maintainers change. That goes triple for >>>> unexpected changes. There's (still!) no really good way to migrate an issue >>>> tracker or PRs from one repository to another. Unfortunately, for that same >>>> reason, I believe that actually moving your project to the organization will >>>> be quite unpleasant if there are more than a few open tickets. And if there >>>> are more than a few closed tickets, then preserving history in a useful >>>> history seems hard too. Maybe someone else knows a reason this isn't >>>> actually terrible. >>>> >>>> David >>>> >>>> On Sep 14, 2017 1:10 AM, "Ivan Lazar Miljenovic" >>>> <ivan.miljenovic(a)gmail.com> wrote: >>>> >>>> Since you've seem to set this up as an organisation, would you be >>>> interested in my moving over the various streaming libraries I have >>>> there as well? >>>> >>>> On 14 September 2017 at 03:31, Andrew Martin <andrew.thaddeus(a)gmail.com> >>>> wrote: >>>> > The streaming and streaming-bytestring libraries are now being >>>> > maintained >>>> > here: https://github.com/haskell-streaming >>>> > >>>> > On Tue, Sep 12, 2017 at 4:50 PM, Andrew Martin >>>> > <andrew.thaddeus(a)gmail.com> >>>> > wrote: >>>> >> >>>> >> Thanks adding me as a maintainer. I'm new to this process, so I >>>> >> appreciate >>>> >> the tip about admin(a)hackage.haskell.org as well. >>>> >> >>>> >> -Andrew Martin >>>> >> >>>> >> On Tue, Sep 12, 2017 at 3:57 PM, Erik Hesselink <hesselink(a)gmail.com> >>>> >> wrote: >>>> >>> >>>> >>> Hi Andrew, >>>> >>> >>>> >>> We usually allow about 3 weeks for the maintainer to respond. Since >>>> >>> that >>>> >>> time has now passed I've added you as a maintainer for streaming and >>>> >>> streaming-bytestring. Let me know if there's anything else you need. >>>> >>> >>>> >>> For others looking to take over a package in the future, please CC >>>> >>> admin(a)hackage.haskell.org, there's a higher chance I'll see it there >>>> >>> than >>>> >>> just on the email lists. >>>> >>> >>>> >>> Regards, >>>> >>> >>>> >>> Erik (hackage admin) >>>> >>> >>>> >>> On 12 September 2017 at 20:18, Andrew Martin >>>> >>> <andrew.thaddeus(a)gmail.com> >>>> >>> wrote: >>>> >>>> >>>> >>>> Are there any further steps that I can take? >>>> >>>> >>>> >>>> On Thu, Sep 7, 2017 at 11:07 AM, Andrew Martin >>>> >>>> <andrew.thaddeus(a)gmail.com> wrote: >>>> >>>>> >>>> >>>>> David Feuer brought this up two weeks ago [0]. The maintainer of >>>> >>>>> streaming and streaming-bytestring has been unreachable, and >>>> >>>>> provided his >>>> >>>>> continued absence, I would like to become a maintainer of these >>>> >>>>> two >>>> >>>>> libraries. I have put up PRs fixing issues [1] and I've offered on >>>> >>>>> the issue >>>> >>>>> tracker to become a comaintainer [2]. I use this library a lot at >>>> >>>>> work, so I >>>> >>>>> have an interest in keeping it in good shape. >>>> >>>>> >>>> >>>>> [0] >>>> >>>>> >>>> >>>>> https://mail.haskell.org/pipermail/libraries/2017-August/028141.html >>>> >>>>> [1] https://github.com/michaelt/streaming-bytestring/pull/11 >>>> >>>>> [2] https://github.com/michaelt/streaming-bytestring/issues/19 >>>> >>>>> >>>> >>>>> -- >>>> >>>>> -Andrew Thaddeus Martin >>>> >>>> >>>> >>>> >>>> >>>> >>>> >>>> >>>> >>>> -- >>>> >>>> -Andrew Thaddeus Martin >>>> >>>> >>>> >>>> _______________________________________________ >>>> >>>> Libraries mailing list >>>> >>>> Libraries(a)haskell.org >>>> >>>> http://mail.haskell.org/cgi-bin/mailman/listinfo/libraries >>>> >>>> >>>> >>> >>>> >> >>>> >> >>>> >> >>>> >> -- >>>> >> -Andrew Thaddeus Martin >>>> > >>>> > >>>> > >>>> > >>>> > -- >>>> > -Andrew Thaddeus Martin >>>> > >>>> > _______________________________________________ >>>> > Haskell-Cafe mailing list >>>> > To (un)subscribe, modify options or view archives go to: >>>> > http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe >>>> > Only members subscribed via the mailman list are allowed to post. >>>> >>>> >>>> >>>> -- >>>> Ivan Lazar Miljenovic >>>> Ivan.Miljenovic(a)gmail.com >>>> http://IvanMiljenovic.wordpress.com >>>> _______________________________________________ >>>> Haskell-Cafe mailing list >>>> To (un)subscribe, modify options or view archives go to: >>>> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe >>>> Only members subscribed via the mailman list are allowed to post. >>>> >>>> >>>> _______________________________________________ >>>> Haskell-Cafe mailing list >>>> To (un)subscribe, modify options or view archives go to: >>>> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe >>>> Only members subscribed via the mailman list are allowed to post. >> >> >> _______________________________________________ >> Libraries mailing list >> Libraries(a)haskell.org >> http://mail.haskell.org/cgi-bin/mailman/listinfo/libraries >> >

1 0

Haskell IDE Engine logo poll
by Alan & Kim Zimmerman 11 Dec '17

11 Dec '17

Hi Thanks to Damien Flament we have some logo proposals for the haskell-ide-engine[1] logo. Please take a moment to vote for the options at [2]. If there are alternative designs, please feel free to put them forward too, the issue tracking this is at [3] We will keep the poll open until Friday noon UTC. Alan [1] https://github.com/haskell/haskell-ide-engine [2] http://www.anonvote.com/poll/dr587990y [3] https://github.com/haskell/haskell-ide-engine/issues/267

1 1

How to call constructor from Template Haskell
by Baa 11 Dec '17

11 Dec '17

Hello All! May be topic is not for Haskell beginners, so I'll re-send it to Cafe. I have function which constructs some data type. It has signature `Name -> Q [Dec]`. Somewhere in its body I'm extracting constructors of another type with pattern-matching: case tyCons of DataD ctx nm tyVars mbKind cs derivs -> ... Type of those constructors `cs` instantiates some class like this: class MyClass a where specialValue :: a So, I'm iterating over those `cs` but I want to skip one of them which is equal to `specialValue`. Something like this: [c | c <- cs, c /= specialValue] How to do this with Template Haskell's `Con` type (`c`::Con)? I can't simply call it to compare created value with a `specialValue`. === Best regards, Paul

1 0

ANN: New Haskell.org Committee Members
by Gershom B 11 Dec '17

11 Dec '17

Following the self-nomination period and discussion, the Haskell.org committee has selected the following members for a new three-year term, expiring 2020: * Tikhon Jelvis * Ryan Trinkle (reappointment) * George Wilson As per the rules of the committee, this discussion was held among the current members of the committee, and the outgoing members of the committee who were not seeking reappointment. Thank you to all the many candidates who submitted a self-nomination. We received a number of strong nominations. We would encourage all those who nominated themselves to consider self-nominating again in the future. The outgoing members are: John Wiegley and Alan Zimmerman. Thanks both for your service! Regards, Gershom

1 0

Re: [Haskell-cafe] Taking over mtl-tf
by M Farkas-Dyck 10 Dec '17

10 Dec '17

On 09/12/2017, Trevor Elliott <awesomelyawesome(a)gmail.com> wrote: > I'm happy to transfer the package to someone else. The old darcs repository > is long gone and I don't think that I ever migrated it over to github, so > the package source on hackage is probably all that remains. Thanks! My Hackage user name is "MatthewFarkasDyck"; would you please add me to maintainers?

1 0

Taking over mtl-tf
by M Farkas-Dyck 09 Dec '17

09 Dec '17

The maintainer e-mail <trevor(a)galois.com> seems defunct. Ergo, i mean to take over the package, unless a maintainer comes forth.

2 1

Serialising both data and functions
by Clinton Mead 07 Dec '17

07 Dec '17

The cereal <https://hackage.haskell.org/package/cereal> package contains a useful framework for serialising data. I've also noticed that the static pointers <https://ocharles.org.uk/blog/guest-posts/2014-12-23-static-pointers.html> extension could be useful for serialising functions, at least those which are statically applied (I understand the caveat that this breaks if the executable is recompiled). But it occurred to me that I might want to serialise a combination of these two things, for example, a static function call with a number of arguments, but the first of those arguments being non-static data. Is there a package to that combines these two use cases, namely static functions with non-static data? I'm happy to start writing one myself, but I don't want to reinvent the wheel. My ultimate aim is to combine this with acid-state <https://hackage.haskell.org/package/acid-state> so the current requirement to effectively pre-declare all possible operations on your data is relaxed.

2 1

ANN: stack-1.6.1
by Emanuel Borsboom 07 Dec '17

07 Dec '17

See https://haskellstack.org <https://haskellstack.org/> for installation and upgrade instructions. Note: we are releasing a bit earlier than planned due to #3624 <https://github.com/commercialhaskell/stack/issues/3624>. As such, not all the binaries have been built yet, but the commonly used 64-bit binaries of Linux static, macOS, and Windows are available. In addition, the Windows installer and binary has not been codesigned (we are awaiting validation of a new codesign certificate), and you may see a "Windows Defender SmartScreen prevented an unrecognized app from starting" warning when you try to run them. If so, click on More info, and then click on the Run anyway button that appears. Changes since v1.5.1 Major changes: Complete overhaul of how snapshots are defined, the packages and extra-deps fields, and a number of related items. For full details, please see the writeup on these changes <https://www.fpcomplete.com/blog/2017/07/stacks-new-extensible-snapshots>. PR #3249 <https://github.com/commercialhaskell/stack/pull/3249>, see the PR description for a number of related issues. Upgraded to version 2.0 of the Cabal library. Behavior changes: The --install-ghc flag is now on by default. For example, if you run stack build in a directory requiring a GHC that you do not currently have, Stack will automatically download and install that GHC. You can explicitly set install-ghc: false or pass the flag --no-install-ghc to regain the previous behavior. stack ghci no longer loads modules grouped by package. This is always an improvement for plain ghci - it makes loading faster and less noisy. For intero, this has the side-effect that it will no longer load multiple packages that depend on TH loading relative paths. TH relative paths will still work when loading a single package into intero. See #3309 <https://github.com/commercialhaskell/stack/issues/3309> Setting GHC options for a package via ghc-options: in your stack.yaml will promote it to a local package, providing for more consistency with flags and better reproducibility. See: #849 <https://github.com/commercialhaskell/stack/issues/849> The package-indices setting with Hackage no longer works with the 00-index.tar.gz tarball, but must use the 01-index.tar.gz file to allow revised packages to be found. Options passsed via --ghci-options are now passed to the end of the invocation of ghci, instead of the middle. This allows using +RTS without an accompanying -RTS. When auto-detecting --ghc-build, tinfo6 is now preferred over standard if both versions of libtinfo are installed Addition of stack build --copy-compiler-tool, to allow tools like intero to be installed globally for a particular compiler. #2643 <https://github.com/commercialhaskell/stack/issues/2643> Stack will ask before saving hackage credentials to file. This new prompt can be avoided by using the save-hackage-creds setting. Please see #2159 <https://github.com/commercialhaskell/stack/issues/2159>. The GHCRTS environment variable will no longer be passed through to every program stack runs. Instead, it will only be passed through commands like exec, runghc, script, ghci, etc. See #3444 <https://github.com/commercialhaskell/stack/issues/3444>. ghc-options: for specific packages will now come after the options specified for all packages / particular sets of packages. See #3573 <https://github.com/commercialhaskell/stack/issues/3573>. The pvp-bounds feature is no longer fully functional, due to some issues with the Cabal library's printer. See #3550 <https://github.com/commercialhaskell/stack/issues/3550>. Other enhancements: The with-hpack configuration option specifies an Hpack executable to use instead of the Hpack bundled with Stack. Please see #3179 <https://github.com/commercialhaskell/stack/issues/3179>. It's now possible to skip tests and benchmarks using --skip flag GitSHA1 is now StaticSHA256 and is implemented using the StaticSize 64 ByteString for improved performance. See #3006 <https://github.com/commercialhaskell/stack/issues/3006> Dependencies via HTTP(S) archives have been generalized to allow local file path archives, as well as to support setting a cryptographic hash (SHA256) of the contents for better reproducibility. Allow specifying --git-branch when upgrading When running stack upgrade from a file which is different from the default executable path (e.g., on POSIX systems, ~/.local/bin/stack), it will now additionally copy the new executable over the currently running stack executable. If permission is denied (such as in /usr/local/bin/stack), the user will be prompted to try again using sudo. This is intended to assist with the user experience when the PATH environment variable has not been properly configured, see #3232 <https://github.com/commercialhaskell/stack/issues/3232>. stack setup for ghcjs will now install alex and happy if they are not present. See #3109 <https://github.com/commercialhaskell/stack/issues/3232>. Added stack ghci --only-main flag, to skip loading / importing all but main modules. See the ghci documentation page for further info. Allow GHC's colored output to show through. GHC colors output starting with version 8.2.1, for older GHC this does nothing. Sometimes GHC's heuristics would work fine even before this change, for example in stack ghci, but this override's GHC's heuristics when they're broken by our collecting and processing GHC's output. Extended the ghc-options field to support $locals, $targets, and $everything. See: #3329 <https://github.com/commercialhaskell/stack/issues/3329> Better error message for case that stack ghci file targets are combined with invalid package targets. See: #3342 <https://github.com/commercialhaskell/stack/issues/3342> For profiling now uses -fprof-auto -fprof-cafs instead of the deprecated -auto-all -caf-all. See: #3360 <https://github.com/commercialhaskell/stack/issues/3360> Better descriptions are now available for stack upgrade --help. See: #3070 <https://github.com/commercialhaskell/stack/issues/3070> When using Nix, nix-shell now depends always on gcc to prevent build errors when using the FFI. As ghc depends on gcc anyway, this doesn't increase the dependency footprint. --cwd DIR can now be passed to stack exec in order to execute the program in a different directory. See: #3264 <https://github.com/commercialhaskell/stack/issues/3264> Plan construction will detect if you add an executable-only package as a library dependency, resulting in much clearer error messages. See: #2195 <https://github.com/commercialhaskell/stack/issues/2195>. Addition of --ghc-options to stack script to pass options directly to GHC. See: #3454 <https://github.com/commercialhaskell/stack/issues/3454> Add hpack package.yaml to build Stack itself Add ignore-revision-mismatch setting. See: #3520 <https://github.com/commercialhaskell/stack/issues/3520>. Log when each individual test suite finishes. See: #3552 <https://github.com/commercialhaskell/stack/issues/3552>. Avoid spurious rebuilds when using --file-watch by not watching files for executable, test and benchmark components that aren't a target. See: #3483 <https://github.com/commercialhaskell/stack/issues/3483>. Stack will now try to detect the width of the running terminal (only on POSIX for the moment) and use that to better display output messages. Work is ongoing, so some messages will not be optimal yet. The terminal width can be overriden with the new --terminal-width command-line option (this works even on non-POSIX). Passing non local packages as targets to stack ghci will now cause them to be used as -package args along with package hiding. Detect when user changed .cabal file instead of package.yaml. This was implemented upstream in hpack. See #3383 <https://github.com/commercialhaskell/stack/issues/3383>. Automatically run autoreconf -i as necessary when a configure script is missing. See #3534 <https://github.com/commercialhaskell/stack/issues/3534> GHC bindists can now be identified by their SHA256 checksum in addition to their SHA1 checksum, allowing for more security in download. For filesystem setup-info paths, it's no longer assumed that the directory is writable, instead a temp dir is used. See #3188 <https://github.com/commercialhaskell/stack/issues/3188>. Bug fixes: stack hoogle correctly generates Hoogle databases. See: #3362 <https://github.com/commercialhaskell/stack/issues/3362> stack --docker-help is now clearer about --docker implying system-ghc: true, rather than both --docker and --no-docker. stack haddock now includes package names for all modules in the Haddock index page. See: #2886 <https://github.com/commercialhaskell/stack/issues/2886> Fixed an issue where Stack wouldn't detect missing Docker images properly with newer Docker versions. #3171 <https://github.com/commercialhaskell/stack/pull/3171> Previously, cabal files with just test-suite could cause build to fail (#2862 <https://github.com/commercialhaskell/stack/issues/2862>) If an invalid snapshot file has been detected (usually due to mismatched hashes), Stack will delete the downloaded file and recommend either retrying or filing an issue upstream. See #3319 <https://github.com/commercialhaskell/stack/issues/3319>. Modified the flag parser within Stack to match the behavior of Cabal's flag parser, which allows multiple sequential dashes. See #3345 <https://github.com/commercialhaskell/stack/issues/3345> Now clears the hackage index cache if it is older than the downloaded index. Fixes potential issue if stack was interrupted when updating index. See #3033 <https://github.com/commercialhaskell/stack/issues/3033> The Stack install script now respects the -d option. See #3366 <https://github.com/commercialhaskell/stack/pull/3366>. stack script can now handle relative paths to source files. See #3372 <https://github.com/commercialhaskell/stack/issues/3372>. Fixes explanation of why a target is needed by the build plan, when the target is an extra dependency from the commandline. See #3378 <https://github.com/commercialhaskell/stack/issues/3378>. Previously, if you delete a yaml file from ~/.stack/build-plan, it would trust the etag and not re-download. Fixed in this version. Invoking stack --docker in parallel now correctly locks the sqlite database. See #3400 <https://github.com/commercialhaskell/stack/issues/3400>. docs.haskellstack.org RTD documentation search is replaced by the mkdocs search. Please see #3376 <https://github.com/commercialhaskell/stack/issues/3376>. stack clean now works with nix. See #3468 <https://github.com/commercialhaskell/stack/issues/3376>. stack build --only-dependencies no longer builds local project packages that are depended on. See #3476 <https://github.com/commercialhaskell/stack/issues/3476>. Properly handle relative paths stored in the precompiled cache files. See #3431 <https://github.com/commercialhaskell/stack/issues/3431>. In some cases, Cabal does not realize that it needs to reconfigure, and must be told to do so automatically. This would manifest as a "shadowed dependency" error message. We now force a reconfigure whenever a dependency is built, even if the package ID remained the same. See #2781 <https://github.com/commercialhaskell/stack/issues/2781>. When --pvp-bounds is enabled for sdist or upload, internal dependencies could cause errors when uploaded to hackage. This is fixed, see #3290 <https://github.com/commercialhaskell/stack/issues/3290> Fixes a bug where nonexistent hackage versions would cause stack to suggest the same package name, without giving version info. See #3562 <https://github.com/commercialhaskell/stack/issues/3562> Fixes a bug that has existed since 1.5.0, where stack setup --upgrade-cabal would say that Cabal is already the latest version, when it wasn't. Ensure that an extra-dep from a local directory is not treated as a $locals for GHC options purposes. See #3574 <https://github.com/commercialhaskell/stack/issues/3574>. Building all executables only happens once instead of every time. See #3229 <https://github.com/commercialhaskell/stack/issues/3229> for more info. Thanks to all our contributors for this release: Aaron McDaid Adam McCullough Alexey Zabelin Andy Ashley Towns Chris Done Chris Martin d-dorazio Deni Bertovic Dmitry Ivanov Echo Nolan Emanuel Borsboom Felix Yan Filippo Vitale Gábor Lipták Ivan Lazar Miljenovic Joshua Simmons Judah Jacobson Khan Thompson Lizao Li Luke Murphy Martin Kolinek Mathieu Boespflug Matt Audesse Matthias Heinzel Michael Sloan Michael Snoyman mrkkrp Neil Mitchell Oleg Grenrus OvermindDL1 Paolo G. Giarrusso Rafe Reuben D'Netto Roman Cheplyaka Samuli Thomasson Schlueter Scott Fleischman Shea Levy Simon Jakobi Tom Sydney Kerckhove tswelsh Walter Franzini

1 0

[Announce] ZuriHac 2018: Registration now open
by Jasper Van der Jeugt 06 Dec '17

06 Dec '17

We are happy to announce that registration for ZuriHac 2018 is now open. Participation is free but limited to 300 attendees. You can register at: http://zurihac.info/register This year, the Haskell Hackathon will take place Friday June 8th to Sunday the 10th. It will be hosted at the Hochschule Rapperswil right besides the beautiful lake Zurich, like last year. The Zurich Haskell Hackathon is a free (as in beer), international, grassroots collaborative coding festival whose goal is to expand the community and to build and improve Haskell libraries, tools, and infrastructure. This is already the 7th Haskell Hackathon in Zurich! This year, we will enjoy keynotes from: - Niki Vazou - Edward Kmett - Stephen Diehl More keynote speakers will be announced. This event is open to any experience level, from beginners to gurus. This year, Julie Moronuki, co-author of Haskell Programming from first principles [1], has kindly agreed to teach a beginners course in one of the classrooms we have available. Additionally, there will be mentors on site whom you can directly approach during the whole event with any Haskell-related question you have. This is a great opportunity to meet your fellow Haskellers in real life, find new contributors for your project, improve existing libraries and tools or even start new ones! More information about ZuriHac can be found on our website [2]. We would also like to thank our sponsors Adjoint [3], Digital Asset [4], HSR [5] for supporting this great event! Looking forward to see you there, the Zurich HaskellerZ meetup group [1]: https://www.goodreads.com/book/show/25587599-haskell-programming [2]: https://zurihac.info/ [3]: https://www.adjoint.io/ [4]: https://digitalasset.com/careers.html [5]: https://www.hsr.ch/

2 1

How to match on such type
by Baa 05 Dec '17

05 Dec '17

Hello, All! I have type: infixr 9 ||| data a ||| b = A a|B b deriving (Eq, Data, Show) and usually I wraps into it values which are instances of my class IsTag: class IsTag a where anyTag :: a So, I need to check if some value wrapping by `a|||b` is equal to `anyTag`, i.e.: A (B (A x)) == (anyTag::TypeOf_x) ==> True This function must be generic, ie, it can not know anything about concreate TypeOf_x, only: `a|||b` and `IsTag`. How to do it??? I added `Data` to `a|||b` and even to values which I "wrap" with `a|||b` (I assumed to use `gmap*` and Co), but this does not help me. Is it even possible?? == Best regadrs, Paul

2 3

Taking over a maintainership on hsyslog-udp
by Kostiantyn Rybnikov 04 Dec '17

04 Dec '17

I'd like to take over a maintainership of the hsyslog-udp package [0]. I wrote Jon few days ago and got no response, so I'm acting as per the "taking over" instructions [1] Thanks [0]: http://hackage.haskell.org/package/hsyslog-udp [1]: https://wiki.haskell.org/Taking_over_a_package

2 2

10 PhD studentships in Nottingham
by Graham Hutton 04 Dec '17

04 Dec '17

Dear all, The School of Computer Science in Nottingham is advertising 10 fully-funded PhD studentships. Applicants in the area of the Functional Programming Lab (https://tinyurl.com/fp-notts) are encouraged! If you are interested in applying, please contact a potential supervisor prior to submitting your application: Thorsten Altenkirch - constructive logic, proof assistants, homotopy type theory, category theory, lambda calculus. Venanzio Capretta - type theory, mathematical logic, corecursive structures, proof assistants, dependently-typed programming. Graham Hutton - program calculation and verification, category theory, recursion operators, coinductive types. Henrik Nilsson - functional reactive programming, modelling and simulation, domain-specific languages, probabilistic languages. Best wishes, Graham +---------------------------------------------------------------+ 10 Fully-Funded PhD Studentships School of Computer Science University of Nottingham, UK https://tinyurl.com/10-phds-2018 Applications are invited for up to ten fully-funded PhD studentships in the School of Computer Science at the University of Nottingham, starting on 1 October 2018. The topics for the studentships are open, but should relate to the interests of one of the School's research groups: Agents Lab; Automated Scheduling, Optimisation and Planning; Computer Vision Lab; Functional Programming Lab; Intelligent Modelling and Analysis; Mixed Reality Lab; Data Driven Algorithms, Systems and Design and Uncertainty in Data and Decision Making. The studentships are for three years and include a stipend of £14,553 per year and tuition fees, and are available to students of any nationality. Applicants are normally expected to have a first-class Masters or Bachelors degree in Computer Science or a related discipline, and must obtain the support of a potential supervisor in the School prior to submitting their application. Initial contact with supervisors should be made at least two weeks prior to the closing date for applications. Informal enquiries may be addressed to SS-PGR-JC(a)nottingham.ac.uk To apply, please submit the following items by email to: Christine.Fletcher(a)nottingham.ac.uk: (1) a brief covering letter that describes your reasons for wishing to pursue a PhD, your proposed research area and topic, and the name of a potential supervisor; (2) a copy of your CV, including your actual or expected degree class(es), and results of all University examinations; (3) an example of your technical writing, such as a project report or dissertation; (4) contact details for two academic referees. Closing date for applications: 19th January 2018 +---------------------------------------------------------------+ This message and any attachment are intended solely for the addressee and may contain confidential information. If you have received this message in error, please send it back to me, and immediately delete it. Please do not use, copy or disclose the information contained in this message or in any attachment. Any views or opinions expressed by the author of this email do not necessarily reflect the views of the University of Nottingham. This message has been checked for viruses but the contents of an attachment may still contain software viruses which could damage your computer system, you are advised to perform your own checks. Email communications with the University of Nottingham may be monitored as permitted by UK legislation.

1 0

Call for Participation: BOB 2018 (February 23, Berlin)
by Matthias Fischmann 04 Dec '17

04 Dec '17

BOB 2018 Conference “What happens if we simply use what’s best?” February 23, 2018, Berlin http://bobkonf.de/2018/ Program: http://bobkonf.de/2018/en/program.html Registration: http://bobkonf.de/2018/en/registration.html ================================================================ BOB is the conference for developers, architects and decision-makers to explore technologies beyond the mainstream in software development, and to find the best tools available to software developers today. Our goal is for all participants of BOB to return home with new insights that enable them to improve their own software development experiences. The program features 14 talks and 8 tutorials on current topics: http://bobkonf.de/2018/en/program.html The subject range of talks includes functional programming, verticalization, formal methods, and data analytics. The tutorials feature introductions to Haskell, Clojure, Livecoding, terminal programming, Liquid Haskell, functional reactive programming, and domain-driven design. Leif Andersen will give the keynote talk. Registration is open online: http://bobkonf.de/2018/en/registration.html NOTE: The early-bird rates expire on January 22, 2018! BOB cooperates with the :clojured conference on the following day. There is a registration discount available for participants of both events. http://www.clojured.de/

1 0

ghc-8.2.2 downloads: missing checksums
by Jeremy Henty 03 Dec '17

03 Dec '17

The SHA1SUMS and SHA256SUMS files in https://downloads.haskell.org/~ghc/8.2.2/ do not have checksums for ghc-8.2.2-x86_64-unknown-linux.tar.xz . Regards, Jeremy Henty

2 2

out-commented code vs. case with redundant pattern matches
by Henning Thielemann 30 Nov '17

30 Nov '17

Occasionally I have multiple implementations of the same task and want to choose one quickly but statically. I do not want to out-comment unused branches because they shall still be type checked. So far I used this scheme: case 0::Int of 0 -> putStrLn "A" 1 -> putStrLn "B" _ -> putStrLn "C" With ghc-8.0.2 and ghc-8.2.2 I get these warnings: RedundantCase.hs:4:7: warning: [-Woverlapping-patterns] Pattern match is redundant In a case alternative: 0 -> ... RedundantCase.hs:5:7: warning: [-Woverlapping-patterns] Pattern match is redundant In a case alternative: 1 -> ... I thought that "redundant" means that the first two cases overlap with '_'. But if I replace '_' by '2' I get not only the non-exhaustive patterns warning but an additional redundancy warning on pattern '2'. Is there a nice way to tell GHC that the unused branches are intended, without generally disabling overlapping patterns warning? I mean, this one does not provoke any warnings: if True then putStrLn "X" else putStrLn "Y" but is limited to two branches.

4 5

Re: [Haskell-cafe] out-commented code vs. case with redundant pattern matches
by Olaf Klinke 29 Nov '17

29 Nov '17

Henning, how about putting the branches into their own variables. Admittedly this pollutes the namespace but is much more readable IMHO. workflow = new_workflow where new_workflow = putStrLn "A" old_workflow = putStrLn "B" I suppose GHC complains neither about unused where clauses nor about unused top-level bindings. At least with GHCi 7.8.3 the above code produces no warnings. Olaf

2 1

Re: [Haskell-cafe] out-commented code vs. case with redundant pattern matches
by Doug McIlroy 29 Nov '17

29 Nov '17

Surely GHC is too clever by half in asserting that just 1 of two impossible branches is redundant in the code > case 0::Int of > 0 -> putStrLn "A" > 1 -> putStrLn "B" > _ -> putStrLn "C" The assertion suggests that GHC code optimization would leave some useless vestige of the third case, The long-range solution to Thielmann's quandry is a bug report. Doug

1 0

Looking for opportunity to present Clash (Haskell-to-Hardware compiler) in San Francisco area
by Christiaan Baaij 28 Nov '17

28 Nov '17

Hello Cafe!, I'm on a business trip in San Francisco from 2nd until 8th of December, but only have meetings on 4th and 6th. I was wondering if there are any people out in the SF area interested in a presentation about Clash, a Haskell-to-Hardware compiler ( http://clash-lang.org) and could host me in some way (i.e. provide a room to present); or just talk Haskell. It could be on the 3rd, 5th, or 7th. Please contact me if you're interested, or know of a place/meetup I could contact. Cheers! Christiaan

1 0

New Haskell Meetup in San Diego, California
by erik 27 Nov '17

27 Nov '17

Hello Haskell Cafe, We have decided to start a new Haskell meetup in San Diego, California: https://www.meetup.com/Haskell-Hangout/ Our initial goals are to cover both theoretical and practical aspects of the language. More broadly, we'd like to provide a space for people to discuss, learn, and further their Haskell understanding and to foster awareness of and interest in the language in the community of professional developers here in San Diego. For our first meeting on January 10th, we're going to discuss Philip Wadler's 1992 paper "Monads for Functional Programming". If you're interested and nearby, feel free to join us. All are welcome to attend, no Haskell experience required. Best, -- Erik Aker

1 0

emacs problem : haskell mode keeps hanging to report types, renders emacs useless
by Sean Matthews 27 Nov '17

27 Nov '17

I have just reinstalled everything. Newest release of emacs, Haskell-pakage and Haskell-mode and Haskell. I have tried to do this as cleanly as possible (via the customise and package install interfaces). Now when I try to edit haskell files, the system keeps freezing to report types. Nothing that I try (setting configuration variables, etc.) has any effect. I know that there is a problem with parsing the command line with the newest version of GHCi, but I think I can avoid that by using :load instead of C-c C-l. This freezing problem, however, is another level of problem. It renders my emacs basically useless for editing haskell. Anybody recognise the problem, and have a fix? Thanks, Sean Matthews -- Sean Matthews seanmatthews1(a)gmail.com / +49 1515 800 1901

5 8

Munich Haskell Meeting, 2017-11-29 @ 19:30
by Christian Neukirchen 26 Nov '17

26 Nov '17

Dear all, Next week, our monthly Munich Haskell Meeting will take place again on Wednesday, November 29 at Cafe Puck 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-nov-2017/ Everybody is welcome! cu, -- Christian Neukirchen <chneukirchen(a)gmail.com> http://chneukirchen.org

1 0

Running an action periodically
by Tristan Seligmann 25 Nov '17

25 Nov '17

I just wrote this helper: > import Control.Concurrent > import Control.Concurrent.STM > import Control.Exception.Safe > > pollT :: Int -> IO a -> IO (STM (Maybe a), Async b) > pollT delay act = do > tv <- atomically (newTVar Nothing) > as <- > async . forever $ do > r <- tryAny act > case r of > Left _ -> pure () > Right r' -> atomically (writeTVar tv (Just r')) > threadDelay delay > pure (readTVar tv, as) I was sort of surprised not to find something like this in an existing library. 1. Did I miss an existing implementation? 2. Any problems with this one? 3. Any suggestions for a better name? 4. Any thoughts on the general idea? That is, "run an action periodically, updating a TVar with the result". There's a couple of obvious variations that can be built on top of this, like retrying if the TVar is Nothing when reading from it, or writing Nothing to the TVar when the action fails rather than keeping the old value. Maybe passing in the old value to the action?

3 4

Can reallyUnsafePtrEquality give false positives?
by Michael Walker 25 Nov '17

25 Nov '17

Hello, Can reallyUnsafePtrEquality give false positives? I can see how it can give false negatives (eg, compiler optimisations increasing or decreasing sharing), but I'm not so sure if it can give false positives. I don't see how in a garbage collected language two live values could compare reference equal. Unless the implementation is something like: reallyUnsafePtrEquality a b = getptr a == getptr b ...as that then means that if the GC moves things after `getptr a` is evaluated but before `getptr b` is, then you could get a false positive. But that doesn't seem like a sensible implementation to me, because then reallyUnsafePtrEquality would surely be totally useless. -- Michael Walker (http://www.barrucadu.co.uk)

9 11

Re: [Haskell-cafe] Speculation, OT: Program a Spreadsheet
by Olaf Klinke 23 Nov '17

23 Nov '17

Yesterday I read in a slashdot thread [1] about Javelin [2], which was available shorty after I was born and before Excel existed. Telling from the wikipedia article, it did what I dreamed up in my previous post: instead of sheets, each logical piece of data occupied its own "variable". (Trent's virtual worksheet might be the equivalent here?) It also make the connections between data browsable. Is there anyone on this list who used Javelin back then? Care to share your experience? Olaf [1] https://news.slashdot.org/story/17/11/22/1525254/stop-using-excel-finance-c… [2] https://en.wikipedia.org/wiki/Javelin_Software

1 0

Re: [Haskell-cafe] Speculation, OT: Program a Spreadsheet
by Joachim Durchholz 22 Nov '17

22 Nov '17

Am 21.11.2017 um 08:13 schrieb trent shipley: > Which one it is that you are interested in? > "Three-dimensional" as in "we have row, column, and layer", or as in "we > have hierarchical workbooks"? > > They are not mutually exclusive. A workbook can contain sheets--just > like now. IN ADDITION, you can put workbooks in workbooks, until you > reach the root workbook, which is also a file. Not an answer that helps me understand your point. > > Also, if sheets can be marked as being functions, virtual > workbooks can > > support libraries of functions, or objects, if you want such things. > > Sometimes I think Excel etc. got it all wrong. > People routinely reserve areas inside the spreadsheet for different > tasks: input, intermediate results, output. Increasing the size of each > area becomes a pain. > > I'd want to have a spreadsheet where it's easy to define multiple sheets > on the same "table". Extending the input sheet with another row > automatically extends the output sheet by a row (and if you have rollup > then we get more than one row). Intermediate sheets could be replaced by > a function definition. > > It's a bit of an ergonomic challenge; functions are much more abstract, > and users will want to see how the results of applying a function to an > input area look like. So the mental model might be that we still have > intermediate sheets, but with just a single function, and the > intermediate sheets can be create, destroyed, shown and hidden easily. > > The other challenge would be dealing with headers. Headers are > important, but for the intermediate we have just the function so it > needs to provide the headers. I.e. the function result would have to be > a named tuple, and if you want multiline headers, we get a hierarchical > named tuple. > Manipulating the column order would also manipulate the tuple > definition, i.e. you'd have to think about how GUI manipulation affects > the function definition. > > > (No longer Haskell discussion, but anything civil goes in Cafe) > > Sounds both interesting and relevant, but I don't quite get it. Can you > provide a simple, concrete, narrative example--with pictures (ASCII > OK)--if possible. Nah, I'm only good at walls of text. And at answering directed questions - start asking about what exactly you didn't understand. Guessing what you might have not understood is going to be a waste of everybody's time. (Besides, if you need to tell where exactly you didn't understand may help your understanding. Well, the keyword being "may"; I know it worked for me on various occasions.) > There's pivot tables, so the difference between row and column isn't as > clear-cut as the above assumes. > > Don't worry about pivot tables. Simple cases first. You have to design for the maximum complication. Otherwise, stuff will not fit in well, and you'll be stuck with either a half-assed solution, nothing at all, or a full rewrite. Trust me. I've been coding and designing software for decades. > There are a few more things to consider. It's firmly in the GUI > ergonomics area. > For this kind of stuff, you don't care whether the programming language > evaluation semantics matches the problem domain (spreadsheet functional > semantics is easy to do in any language, it was done in Assembler with > Lotus 1-2-3), you care whether it is easy to prototype GUI approaches, > which means GUI libraries that make it easy to create new widgets. > > Any suggestions for a GUI library--that kind of implies C++ or Java. > Ideally your GUI would be cross platform. I know only the Java GUI landscape well enough to say anything. In that area, dialog boxes, menus and such will be easy enough with any lib, but you'll be mostly on your own for the grid. Also if you aim for unlimited size you'll get into a lot of hairy memory management issues - a 64kx64k grid has 1 million cells, multiply that with 1KB per cell and you end with a memory footprint of a gigabyte. Evaluating a formula for each cell is going to get you a slideshow-like performance. So... managing which cells are actually needed and which aren't is going to be a major point of the software. Did I mention that coding a spreadsheet is a huge project? ;-) > > Programmers have to learn multiple languages, and most wind up liking > > it. They also have favorite languages. LibreOffice Calc has about > four > > bolt-on languages. As I recall, none of them are a functional > > programming language. Maybe a few programmers should get together and > > add one as a sub-project. > > The problem is that any additional language needs to be installed. So > either the new language needs to be integrated in the LO project, or it > is not and anybody who passes on a spreadsheet in the new language needs > to tell the recipients how to install the plugin for the language. > > Maybe that's the reason why only the four languages exist. > > Doubt it. > > A given plugin's installation could be automated and check for dependencies. Heh. Famous last words. The Java folks got a 90% solution working - just for managing dependencies, mind you; for some people it doesn't work at all because they don't know how to get past the corporate firewall. Besides, most corporate firewalls do a man-in-the-middle certificate nowadays and will inspect and reject some packets and not others, so any update mechanism must be able to deal with wilfully unreliable internet connections. So that's another area that's going to bind a lot of developer resources.

2 2

Arrows and streaming/piping
by PY 22 Nov '17

22 Nov '17

Hello, Cafe! There is a statement that Arrows can be used as streaming approach. Arrows are very new for me, so my question may looks stupid, but would somebody show me clean and simple example how it will look? Lets suppose we have function `getLines` which returns `IO [String]`, a lot of lines :) And I want to process them as I do it with streaming library (or pipes) - with constant space. If it's true, then I can use Arrows instead of pipes, right? === Best regards, Paul

2 1

Speculation, OT: Program a Spreadsheet
by trent shipley 22 Nov '17

22 Nov '17

I have a vision for a spreadsheet that is programmable as a spreadsheet itself. (Excel, for example, is programmable in VBA, but VBA requires switching modes to the VBA environment and using a non-spreadsheet idiom. Excel is not self-programmable as a spreadsheet.) First there one function in a cell or array can reference other cells and arrays, including those that contain functions themselves. Second, IF(boolean,then,else) functions provide for selection. Third, the Function local scope property for a sheet in a workbook, the PARAMETER() function, and the RETURN() function allow the spreadsheet programmer to write new functions, including recursive functions. * Is a spreadsheet you can program from the spreadsheet a reasonable goal? * Has it been done? (I don't have the academic CS chops to know what keywords to use, and how search CS publications in English.) I have written a 30 page essay on Scriptsheets, but the essence boils down to the above. (If you, for some inexplicable reason, actually want the draft of the essay I'd be more than happy to share it with the understanding that you would provide feedback). I call the proposal Scriptsheets. So the plan is to take something like GNUmeric or LibreOffice Calc and graft on a primitive function sheet interpreter. It would be natural to use C++, but the astute will note that a spreadsheet basically does not rewrite cells (unless you use a circular reference), so I'd also like to use a functional language, maybe Haskel. * Would using a functional language as a basic language of the project save effort and intellectual load? In the longer term I'd like as much of the spreadsheet programmable as a spreadsheet to be written to run on the JVM. As near as I can tell near future Java and typed functional languages, include the following options: Eta, Frege, Kotlin and, Scala. Note that a spreadsheet needs to give the satisfaction of immediate results, or failing immediate results, the sensation of actively working, so if the language could be interpreted that would be a huge help. * Which combination of typed, compiled, interpreted, FOSS functional language that runs on the JVM, JAVA, Haskell, C++, C, used in that order of preference, makes the most sense for the Java compatible functional language at the top of the preference hierarchy? Note also, that I have only the equivalent of an AA degree from a CIS, not a CS, perspective, so the odds are the whole idea is vaporware, unless I can determine feasibility and desirability, then sweet talk real developers to help out. trent1967.48(a)outlook.com (junk email address) See also the spreadsheet at http://orgmode.org/ it's cool.

5 13

[ANNOUNCE] GHC 8.2.2 released
by Ben Gamari 21 Nov '17

21 Nov '17

=============================================== The Glasgow Haskell Compiler -- version 8.2.2 =============================================== The GHC Team is pleased to announce a new minor release of GHC. This release builds on the performance and stability improvements of 8.2.1, fixing a variety of correctness bugs, improving error messages, and making the compiler more portable. Notable bug-fixes include * A correctness issue resulting in segmentation faults in some FFI-users (#13707, #14346) * A correctness issue resulting in undefined behavior in some programs using STM (#14171) * A bug which may have manifested in segmentation faults in out-of-memory condition (#14329) * clearBit of Natural no longer bottoms (#13203) * A specialisation bug resulting in exponential blowup of compilation time in some specialisation-intensive programs (#14379) * ghc-pkg now works even in environments with misconfigured NFS mounts (#13945) * GHC again supports production of position-independent executables (#13702) * Better error messages around kind mismatches (#11198, #12373, #13530, #13610) A thorough list of the changes in the release can be found in the release notes, https://haskell.org/ghc/docs/8.2.2/html/users_guide/release-8-2-2.html How to get it ~~~~~~~~~~~~~ This release can be downloaded from https://www.haskell.org/ghc/download_ghc_8_2_2.html For older versions see https://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. 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 on the World-Wide Web: 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/Contributors 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

1 1

Re: [Haskell-cafe] Speculation, OT: Program a Spreadsheet
by Olaf Klinke 21 Nov '17

21 Nov '17

> Olaf, have you looked at Jupyter <http://jupyter.org/> at all? This now > has a backend for Haskell and supports many of the things you mention. Neil, I must have forgotten about Jupyter. That is exactly what I was takling about! I have become quite a fan of literate programming. Now I admit that Jupyter looks quite different from spreadsheets, so wont' fit the bill of what Trent was originally asking for. As I tried to express earlier, the strength of spreadseets in my eyes is the somewhat explicit data flow. (You need to highlight a cell to see its formula.) Hence I envision a Jupyter with data flow made explicit. You start by defining your input data. Single values, lists, matrices, whatever. You can define some functions, which will act as edges of your data flow graph. Then you combine these functions and apply to the data. For each (f.g)(x), all of x, g(x) and (f.g)(x) become nodes of a graph with (f.g)(x) hyperlinked to g(x) which in turn gets hyperlinked to x. Thus you can explore backwards from the result and see how the answer was derived. Of course a nicely written Jupyter notebook needs no hyperlinks. One can leave enough explanation in the markup cells. But not everyone is trained to read and understand such mixture of text and code. There might be an applicative functor (a variant of 'State SomeGraph') for what I'm after. Once I've defined it, I'll post it here. Olaf

1 0

Re: [Haskell-cafe] [ANN]: fin & vec
by Oleg Grenrus 21 Nov '17

21 Nov '17

Thanks for more references! I was quite sure I didn't found all packages around fin/nat/vec (and I feel a little bad for making "standards" problem worse :) - https://hackage.haskell.org/package/finite-typelits uses GHC.TypeLits.Nat (fair thing to do). - https://hackage.haskell.org/package/vector-sized builds on top of that and looks like a nice package too! I dislike GHC.TypeLits.Nat for doing induction over, yet for many things they (+ [1,2] or [3]) are great. I have to write that down in the description of the package(s). Hopefully the approaches: compiler built-in magic and DataKinds definition would be unified in the future. Cheers, Oleg. - [1] https://hackage.haskell.org/package/ghc-typelits-natnormalise - [2] https://hackage.haskell.org/package/ghc-typelits-extra - [3] http://hackage.haskell.org/package/constraints-0.9.1/docs/Data-Constraint-N… On 21.11.2017 15:20, Alexey Vagarenko wrote: > I wrote a package not long ago which also uses static inlining for > similar things: https://hackage.haskell.org/package/static-tensor > > There is also https://hackage.haskell.org/package/vector-sized which > is a wrapper around 'vector' library. > > <http://www.avg.com/email-signature?utm_medium=email&utm_source=link&utm_cam…> > Virus-free. www.avg.com > <http://www.avg.com/email-signature?utm_medium=email&utm_source=link&utm_cam…> > > > > 2017-11-21 17:27 GMT+05:00 Oleg Grenrus <oleg.grenrus(a)iki.fi > <mailto:oleg.grenrus@iki.fi>>: > > I'm happy to announce two packages: > > - http://hackage.haskell.org/package/fin > <http://hackage.haskell.org/package/fin> > - http://hackage.haskell.org/package/vec > <http://hackage.haskell.org/package/vec> > > In short they provide following types: > > data Nat where Z | S Nat > > data Fin (n :: Nat) where > Z :: Fin ('S n) > S :: Fin n -> Fin ('S n) > > data Vec (n :: Nat) a where > VNil :: Vec 'Z a > (:::) :: a -> Vec n a -> Vec ('S n) a > > Main motivation for creating these packages is that I didn't found > anything > similar on Hackage. Before comparison with the alternatives, let me > mention few > highlights: > > - `fin` and `vec` support GHC-7.8.4 .. GHC-8.2.1; and I plan to > keep support > window as wide as possible. > > - `fin` package provides `Data.Fin.Enum` module to work > generically with > enumerations. It's (subjectively) more ergonomic than working with > `All ((:~:) a) xs => NS I xs` from `generics-sop` [1] > > - `fin` package defines `InlineInduction` class, > letting us trick GHC to unfold recursion. One general example is > > unfoldedFix :: forall n a proxy. InlineInduction n > => proxy n -> (a -> a) -> a > unfoldedFix _ = getFix (inlineInduction1 start step :: Fix > n a) > where > start :: Fix 'Z a > start = Fix fix > > step :: Fix m a -> Fix ('S m) a > step (Fix go) = Fix $ \f -> f (go f) > > newtype Fix (n :: Nat) a = Fix { getFix :: (a -> a) -> a } > > So, for statically known @n@, GHC's inliner will "simplify": > > unfoldedFix (Proxy :: Proxy Nat3) f = f (f (f (fix f))) > > - `fin` has very light dependency footprint: > `base`, `deepseq`, `hashable` (and transitively `text`) on GHC>=8.0 > > - `vec` has a little more dependencies, essentially `lens`. See > dependency > diagram in the readme. [2] > > - `vec` comes in three flavours: > > * __naive__: with explicit recursion. It's simple, > constraint-less, > yet slow. > > * __pull__: using `Fin n -> a` representation, which fuses well, > but makes some programs hard to write. And > > * __inline__: which uses `InlineInduction`, unrolling > recursion if the size of 'Vec' is known statically. > > Differences with other packages > ------------------------------- > > ### fin > > - [type-natural](http://hackage.haskell.org/package/type-natural > <http://hackage.haskell.org/package/type-natural>) depends > on @singletons@ package. `fin` will try to stay light on the > dependencies, > and support as many GHC versions as practical. > > - [peano](http://hackage.haskell.org/package/peano > <http://hackage.haskell.org/package/peano>) is very incomplete > > - [nat](http://hackage.haskell.org/package/nat > <http://hackage.haskell.org/package/nat>) as well. > > - > [PeanoWitnesses](https://hackage.haskell.org/package/PeanoWitnesses > <https://hackage.haskell.org/package/PeanoWitnesses>) > doesn't use @DataKinds@. > > - > [type-combinators](http://hackage.haskell.org/package/type-combinators > <http://hackage.haskell.org/package/type-combinators>) > is a big package. > > ### vec > > - [linear](http://hackage.haskell.org/package/linear > <http://hackage.haskell.org/package/linear>) has 'V' type, > which uses 'Vector' from @vector@ package as backing store. > `Vec` is a real GADT, but tries to provide as many useful > instances (upto > @lens@). > > - [sized-vector](http://hackage.haskell.org/package/sized-vector > <http://hackage.haskell.org/package/sized-vector>) depends > on 'singletons' package. `vec` isn't light on dependencies either, > but try to provide wide GHC support. > > - [sized](https://hackage.haskell.org/package/sized > <https://hackage.haskell.org/package/sized>) also depends > on a 'singletons' package. The 'Sized f n a' type is > generalisation of > linears 'V' for any 'ListLike'. > > - > [clash-prelude](https://hackage.haskell.org/package/clash-prelude > <https://hackage.haskell.org/package/clash-prelude>) > is a kitchen sink package, which has 'CLaSH.Sized.Vector' module. > Also depends on 'singletons'. > > Disclaimer > ---------- > > These are the "first released versions", i.e. `fin-0` and `vec-0`. > Don't be fooled by 0, we use them in production. > > We don't have (yet?) a use-case where proper full inlining would > matter, it > seems to work with simple examples. The `vec` package includes > simple dot > product benchmark, it gives sensible results: > > - *list* version sets the baseline, built-in fusion seems to kick in. > - using `vector` is 3x slower (?) > - naive `Vec` is even slower, not surprisingly > - `Data.Vec.Pull` approach is slower, *except* > - that without conversions it's up to speed with `vector` > - `InlineInduction` is *fastest*. > > Acknowledgements > ---------------- > > - *APLicative Programming with Naperian Functors* [3] has the very > similar > `Nat`, `Fin` and `Vec` (sections 2--4). I spotted few missing > functions in > `vec` by re-reading the paper (`vgroup` is `chunks` and `viota` is > `universe`). > I don't claim that my library is novel in any kind :) > - I learned *Pull array* idea from Josef Svenningsson talk at SmallFP > 2017 [4]. > See the video [5] if interested. > - Herbert Valerio Riedel for the idea to split `fin` out of `vec`. > It turned > out to be very light package. > - Andres Löh for discussions about `generics-sop` [1], and about > the static > inlining idea. > - Joachim Breitner for creating `inspection-testing` [6], which > really helps > validating optimisations working. > > Cheers, > Oleg > > > - [1] http://hackage.haskell.org/package/generics-sop > <http://hackage.haskell.org/package/generics-sop> > - [2] https://github.com/phadej/vec#dependencies > <https://github.com/phadej/vec#dependencies> > - [3] > https://www.cs.ox.ac.uk/people/jeremy.gibbons/publications/aplicative.pdf > <https://www.cs.ox.ac.uk/people/jeremy.gibbons/publications/aplicative.pdf> > - [4] http://clojutre.org/2017/ > - [5] > https://www.youtube.com/watch?v=5PZh0BcjIbY&list=PLetHPRQvX4a9uUK2JUZrgjtC_… > <https://www.youtube.com/watch?v=5PZh0BcjIbY&list=PLetHPRQvX4a9uUK2JUZrgjtC_…> > - [6] http://hackage.haskell.org/package/inspection-testing > <http://hackage.haskell.org/package/inspection-testing> > > > > _______________________________________________ > Haskell-Cafe mailing list > To (un)subscribe, modify options or view archives go to: > http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe > <http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe> > Only members subscribed via the mailman list are allowed to post. > >

2 1

[ANN]: fin & vec
by Oleg Grenrus 21 Nov '17

21 Nov '17

I'm happy to announce two packages: - http://hackage.haskell.org/package/fin - http://hackage.haskell.org/package/vec In short they provide following types: data Nat where Z | S Nat data Fin (n :: Nat) where Z :: Fin ('S n) S :: Fin n -> Fin ('S n) data Vec (n :: Nat) a where VNil :: Vec 'Z a (:::) :: a -> Vec n a -> Vec ('S n) a Main motivation for creating these packages is that I didn't found anything similar on Hackage. Before comparison with the alternatives, let me mention few highlights: - `fin` and `vec` support GHC-7.8.4 .. GHC-8.2.1; and I plan to keep support window as wide as possible. - `fin` package provides `Data.Fin.Enum` module to work generically with enumerations. It's (subjectively) more ergonomic than working with `All ((:~:) a) xs => NS I xs` from `generics-sop` [1] - `fin` package defines `InlineInduction` class, letting us trick GHC to unfold recursion. One general example is unfoldedFix :: forall n a proxy. InlineInduction n => proxy n -> (a -> a) -> a unfoldedFix _ = getFix (inlineInduction1 start step :: Fix n a) where start :: Fix 'Z a start = Fix fix step :: Fix m a -> Fix ('S m) a step (Fix go) = Fix $ \f -> f (go f) newtype Fix (n :: Nat) a = Fix { getFix :: (a -> a) -> a } So, for statically known @n@, GHC's inliner will "simplify": unfoldedFix (Proxy :: Proxy Nat3) f = f (f (f (fix f))) - `fin` has very light dependency footprint: `base`, `deepseq`, `hashable` (and transitively `text`) on GHC>=8.0 - `vec` has a little more dependencies, essentially `lens`. See dependency diagram in the readme. [2] - `vec` comes in three flavours: * __naive__: with explicit recursion. It's simple, constraint-less, yet slow. * __pull__: using `Fin n -> a` representation, which fuses well, but makes some programs hard to write. And * __inline__: which uses `InlineInduction`, unrolling recursion if the size of 'Vec' is known statically. Differences with other packages ------------------------------- ### fin - [type-natural](http://hackage.haskell.org/package/type-natural) depends on @singletons@ package. `fin` will try to stay light on the dependencies, and support as many GHC versions as practical. - [peano](http://hackage.haskell.org/package/peano) is very incomplete - [nat](http://hackage.haskell.org/package/nat) as well. - [PeanoWitnesses](https://hackage.haskell.org/package/PeanoWitnesses) doesn't use @DataKinds@. - [type-combinators](http://hackage.haskell.org/package/type-combinators) is a big package. ### vec - [linear](http://hackage.haskell.org/package/linear) has 'V' type, which uses 'Vector' from @vector@ package as backing store. `Vec` is a real GADT, but tries to provide as many useful instances (upto @lens@). - [sized-vector](http://hackage.haskell.org/package/sized-vector) depends on 'singletons' package. `vec` isn't light on dependencies either, but try to provide wide GHC support. - [sized](https://hackage.haskell.org/package/sized) also depends on a 'singletons' package. The 'Sized f n a' type is generalisation of linears 'V' for any 'ListLike'. - [clash-prelude](https://hackage.haskell.org/package/clash-prelude) is a kitchen sink package, which has 'CLaSH.Sized.Vector' module. Also depends on 'singletons'. Disclaimer ---------- These are the "first released versions", i.e. `fin-0` and `vec-0`. Don't be fooled by 0, we use them in production. We don't have (yet?) a use-case where proper full inlining would matter, it seems to work with simple examples. The `vec` package includes simple dot product benchmark, it gives sensible results: - *list* version sets the baseline, built-in fusion seems to kick in. - using `vector` is 3x slower (?) - naive `Vec` is even slower, not surprisingly - `Data.Vec.Pull` approach is slower, *except* - that without conversions it's up to speed with `vector` - `InlineInduction` is *fastest*. Acknowledgements ---------------- - *APLicative Programming with Naperian Functors* [3] has the very similar `Nat`, `Fin` and `Vec` (sections 2--4). I spotted few missing functions in `vec` by re-reading the paper (`vgroup` is `chunks` and `viota` is `universe`). I don't claim that my library is novel in any kind :) - I learned *Pull array* idea from Josef Svenningsson talk at SmallFP 2017 [4]. See the video [5] if interested. - Herbert Valerio Riedel for the idea to split `fin` out of `vec`. It turned out to be very light package. - Andres Löh for discussions about `generics-sop` [1], and about the static inlining idea. - Joachim Breitner for creating `inspection-testing` [6], which really helps validating optimisations working. Cheers, Oleg - [1] http://hackage.haskell.org/package/generics-sop - [2] https://github.com/phadej/vec#dependencies - [3] https://www.cs.ox.ac.uk/people/jeremy.gibbons/publications/aplicative.pdf - [4] http://clojutre.org/2017/ - [5] https://www.youtube.com/watch?v=5PZh0BcjIbY&list=PLetHPRQvX4a9uUK2JUZrgjtC_… - [6] http://hackage.haskell.org/package/inspection-testing

2 1

problem with compiler error message
by Dmitry Olshansky 21 Nov '17

21 Nov '17

Hello cafe! It seems that this behavior is wrong: > class Foo a where { type Bar a; baz :: a -> Bar a } > baz zzz -- zzz is not in scope <interactive>:17:1: error: • Couldn't match expected type ‘Bar a’ with actual type ‘Bar a0’ NB: ‘Bar’ is a type function, and may not be injective The type variable ‘a0’ is ambiguous • In the ambiguity check for the inferred type for ‘it’ To defer the ambiguity check to use sites, enable AllowAmbiguousTypes When checking the inferred type it :: forall a. Bar a As opposite - correct behavior: > :t negate negate :: Num a => a -> a > negate zzz <interactive>:19:8: error: Variable not in scope: zzz Best regards, Dmitry

2 2

Questions about Numeric.AD / Automatic differentiation
by Sean Matthews 21 Nov '17

21 Nov '17

I'm having some problems with Numeric.AD (translation, things are not working for reason that I don't understand). Note I don't have much experience with this package, so these are newbie questions, thus appropriate answers may involve pointing me to a document somewhere out there on the net. Anyway, here is my problem: I have a function (call it f x theta) which I have defined purely in terms of basic arithmetic functions (+/-/(/)/*/**) glued together using standard applicative functor operations has type f :: m1 (m2 Double) -> m3 Double -> Double f x theta = ... m1 m2 and m3 are all Traversable. f is defined purely in terms of basic arithmetic operations, (+/-/(/)/*/**) glued together using standard applicative functor operations, and m1 m2 and m3 are all pretty trivial record types (no recursion, even). I would like to write df x theta = grad (f x) theta But it refuses to type, even though (admittedly quite a lot) simpler versions do. So what am I missing? Does AD not go through Applicative? That seems unlikely to me. Any advice / suggestions, etc. gratefully received. Sean Matthews -- Sean Matthews seanmatthews1(a)gmail.com / +49 1515 800 1901

2 2

argument counts...
by Gregory Guthrie 20 Nov '17

20 Nov '17

I have a simple function: revFn (x:xs) = (revFn xs) . (x:) Of course GHCi correctly infers the type as: revFn :: [a] -> [a] -> c Adding the base case: revFn [] xs = xs Now gives an error; "Equations for 'revF' have different numbers of arguments" Of course this can be "fixed" by either adding the cancelled argument to the first clause, or converting the base case to only have one explicit argument, and a RHS of a lambda or identity function. But since the interpreter already correctly inferred that the first clause has two arguments (with only one explicit), why does it then ignore this and give an error when the second clause shows two explicit arguments? The types are all correct in either case - why require explicit arguments? Or, perhaps I am missing something simple?

5 4

Re: [Haskell-cafe] Speculation, OT: Program a Spreadsheet
by Olaf Klinke 20 Nov '17

20 Nov '17

Hello Trent, let me suggest to step back and think about why people use spreadsheets. They provide access to data analysis functions, statistics and graphing that is otherwise missing (at least on) Windows systems. Serious number crunching is not done in spreadsheets, though. There is R, Matlab and the like. You should not try to comptete with that. The big selling point (in my eyes) of spreadsheets over scripting languages like R is that the data as well as the formulae and intermediate results are, well, spread out in front of your eyes. That is e.g. desirable when you need someone else to understand what you did and how you arrived at the answer given. But is it important that the intermediate result resides in cells C2 to C13? Certainly not. I wrote a small financial application in Haskell that would otherwise be done in spreadsheets. Haskell provided, via its type system, extra sanity checks and much more that spreadsheets don't provide. However, I often wished that there was a way to disassemble the computation into logical bits that can be formatted neatly and be presented to a human inspector. Haskell provides ways to do this, e.g. by mixing Haskell and LaTeX, or writing a small DSL with two interpreters, one for calculations, one for layout. So instead of enhancing a spreadsheet format I'd rather have a scripting language with a workbook file format à la Mathematica, where comments, code and results of computations are displayed together. Changing a formula triggers change in the results. (The workbooks I've seen don't do that.) Input data and intermediate results can be hidden or expanded via mouse click. Results can be traced back through the workbook's formulae up to the input data. (The latter is not always easy in spreadsheets.) One would need to research whether such a language exists. If not, I'd be happy to help develop it. Olaf

5 5

Re: [Haskell-cafe] Speculation, OT: Program a Spreadsheet
by dominic＠steinitz.org 20 Nov '17

20 Nov '17

Here’s a presentation about a functional language embedded in Excel which I used when I worked at an investment bank https://www.youtube.com/watch?v=uICBMTeIl2U http://cufp.org/2009/fmd-functional-development-excel.html As far as I know the code is still in use (I recall there was something like 400 users in the bank) and was never open-sourced but it may provide some ideas given it was pretty successful internally. Dominic Steinitz dominic(a)steinitz.org http://idontgetoutmuch.wordpress.com

1 0

implement a simple DSL meet problem with env data can't be changed
by mo jia 19 Nov '17

19 Nov '17

Base on the correct compiler desc on https://github.com/pa-ba/calc-comp Here is the source code module Lambda_define ( Name, Expr, eval )where import Prelude hiding (null, lookup, map, filter) import Data.HashMap.Lazy type Name = [Char] data Expr = Val Int | Add [Expr] | Var Name | Abs Name Expr | App Expr Expr | Define Name Expr | Begin [Expr] | Let (Name, Expr) Expr data Env = Root | Env { current :: HashMap Name Value, parent :: Env } data Value = Num Int | Clo Name Expr Env envLookup :: Name -> Env -> Value envLookup n Root = Num 10000 --- fix it envLookup n env = case lookup n (current env) of Just v -> v otherwise -> envLookup n (parent env) --------------- setvar :: Name -> Value -> Env -> Env setvar n v Root = Env{current=fromList [(n, v)] , parent=Root } setvar n v Env{current=c, parent=p} = Env{current=(insert n v c), parent=p } eval :: Expr -> Env -> (Value, Env) eval (Val n) e = (Num n , e) eval (Add [x , y]) e = case eval x e of (Num n, e') -> case eval y e of (Num m, e1') -> (Num (n+m), e) eval (Add [x]) e = case eval x e of (Num n, e') -> (Clo "y" (Add [(Val n), (Var "y")]) e' , e) eval (Var n) e = (envLookup n e, e) eval (Abs n x) e = (Clo n x e, e) eval (App x y) e = case eval x e of (Clo n' x' e', env') -> case eval y e of (vy, e'') -> (fst (eval x' (Env (fromList [(n', vy)]) e')), e ) --- the saved clojure env can't be changed eval (Define n e) env = case eval e env of (v, e') -> (Num 0, setvar n v env) --- fix me why 0 eval (Let (n, e1) e2) env = ------ Let should don't chanve the env (fst (eval e2 (Env (fromList [(n, (fst (eval e1 env)))]) env)), env) eval (Begin xs) e = case length xs of 0 -> (Num 0, Root) -- never come here 1 -> case eval (xs !! 0) e of (v, e') -> (v, e') n -> case eval (Begin (take (n - 1) xs)) e of (v, e') -> eval (last xs) e' test1 = eval (Begin [(Define "z" (Val 1)), (Define "y" (Abs "x" (Add [(Var "z"), (Var "x")]))), (Define "x" (Val 7)), (Define "z" (Val 90)), (Add [(Val 5), (App (Var "y") (Val 8))])]) Root test2 = eval (Begin [(Define "z" (Val 1)), (Define "y" (Abs "x" (Add [(Var "z"), (Var "x")]))), (Define "x" (Val 7)), (Let ("z", (Val 90)) (Add [(Val 5), (App (Var "y") (Val 8))])) ]) Root In case you want to see the total program. I put it into https://github.com/jiamo/correct_compiler/blob/master/src/Lambda_define.hs Here is my problem: I want test1 return (Num 103) I want test2 return (Num 14) But now it both return (Num 14) One problem I can figure out that "the eval of Define return a new env can't change the old env" Any one have suggests?

1 0

latin file encoding
by Henning Thielemann 17 Nov '17

17 Nov '17

I have a LATIN-1 encoded file on a UTF-8 configured system: $ iconv -f latin1 Text Häßkell $ echo $LANG de_DE.UTF-8 Thus, a Haskell program cannot process it as it is: $ cat Text | ghc-8.2.2 -e 'interact id' | iconv -f latin1 <interactive>: <stdin>: hGetContents: invalid argument (invalid byte sequence) So far, so expected. Now I want to run it with latin encoding: $ cat Text | (LANG=de_DE ghc-8.2.2 -e 'interact id') | iconv -f latin1 <interactive>: <stdin>: hGetContents: invalid argument (invalid byte sequence) That's unexpected. Is this the reason: $ LANG=de_DE ghc-8.2.2 -e 'print System.IO.localeEncoding' ASCII ? Btw. what would be the Locale name for Latin-1 encoding?

1 1

2017 state of Haskell survey results
by Taylor Fausak 16 Nov '17

16 Nov '17

I am excited to announce that the results of the 2017 state of Haskell survey are now available: http://taylor.fausak.me/2017/11/15/2017-state-of-haskell-survey-results/ <http://taylor.fausak.me/2017/11/15/2017-state-of-haskell-survey-results/> Thanks to everyone who responded!

1 0

Dutch FP-day 2018 (early registration required)
by Arjen 16 Nov '17

16 Nov '17

I would like to invite you to the next Dutch Functional Programming Day. It will take place on Friday 5th of January 2018, at the Walter Bos Complex of the Dutch Tax and Customs Administration at John F. Kennedylaan 8, Apeldoorn. The Dutch Functional Programming Day is an annual gathering of researchers, students, and practitioners sharing a common interest in functional programming. Experts and newcomers to the field are equally welcome. For more information see http://wiki.clean.cs.ru.nl/NL-FP_dag_2018 Please note that to the nature of the location, registration before December 15 is required. We need a list of participants for the security staff. We also need this to order the right number of badges, drinks and pizza's. You can register by sending a mail to a.van.weelden(a)belastingdienst.nl (or reply to this e-mail) including: 1. your name (used for identification) 2. your affiliation, if any 3. whether you want (vegetarian) pizza 4. whether you want to give a talk There are no costs for anything this year, as it is fully sponsored by the Dutch Tax and Customs Administration. kind regards, Betsy Pepels and Arjen van Weelden

1 0

Project idea, seeking feedback
by Alex 15 Nov '17

15 Nov '17

Hi all, I'm seeking feedback for a project I'd like to start. I have a bit of experience developing large scale systems containing many microservices, databases, message queues, and caches over many VMs. Time and time again I find myself confronted with the same problems: 1. It is difficult to trace events through the system: Consider an HTTP request made by a customer to a public API. Which microservices were impacted by that request? What SQL queries were run as a result of that request? What 3rd party APIs were consulted during the request's fulfillment? Answers to these questions are essential to fixing bugs quickly, and yet they are so difficult to answer (at least in my experience). 2. Problems are difficult to reproduce: When Customer Success walks in and says, "I have an angry customer on the phone. They want to know why [FOO] wasn't properly [BAR]" it is often impossible to give an answer without interactive troubleshooting and hours of grepping through unstructured log files. Troubleshooting may incur additional expenses too, since (for instance) you may hit your API request limit for a 3rd party service. 3. Business and non-business logic are not well encapsulated: Often I see code related to (for example) RabbitMQ interwoven with core business logic when calls need to be made to other microservices. The fact that RabbitMQ facilitates communication between microservices is an implementation detail that I shouldn't have to think about. 4. Resource consumption is non-uniform: Some microservices are more demanding than others in terms of CPU, memory, and disk usage. Achieving optimal "packing" is difficult. In other words, some VMs will have a high load and others will remain idle. Auto scaling groups can help with this in theory, but I don't think they can achieve the kind of density I would like to see. Moreover, what constitutes a "resource"? If a 3rd party service rate limits requests by IP address, couldn't each request be considered a resource unit which needs to be properly load balanced, just as you would with CPU? Given these motivations, I would like to flesh out some ideas for a framework/platform which addresses these issues. These ideas are half-baked and may not tie in well with one another. I envision a distributed system as follows: 1. One kind of VM: DevOps people have a saying: "Treat your VMs like cattle, not pets". In practice, "cattle" becomes "cows, chickens, pigs, and lobster". VMs typically have an assigned role, and they become part of a group which may or may not be auto-scaling. For a given instantiation of this hypothetical platform, I would like to see a single kind of VM. That is, every VM is identical to every other VM, and they all run the same Haskell application. 2. Strict separation of business and non-business logic: The framework should handle all aspects of communication between nodes (like Cloud Haskell does) in a pluggable and transparent way, but that's not all. The framework should have first class support for other integrations (such as PagerDuty alerting, performance monitoring, etc) which are described below. 3. Pool coordination via DSL: The entire pool of VMs is orchestrated/coordinated by one ore more "scripts" written in a DSL, which is implemented as a Free Monad. Every single "operation" or "primitive" in your AST data type is Serializable, and when the framework interprets the DSL, it serializes the instruction and sends it over the network to a node for execution. The particular node on which the instruction gets executed is chosen by the platform, not the developer. 4. Smart resource consumption: Each node brings with it a set of resources. It is *not* my intention to create a system which views CPU, memory, etc as a contiguous unit. Rather, each primitive instruction in the AST is viewed as a "black box" which can only consume as much CPU and memory as the node has available to it. The framework is responsible for profiling each instruction and scheduling future instructions to a node for which resources are predicted to be available. The developer should be able to define new resources such as 3rd party API calls, bandwidth, database connections, etc, all of which are profiled just as CPU and memory would. 5. Browser based control panel: Engineers should have a GUI at their disposal which allows them to watch -- in real time -- the execution flow of the DSL script. 6. Structured logs with advanced filtering: All log output should be structured with first class support for shipping the data to Logstash/ElasticSearch. The aforementioned GUI should be able to selectively filter output based on certain pre-defined predicates and display them to the developer. For example, if you're building an email virus scanning system (which may see millions of emails per day), you may want to limit the real-time debugging output to only a specific customer. 7. First class integration with modern tools and services: The system should integrate with Consul, PagerDuty, statsd, RabbitMQ, memcache, DataDog, Logstash, and Slack, with new integrations being easy to add. This is vital for clean separation of business and non-business logic. For example, the developer should be able to cache certain bits of data at will, without having to worry about opening and managing a TCP connection to memcache. This is my vision, and I want to build it completely in Haskell. What do you all think? -- Alex

4 4

Re: [Haskell-cafe] how to make a KnownNat at runtime?
by dominic＠steinitz.org 15 Nov '17

15 Nov '17

You mean something like this? > withMatrix > :: forall z > . Matrix ℝ > -> (forall m n . (KnownNat m, KnownNat n) => L m n -> z) > -> z > withMatrix a f = > case someNatVal $ fromIntegral $ rows a of > Nothing -> error "static/dynamic mismatch" > Just (SomeNat (_ :: Proxy m)) -> > case someNatVal $ fromIntegral $ cols a of > Nothing -> error "static/dynamic mismatch" > Just (SomeNat (_ :: Proxy n)) -> > f (mkL a :: L m n) > Dear Cafe, > > I am using type-level numbers for > representing dimensions of vectors and matrices > (similar to https://github.com/ekmett/ersatz/blob/master/tests/Z001.hs ) > Now when I indeed know all the dimensions at compile time, > (in the example code, line 20) everything works nicely. > > But what do I do when the dimensions > will only become available at run time? > > Here is a simplified example: print the null vector > where the size is read from the command line - > of course in my application "handle" does more, > but it essentially has the type given here. > > I can extend the "case" in the "main" function > to include all the values I want to handle. > Looks ugly. Is there a better way? > > - J. > > {-# language KindSignatures, RankNTypes, LambdaCase, > TypeApplications, DataKinds, ScopedTypeVariables > #-} > > import GHC.TypeLits > import Data.Proxy > import System.Environment > > main :: IO () > main = getArgs >>= \ case > [ "2" ] -> handle (Proxy :: Proxy 2) > [ "3" ] -> handle (Proxy :: Proxy 3) > > handle :: forall (n::Nat) . KnownNat n => Proxy n -> IO () > handle (_ :: Proxy n) = print (zero :: V n Int) > > data V (n::Nat) a = V [a] deriving Show > > zero :: forall (n::Nat) a . (KnownNat n, Num a) => V n a > zero = V $ replicate (fromIntegral $ natVal (Proxy :: Proxy n)) 0 > Dominic Steinitz dominic(a)steinitz.org http://idontgetoutmuch.wordpress.com

1 0

ANNOUNCE: Haskell Communities and Activities Report (33rd ed., November 2017)
by Mihai Maruseac 15 Nov '17

15 Nov '17

On behalf of all the contributors, we are pleased to announce that the Haskell Communities and Activities Report (33rd edition, November 2017) is now available, in PDF and HTML formats: http://haskell.org/communities/11-2017/report.pdf http://haskell.org/communities/11-2017/html/report.html All previous editions of HCAR can be accessed on the wiki at https://wiki.haskell.org/Haskell_Communities_and_Activities_Report Many thanks go to all the people that contributed to this report, both directly, by sending in descriptions, and indirectly, by doing all the interesting things that are reported. We hope you will find it as interesting a read as we did. If you have not encountered the Haskell Communities and Activities Reports before, you may like to know that the first of these reports was published in November 2001. Their goal is to improve the communication between the increasingly diverse groups, projects, and individuals working on, with, or inspired by Haskell. The idea behind these reports is simple: Every six months, a call goes out to all of you enjoying Haskell to contribute brief summaries of your own area of work. Many of you respond (eagerly, unprompted, and sometimes in time for the actual deadline) to the call. The editors collect all the contributions into a single report and feed that back to the community. When we try for the next update, six months from now, you might want to report on your own work, project, research area or group as well. So, please put the following into your diaries now: ======================================== End of February 2018: target deadline for contributions to the May 2018 edition of the HCAR Report ======================================== Unfortunately, many Haskellers working on interesting projects are so busy with their work that they seem to have lost the time to follow the Haskell related mailing lists and newsgroups, and have trouble even finding time to report on their work. If you are a member, user or friend of a project so burdened, please find someone willing to make time to report and ask them to "register" with the editors for a simple e-mail reminder in November (you could point us to them as well, and we can then politely ask if they want to contribute, but it might work better if you do the initial asking). Of course, they will still have to find the ten to fifteen minutes to draw up their report, but maybe we can increase our coverage of all that is going on in the community. Feel free to circulate this announcement further in order to reach people who might otherwise not see it. Enjoy! -- Mihai Maruseac (MM) "If you can't solve a problem, then there's an easier problem you can solve: find it." -- George Polya

3 2

uninstalling libraries
by Evan Laforge 15 Nov '17

15 Nov '17

For a very long time, I've used a local script to uninstall libraries. Initially it was very simple: use ghc-pkg field to find and remove library-dirs, import-dirs, and haddock-html, and call ghc-pkg unregister. It served well for a long time, but eventually I got tired of copy paste games and extended it to be able to recursively delete dependents too. Unfortunately now it's no longer so simple. The main problem is that the only way I know to find dependents is to ghc-pkg unregister, and see what the error message complains about. That's obviously pretty bad, since by that time you've already unregistered, so it's too late to back out. The non-atomic nature of unregister+rm has always caused problems anyway, since if unregister succeeds, but the remove fails, we are stuck with a partial install. Recursive delete is too error prone, so I reverted that. And then I discovered that hmatrix helpfully includes /opt/local/lib and /usr/local/lib in its library-dirs, so clearly just deleting whatever the package tells me is not very safe. All this has led me to believe uninstalling packages is not so simple, and maybe there should be an actual real way to do it, not everyone hacking up their own dangerous shell scripts. So... is there? Should there be one? Is there interest in one? How do other people uninstall libraries? Is there a better interface to the pkg db than ghc-pkg? Is there a better way to find dependents than ghc-pkg unregister?

7 12

how to make a KnownNat at runtime?
by Johannes Waldmann 14 Nov '17

14 Nov '17

Dear Cafe, I am using type-level numbers for representing dimensions of vectors and matrices (similar to https://github.com/ekmett/ersatz/blob/master/tests/Z001.hs ) Now when I indeed know all the dimensions at compile time, (in the example code, line 20) everything works nicely. But what do I do when the dimensions will only become available at run time? Here is a simplified example: print the null vector where the size is read from the command line - of course in my application "handle" does more, but it essentially has the type given here. I can extend the "case" in the "main" function to include all the values I want to handle. Looks ugly. Is there a better way? - J. {-# language KindSignatures, RankNTypes, LambdaCase, TypeApplications, DataKinds, ScopedTypeVariables #-} import GHC.TypeLits import Data.Proxy import System.Environment main :: IO () main = getArgs >>= \ case [ "2" ] -> handle (Proxy :: Proxy 2) [ "3" ] -> handle (Proxy :: Proxy 3) handle :: forall (n::Nat) . KnownNat n => Proxy n -> IO () handle (_ :: Proxy n) = print (zero :: V n Int) data V (n::Nat) a = V [a] deriving Show zero :: forall (n::Nat) a . (KnownNat n, Num a) => V n a zero = V $ replicate (fromIntegral $ natVal (Proxy :: Proxy n)) 0

4 4

[ANN] Book About Simulation
by David Sorokin 11 Nov '17

11 Nov '17

Hi Cafe, I am delightful to inform that I wrote a book about simulation, Haskell and my Aivika libraries. http://aivikasoft.com/downloads/aivika/aivika.pdf It depends on point of view how to concern with this book. It can be a book about discrete event simulation per se. Also it can be considered as Aivika User’s Manual, or as a book about that how we can apply Haskell for simulation. I would be very grateful if someone could review my book, especially the English text as I’m a Russian native speaker. Best regards, David Sorokin

3 3