- Haskell-Cafe - Haskell.org

an automatic refactoring idea
by Jeffrey Brown 21 Jan '16

21 Jan '16

I had a data structure with a redundant field [1]. I refactored to make that field go away. Here is the code [2]. The following is a simplification of it. I was using this type: data X = X1 | X2 Int To make the Int go away, I made a duplicate type: data X' = X1' | X2' Then, every function for which any argument was of type X, I similarly duplicated, replacing every X with X', X1 for X1', and X2 for X2'. Next I had to similarly duplicate every function that used one of those. And so on, and so on ... until eventually I was duplicating the tests. At that point I was able to determine from the duplicate tests that everything was working. There was a little more work involved than that, but the vast, vast majority of the edits that got me there were the simple duplication I just described. I looked once at automatic refactoring in Haskell and was either unimpressed or scared. I may not have understood what I was looking at enough to appreciate its power. Is there something that can do the refactoring described above? [1] The Int in a Tplt could be inferred from context, so keeping a duplicate of that information in the Tplt was dangerous, because it makes invalid state possible (e.g. if one is updated and not the other). So I decided to stop using it. [2] https://github.com/JeffreyBenjaminBrown/digraphs-with-text -- Jeffrey Benjamin Brown

2 1

localized memory management?
by Johannes Waldmann 21 Jan '16

21 Jan '16

Dear cafe, how would you approach this task: find (enumerate) those x from a list xs for which some computation is not successful within some resource bound (it weeds out uninteresting data, leaving just the hard cases, which will be treated later by other means) Input and result could be lazy lists, computations are pure. If the bounded resource is time, then I can use System.Timeout. This puts me into IO, but OK. Perhaps I want to do some logging output anyways. The problem is with bounding space. Assume that "computation on x" (sometimes) allocates a lot. Then the whole program will just die with "heap exhausted", while in fact I want to terminate just the computation on this x, garbage-collect, and continue. I could make the space usage explicit: each step of the computation could additionally compute a number that approximates memory usage. (Assume that this usage varies wildly with each step.) Then I can stop iterating when this reaches some bound. Or, I just compile the computation into a separate executable, and I call it (for each x) via the operating system, because there I can bound space (with ulimit) Is there some way to achieve this in Haskell land? - J.W.

6 5

'stack test --trace' fails
by Eric 20 Jan '16

20 Jan '16

I just upgraded Stack to v1.0.2 on Mac OS X. I naively ran 'stack test --trace' hoping to get better messages out of any errorWithStackTrace calls in my tests. After a long, successful build, the tests failed with the message 'Could not understand these extra arguments: +RTS -xc'. Am I doing something obviously wrong? Or is this a Stack bug? --Eric

1 0

[Template Haskell Question] On defining recursive templates.
by Dominik Bollmann 20 Jan '16

20 Jan '16

Hello Haskellers, I'm currently diving into Template Haskell and I just read the original TH paper [1]. There they give the following example of a generic zip function: -- | A generic zip function. Use (e.g.,) as $(zipN 3) xs ys zs. zipN :: Int -> ExpQ zipN n = [| let zp = $(mkZip n [| zp |]) in zp |] -- | Helper function for zipN. mkZip :: Int -> ExpQ -> ExpQ mkZip n contZip = lamE pYs (caseE (tupE eYs) [m1, m2]) where (pXs, eXs) = genPEs "x" n (pXSs, eXSs) = genPEs "xs" n (pYs, eYs) = genPEs "y" n allCons = tupP $ zipWith (\x xs -> [p| $x : $xs |]) pXs pXSs m1 = match allCons continue [] m2 = match wildP stop [] continue = normalB [| $(tupE eXs) : $(appsE (contZip:eXSs))|] stop = normalB (conE '[]) -- | Generates n pattern and expression variables. genPEs :: String -> Int -> ([PatQ], [ExpQ]) genPEs x n = (pats, exps) where names = map (\k -> mkName $ x ++ show k) [1..n] (pats, exps) = (map varP names, map varE names) This works as expected, e.g., `$(zipN 3) [1..3] [4..6] [7..9]' gives [(1,4,7),(2,5,8), (3,6,9)]. However, I found this definition of passing `[| zp |]' as a helper function slightly confusing, so I tried to make it more succinct and to call zipN directly in the recursion: zipN' :: Int -> ExpQ zipN' n = lamE pYs (caseE (tupE eYs) [m1, m2]) where (pXs, eXs) = genPEs "x" n (pXSs, eXSs) = genPEs "xs" n (pYs, eYs) = genPEs "y" n allCons = tupP $ zipWith (\x xs -> [p| $x : $xs |]) pXs pXSs m1 = match allCons continue [] m2 = match wildP stop [] continue = normalB [| $(tupE eXs) : $(appsE (zipN n:eXSs)) |] stop = normalB (conE '[]) This subtle change, however, causes the compiler to diverge and to get stuck at compiling splice `$(zipN' 3) [1..3] [4..6] [7..9]'... Could anyone explain to me why the first approach works, but the 2nd small deviation does not? Is it because the compiler keeps trying to inline the recursive call to (zip N) into the template indefinitely? Are there easier (more straightforward) alternative implementations to the (imo) slightly convoluted example of zipN from the paper? Any hints are very much appreciated. Thanks, Dominik. [1] http://research.microsoft.com/~simonpj/papers/meta-haskell/

2 1

CPU with Haskell support
by Henning Thielemann 20 Jan '16

20 Jan '16

Hi all, every now and then I think it would be cool to have a microprocessor that supports Haskell in a way. A processor where lazy evaluation is not overhead but an optimization opportunity, a processor that can make use of the explicit data dependencies in Haskell programs in order to utilize many computation units in parallel. I know of the Reduceron project, which evolves only slowly and if it somewhen is ready for use it is uncertain whether it can compete with stock CPUs since FPGA's need much more chip space for the same logic. I got to know that in todays x86 processors you can alter the instruction set, which is mainly used for bugfixes. Wouldn't it be interesting to add some instructions for Haskell support? However, I suspect that such a patch might be rendered invalid by new processor generations with changed internal details. Fortunately, there are processors that are designed for custom instruction set extensions: https://en.wikipedia.org/wiki/Xtensa Would it be sensible to create a processor based on such a design? I have no idea what it might cost, and you would still need some peripheral circuitry to run it. What could processor instructions for Haskell support look like? Has anyone already thought in this direction?

9 12

Re: [Haskell-cafe] Doc generation?
by Francesco Ariis 20 Jan '16

20 Jan '16

On Tue, Jan 19, 2016 at 04:24:24PM +1100, Noon Silk wrote: > Does anyone know what is happening here? > > Not a single one of the packages on > http://hackage.haskell.org/packages/recent has docs generated at the moment. > > Some older ones, upload this year, also do not - > http://hackage.haskell.org/package/pipes-concurrency Docs not being built can be quite frustrating; for those dark times I build them locally: http://ariis.it/static/articles/no-docs-hackage/page.html Living with a flaky WiFi, saves me from screaming at the monitor quite some times.

8 11

Re: [Haskell-cafe] CPU with Haskell support
by Thomas Bereknyei 20 Jan '16

20 Jan '16

There is a CPU being design with an interesting architecture. Take a look at the Mill CPU at millcomputing.com. A facsinating feature is the use of a belt of values vs registers. The values on the belt are immutable and fall off (~auto gc'd?) unless expressly saved or returned. It is also desined to make function calls very cheap. tomberek On Jan 20, 2016 3:49 AM, <haskell-cafe-request(a)haskell.org> wrote: 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. Re: Doc generation? (Patrick Redmond) 2. Re: Doc generation? (Mark Fine) 3. Host-Oriented Template Haskell (Ericson, John) 4. [ANN] ghc-mod-5.5.0.0: Happy Haskell Hacking (Daniel Gr?ber) 5. CPU with Haskell support (Henning Thielemann) 6. Re: Doc generation? (Noon Silk) 7. Re: Doc generation? (Mikhail Glushenkov) 8. Re: CPU with Haskell support (Auke Booij) 9. Re: CPU with Haskell support (Darren Grant) 10. Re: CPU with Haskell support (Henning Thielemann) 11. Re: CPU with Haskell support (Ben Lippmeier) 12. Re: CPU with Haskell support (Richard A. O'Keefe) 13. Re: CPU with Haskell support (Gleb Popov) 14. Re: Doc generation? (Sven Panne) 15. Re: Doc generation? (Mikhail Glushenkov) 16. Re: CPU with Haskell support (Joachim Durchholz) 17. Re: Doc generation? (Sven Panne) ---------------------------------------------------------------------- Message: 1 Date: Tue, 19 Jan 2016 08:39:20 -0800 From: Patrick Redmond <plredmond(a)gmail.com> To: "cabal-devel(a)haskell.org" <cabal-devel(a)haskell.org>, "haskell-cafe(a)haskell.org" <haskell-cafe(a)haskell.org> Subject: Re: [Haskell-cafe] Doc generation? Message-ID: <CAHUea4Ht0p8%3DHwphL%2B--V7j3Xftt%3D8drrZDuOQtcB38rPPkJ2w(a)mail.gmail.com> Content-Type: text/plain; charset="utf-8" I don't know what's happening with hackage, but if you're using stack in your workflow a simple workaround is to build docs locally and search them with a shell script. For example: $ stack haddock async And then muck around in .stack-work or ~/.stack. I've written a bash/fish script to do the search for you here: plredmond.github.io/posts/search-haddocks-offline.html On Tuesday, January 19, 2016, Francesco Ariis <fa-ml(a)ariis.it> wrote: > On Tue, Jan 19, 2016 at 04:24:24PM +1100, Noon Silk wrote: > > Does anyone know what is happening here? > > > > Not a single one of the packages on > > http://hackage.haskell.org/packages/recent has docs generated at the > moment. > > > > Some older ones, upload this year, also do not - > > http://hackage.haskell.org/package/pipes-concurrency > > Docs not being built can be quite frustrating; for those dark times I > build them locally: > > http://ariis.it/static/articles/no-docs-hackage/page.html > > Living with a flaky WiFi, saves me from screaming at the monitor quite > some times. > _______________________________________________ > Haskell-Cafe mailing list > Haskell-Cafe(a)haskell.org <javascript:;> > http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe >

2 1

[ANN] ghc-mod-5.5.0.0: Happy Haskell Hacking
by Daniel Gröber 19 Jan '16

19 Jan '16

I'm pleased to announce the release of ghc-mod 5.5.0.0! This is primarily a maintenance and bug fix release. We are releasing this as a major version bump as we are following a policy of not trying to keep API compatibility until v6.0 to enable us to clean up ghc-mod's internals and API. What's new? =========== * Cabal flags are now preserved across automatic reconfigurations When ghc-mod detects something influencing the cabal configuration has changed since the last invocation it will automatically reconfigure the project. Previously this would call 'cabal configure' without any additional options thus possibly reverting flags the user might have added to the configure command previously. Now we extract the current set of flags from the existing configuration and pass the appropriate options to the configure command. * Rewritten command-line parser (again) The home grown sub-command parser based on getopt has been a user experience disaster so we've replaced it using a new optparse-applicative based parser. This does have the unfortunate side effect that we had to remove support for some optional arguments we had supported previously thus breaking compatibility with very old frontends. * Remove CWD requirement from command-line tools In v5.4.0.0 we had to add a workaround for a nasty race condition in 'ghc-mod legacy-interactive' (ghc-modi) which added a requirement that all ghc-mod command line tools are run in the root of each project's directory. This limitation has now been removed. Frontends which have implemented this workaround should be compatible going forward but for performance reasons it is advisable to disable the workaround for versions after v5.5.0.0. * Various bug fixes and smaller improvements From the change log: * Fix cabal-helper errors when no global GHC is installed (Stack) * Support for spaces in file names when using legacy-interactive * Fix "No instance nor default method for class operation put" * Fix a variety of caching related issues * Emacs: Fix slowdown and bugs caused by excessive use of `map-file` * Emacs: Add ghc-report-errors to inhibit *GHC Error* logging What is ghc-mod? ================ ghc-mod is both a back-end program for enhancing editors and other kinds of development environments with support for Haskell and a library for abstracting the black magic incantations required to use the GHC API in various environments, especially Cabal and Stack projects. The library is used by ambitious projects like HaRe[1], mote[2] and haskell-ide-engine[3] Getting ghc-mod =============== GitHub: https://github.com/DanielG/ghc-mod Hackage: http://hackage.haskell.org/package/ghc-mod Editor frontends: - Emacs (native): https://github.com/DanielG/ghc-mod https://github.com/iquiw/company-ghc - Vim: https://github.com/eagletmt/ghcmod-vim https://github.com/eagletmt/neco-ghc - Atom: https://github.com/atom-haskell/ide-haskell Known issues ============ For issues other than the ones mentioned below visit our issue tracker: https://github.com/DanielG/ghc-mod/issues Frequently reported issues -------------------------- ghc-mod once compiled is bound to one version of GHC since we link against the GHC API library. This used to not be a very big problem but since Stack made it exceedingly easy for users to use more than one version of GHC without even knowing the number of problems in this area has exploded. We are tracing the issue in the following issue: https://github.com/DanielG/ghc-mod/issues/615 (Support switching GHC versions without recompiling ghc-mod) ghc-mod's `case`, `sig` and `refine` commands still do not work properly with GHC>7.10 (See https://github.com/DanielG/ghc-mod/issues/438) Unless someone volunteers to fix this issue I will work towards replacing the features using mote[2] instead as the current code is, from my point of view, unmaintainable. If you do notice any other problems please report them: https://github.com/DanielG/ghc-mod/issues/new ---- [1]: https://github.com/alanz/HaRe [2]: https://github.com/imeckler/mote [3]: https://github.com/haskell/haskell-ide-engine

1 0

Host-Oriented Template Haskell
by Ericson, John 19 Jan '16

19 Jan '16

As is well known, TH and cross-compiling do not get along. There are various proposals on how to make this interaction less annoying, and I am not against them. But as I see it, the problem is largely inherent to the design of TH itself: since values can (usually) be lifted from compile-time to run-time, and normal definitions from upstream modules to downstream modules' TH, TH and normal code must "live in the same world". Now this restriction in turn bequeaths TH with much expressive power, and I wouldn't advocate getting rid of it. But many tasks do not need it, and in some cases, say in bootstrapping compilers[1] themselves, it is impossible to use TH because of it, even were all the current proposals implemented. For these reason, I propose a new TH variant which has much harsher phase separation. Normal definitions from upstream modules can not be used, lifting values is either not permitted or is allowed to fail (because of missing/incompatible definitions), and IO is defined to match the behavior of the host, not target, platform (in the cross compiling case). The only interaction between the two phases is that quoted syntax is resolved against the the run-time phase's definitions (just like today). Some of you may find this a shoddy substitute for defining a subset of Haskell which behaves identically on all platforms, and optionally constraining TH to it. But the big feature that my proposal offers and that one doesn't is to be able to independently specify compile-time dependencies for the host-oriented TH---this is analogous to the newish `Setup.hs` dependencies. That in turns leads to what I think is the "killer app" for Host-Oriented TH: exposing the various prepossessors we use (alex, happy, hsc2hs, even CPP) into libraries, and side-stepping any need for "executable dependencies" in Cabal. Note also that at least hsc2hs additionally requires host-IO---there may not even exist a C compiler on the target platform at all. Finally, forgive me if this has been brought up before. I've been thinking about this a while, and did a final pass over the GHC wiki to make sure it wasn't already proposed, but I could have missed something (this is also my first post to the list). John [1]: https://github.com/ghcjs/ghcjs/blob/master/lib/ghcjs-prim/GHCJS/Prim/Intern…

1 0

Re: [Haskell-cafe] [ANNOUNCE] Haskell DBMS: Project:M36
by A.M. 19 Jan '16

19 Jan '16

On 12/21/2015 11:30 AM, Rémi Vion wrote: > Hello, Project:M36 seems amazing, thanks ! > Thank your also for the link to the "/Out of the Tar Pit" paper/ > (http://shaffner.us/cs/papers/tarpit.pdf > <http://shaffner.us/cs/papers/tarpit.pdf>). Thank you Remi. We are working on completing the final components described in precisely this paper. Then, we will publish an essay about how Project:M36 meets the paper's requirements for functional-relational programming. > > Are you aware of people using Project:M36 in production ? The project is very young and unlikely to be used in production. Currently, I would recommend it to users interested in learning about the mathematics behind the relational algebra. In comparison, SQL is a terrible platform for learning about the relational algebra because SQL made some poor historical decisions. Here is an essay on one facet of this argument: https://github.com/agentm/project-m36/blob/master/docs/on_null.markdown > Is there some user feedback available somewhere ? Please use the github issue system if you encounter any problems. Or are you asking for a "frequently-asked questions" section? We should certainly add that. > For small scale applications, do you think M36 is ready enough to be a > viable alternative to Postgres ? Project:M36 would be a viable replacement for PostgreSQL for experimental use only. There are many more optimizations at every level which need to be implemented before Project:M36 is on-par with PostgreSQL and we are working on many new features. Project:M36 has also not yet achieved feature parity with PostgreSQL, though Project:M36 already includes some features impossible in PostgreSQL (such as nested relations). Thanks for trying Project:M36! Any feedback you have would be very valuable. Cheers, M

1 0

Stackage is reverting to aeson-0.9
by Dan Burton 19 Jan '16

19 Jan '16

This means that LTS 4 is being discontinued, and LTS 5 is imminent. See the announcement blog post: https://unknownparallel.wordpress.com/2016/01/18/stackage-is-reverting-to-a… See also related discussion (yesterday): https://www.reddit.com/r/haskell/comments/41gpdk/lts4_with_aeson010_is_bein… If there are any questions or concerns, don't hesitate to ping me. -- Dan Burton

1 0

Haskell dev roles with Strats at Standard Chartered
by Don Stewart 18 Jan '16

18 Jan '16

Hi folks, I'm hiring 3 more devs to write Haskell for Standard Chartered in London and Singapore. Details of the roles below, but broadly in FX algo pricing and pricing automation. Ability to write "tight" total Haskell that can run 24/7 and do the right thing is needed. https://donsbot.wordpress.com/2016/01/18/haskell-developer-roles-at-standar… CVs to me at Standard Chartered -- Don

1 0

project compile with multi-versions of alex
by Zilin Chen 18 Jan '16

18 Jan '16

Hi Cafe, I have a Haskell project which has ~90 dependencies (transitively) and is managed with plain cabal (w/o stackage, etc.). I try to keep it compile with a few latest releases of GHC (so right now 7.8.4, 7.10.1, 7.10.2 and 7.10.3). It was tractable with conditionals in the cabal config file with minor annoyance. But recently I found this issue:language-c-quote-0.11.3 does not compile with alex 3.1.5 [1]. I was wondering if I should also allow a few versions of executables, like alex, happy, etc (I can see though it will be a huge pain); or should I force all users to use the latest versions of them (I don't know if they are compatible with old ghc versions)? What's the common practice for other projects? Any hints? What should I write in my cabal config? Thanks, Zilin [1]https://github.com/mainland/language-c-quote/issues/57

2 1

ANN: stack-1.0.2
by Emanuel Borsboom 18 Jan '16

18 Jan '16

New version released of Stack, a build tool. See haskellstack.org for installation and upgrade instructions. Release notes: - Arch Linux: Stack has been adopted into the official community repository <https://www.archlinux.org/packages/community/x86_64/stack/>, so we will no longer be updating the AUR with new versions. See the install/upgrade guide <http://docs.haskellstack.org/en/stable/install_and_upgrade.html#arch-linux> for current download instructions. Major changes: - stack init and solver overhaul #1583 <https://github.com/commercialhaskell/stack/pull/1583> Other enhancements: - Disable locale/codepage hacks when GHC >=7.10.3 #1552 <https://github.com/commercialhaskell/stack/issues/1552> - Specify multiple images to build for stack image container docs <http://docs.haskellstack.org/en/v1.0.2/yaml_configuration.html#image> - Specify which executables to include in images for stack image container docs <http://docs.haskellstack.org/en/v1.0.2/yaml_configuration.html#image> - Docker: pass supplemantary groups and umask into container - If git fetch fails wipe the directory and try again from scratch #1418 <https://github.com/commercialhaskell/stack/issues/1418> - Warn if newly installed executables won’t be available on the PATH #1362 <https://github.com/commercialhaskell/stack/issues/1362> - stack.yaml: for stack image container, specify multiple images to generate, and which executables should be added to those images - GHCI: add interactive Main selection #1068 <https://github.com/commercialhaskell/stack/issues/1068> - Care less about the particular name of a GHCJS sdist folder #1622 <https://github.com/commercialhaskell/stack/issues/1622> - Unified Enable/disable help messaging #1613 <https://github.com/commercialhaskell/stack/issues/1613> Bug fixes: - Don’t share precompiled packages between GHC/platform variants and Docker #1551 <https://github.com/commercialhaskell/stack/issues/1551> - Properly redownload corrupted downloads with the correct file size. Mailing list discussion <https://groups.google.com/d/msg/haskell-stack/iVGDG5OHYxs/FjUrR5JsDQAJ> - Gracefully handle invalid paths in error/warning messages #1561 <https://github.com/commercialhaskell/stack/issues/1561> - Nix: select the correct GHC version corresponding to the snapshot even when an abstract resolver is passed via --resolver on the command-line. #1641 <https://github.com/commercialhaskell/stack/issues/1641> - Fix: Stack does not allow using an external package from ghci #1557 <https://github.com/commercialhaskell/stack/issues/1557> - Disable ambiguous global ‘—resolver’ option for ‘stack init’ #1531 <https://github.com/commercialhaskell/stack/issues/1531> - Obey --no-nix flag - Fix: GHCJS Execute.hs: Non-exhaustive patterns in lambda #1591 <https://github.com/commercialhaskell/stack/issues/1591> - Send file-watch and sticky logger messages to stderr #1302 <https://github.com/commercialhaskell/stack/issues/1302> #1635 <https://github.com/commercialhaskell/stack/issues/1635> - Use globaldb path for querying Cabal version #1647 <https://github.com/commercialhaskell/stack/issues/1647>

1 0

Haskell Weekly News
by Kim-Ee Yeoh 15 Jan '16

15 Jan '16

*Top Picks:* - Team GHC announces the first release candidate of version 8.0 <http://haskell.1045720.n5.nabble.com/ANNOUNCE-Glasgow-Haskell-Compiler-8-0-…>. New features include: - Strict and StrictData extensions - TypeFamilyDependencies extension for injective type families <https://ghc.haskell.org/trac/ghc/wiki/InjectiveTypeFamilies> - TypeInType extension for more dependent typing hackery - explicit type application in plain Haskell, not Core - Applicative do-notation - a spanking new pattern-match checker - modularization of the ghci interpreter: it can now run as an independent process Note that the announcement includes a list of bugs linked to the new features. - The engineers at an Australian real estate listings website explain how they "used Category Theory to solve a problem in Java." <http://techblog.realestate.com.au/how-we-used-category-theory-to-solve-a-pr…> They face the problem of their search API having grown gnarly and inextensible. First they offer a monoid tutorial culminating in SearchResults -> SearchResults endomorphisms. Then they regularize their database lookups as Kleisli-composable instances of a monomorphic state monad of type (DataSource, SearchResults) -> SearchResults. Finally, they profunctorize the state monad for mereological development of the DataSource. So how was the blog post received? A vocal section of the HN community express skepticism <https://news.ycombinator.com/item?id=10892696>. One haskell subredditor found it "an excellent article." <https://www.reddit.com/r/haskell/comments/40s85b/how_we_used_category_theor…> - Verity Stob <https://en.wikipedia.org/wiki/Verity_Stob>, the doyen of information technology satire, skewers the cargo culting of Functional Programming <http://www.theregister.co.uk/2016/01/13/stob_remember_the_monoids/> and by the by writes a monad tutorial (omg!). Haskell redditors chuckle and cluck at the hatchet job <https://www.reddit.com/r/haskell/comments/40wqzf/learn_you_func_prog_on_fiv…> . - Team Wander Nauta creates Viskell <https://github.com/wandernauta/viskell>, "an experimental visual programming environment for a typed (Haskell-like) functional programming language." Programming with touch tablets in mind, he implements Viskell in Java 8 because "Haskell lacks suitable GUI libraries, and we need good multi-touch support." A slides PDF contains more screenshots. <https://github.com/wandernauta/viskell/blob/master/viskell-nlfpday.pdf> Well-received on both Hacker News <https://news.ycombinator.com/item?id=10874294> and /r/haskell <https://www.reddit.com/r/haskell/comments/406au9/viskell_visual_programming…> . *Quotes of the Week:* - Tom Ellis: <https://news.ycombinator.com/item?id=10870488#up_10874714> In Haskell you don't fight the type system. It fights your bugs. - Jeremy Bowers: <https://news.ycombinator.com/item?id=10892293#up_10896419> The reason I find Haskell interesting is precisely that it's the only place I know where the theoretically-minded and the practically-minded get together and interpollinate. Everywhere else the one group pretty much just sneers at the other. - Redditor lukewarm: <https://www.reddit.com/r/haskell/comments/40aa4n/how_to_make_industry_quali…> Yes, you can write industry quality software in Haskell. Do all your computations in the IO monad, keep intermediate results in MVars. Use only Int and String types. Use exceptions to handle errors. Write yourself custom constructs to emulate for and while loops, preferably using Template Haskell. -- Kim-Ee

1 0

repa parallelization results
by Anatoly Yakovenko 14 Jan '16

14 Jan '16

https://gist.github.com/aeyakovenko/bf558697a0b3f377f9e8 so i am seeing basically results with N4 that are as good as using sequential computation on my macbook for the matrix multiply algorithm. any idea why? Thanks, Anatoly

5 19

Call for Participation: BOB 2016 (February 19, Berlin)
by Stefan Wehr 14 Jan '16

14 Jan '16

Quick reminder: the early registration deadline for BOB 2016 is this Sunday! We have some interesting Haskell talks and tutorials at BOB 2016! ================================================================ BOB 2016 Conference "What happens if we simply use what's best?" February 19, 2016 Berlin http://bobkonf.de/2016/ Program: http://bobkonf.de/2016/program.html Registration: http://bobkonf.de/2016/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/2016/program.html The subject range of talks includes functional programming, advanced front-end development, data management, and sophisticated uses of types. The tutorials feature introductions to Erlang, Haskell, Scala, Isabelle, Purescript, Idris, Akka HTTP, and Specification by Example. Elise Huard will hold the keynote talk - about Languages We Love. Registration is open online: http://bobkonf.de/2016/registration.html NOTE: The early-bird rates expire on January 17, 2016! 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

Hiring: Haskell at Biotech Startup!
by Andrew Gibiansky 13 Jan '16

13 Jan '16

Hello haskell-cafe, I'm an engineer at Karius, a "stealth-mode" biotech startup in Menlo Park, CA, and we're looking to hire a few folks to write software (and we use Haskell!). Currently only hiring locally or with relocation (though that could change in the future, so feel free to get in touch regardless!). We are a team of crazy biologists, engineers, data scientists and clinicians on a mission to change forever the way infectious diseases are diagnosed and treated. We face incredibly interesting challenges in software engineering, machine learning and molecular biology, as we push the limits of diagnostics and genomic technologies. We're hiring computational biologists, software engineers and data scientists. If you're a software engineer, we're looking for experience in front-end, back-end, web development, intrastructure, devops, bioinformatics, and machine learning. We have a varied list of challenges; we build large data processing pipelines to analyze data from in-house DNA sequencers, separate the signal from the noise and extract what we need, and visualize this in ways that are helpful for scientists and doctor; we build web apps and tools for biologists and doctors to use to plan, conduct, and analyze experiments; we work closely with molecular biologists to analyze data generated by these experiments and develop novel computational biology methods. Our technology stack, as of right now: - Python (for bioinformatics) - Rails (for one backend codebase in maintenance mode) - React and ES6 (for front-end interfaces) - Haskell (for infrastructure and new development) - Backed by AWS and Docker We just put our first large Haskell application into production and are planning on continuing with Haskell; this is an opportunity to use Haskell at a cutting-edge biotechnology startup. If any of this sounds exciting to you, please don't hesitate to get in touch with us by emailing Greg Stock atgstock(a)kariusdx.com. Take a look at our job postings on AngelList <https://angel.co/karius/jobs> for more detail, though they won't say much about Haskell. You may know me personally from my work with IHaskell <http://github.com/gibiansky/IHaskell> and my hindent style <http://github.com/chrisdone/hindent>; Greg Weber is also here at Karius, whom you may know from his contributions to Persistent <http://github.com/yesodweb/persistent>, Yesod <http://github.com/yesodweb/yesod>, and Shelly <https://github.com/yesodweb/Shelly.hs>. -- Andrew Gibiansky

1 0

7.10.3 source link missing
by aditya siram 13 Jan '16

13 Jan '16

Hi all, Just wanted to make haskell.org maintainers aware that 7.10.3 release does not provide a link to the source distribution on the Download page. https://www.haskell.org/ghc/download_ghc_7_10_3#sources. Thanks! -deech

1 1

New release of the book Haskell Programming from first principles
by Christopher Allen 13 Jan '16

13 Jan '16

I'd been reticent in the past to announce the book on the mailing list, but it's pretty comprehensive now and we have enough ecstatic readers learning Haskell with it that I thought I'd share what we've been up to. We're writing this Haskell book (http://haskellbook.com/) because many have found learning Haskell to be difficult and it doesn't have to be. We have a strong focus on writing it to be a book for learning and teaching - it's not just a reference or review of topics. Particularly, we strive to make the book suitable for self-learners. We think Haskell is a really nice language and learning Haskell should be as nice as using it is. The new release puts the book at 26 chapters and 1,156 pages. You can track our progress here: http://haskellbook.com/progress.html The latest release included parser combinators, composing types, and monad transformers. My coauthor Julie Moronuki has never programmed before learning Haskell to work with me on this book. She has written about using the book to teach her 10 year old son as well - https://superginbaby.wordpress.com/2015/04/08/teaching-haskell-to-a-10-year… Julie has also written about learning Haskell more generally - https://superginbaby.wordpress.com/2015/05/30/learning-haskell-the-hard-way/ If you've been reading the book, please speak up and share your thoughts. We have some reader feedback on the site at http://haskellbook.com/feedback.html We'll be looking for a press to do a print run of the book soon as it's about 80% done. If anyone has any pointers or recommendations on whom to work with, particularly university presses, please email me. Cheers everyone, Chris Allen

6 8

Why does shift's function return result in Cont and reset reinsert result into Cont again?
by Dmitriy Matrosov 12 Jan '16

12 Jan '16

Hi. I've read "Introduction to Programming with Shift and Reset" by Kenichi Asai and Oleg Kiselyov , where shift and reset defined as > import Control.Monad.Cont > > shift :: ((a -> w) -> Cont w w) -> Cont w a > shift f = cont (flip runCont id . f) > > reset :: Cont a a -> Cont w a > reset = return . flip runCont id > > shiftT :: Monad m => ((a -> m w) -> ContT w m w) -> ContT w m a > shiftT f = ContT (flip runContT return . f) > > resetT :: Monad m => ContT a m a -> ContT w m a > resetT = lift . flip runContT return But why should function f return result in Cont, which i'll unwrap immediately? And why should i reinsert delimited continuation's result into Cont again in reset? Wouldn't it be simpler (better?) to just define shift/reset like > shift' :: ((a -> w) -> w) -> Cont w a > shift' = cont > > reset' :: Cont w w -> w > reset' m = runCont m id > > shiftT' :: ((a -> m w) -> m w) -> ContT w m a > shiftT' = ContT > > resetT' :: Monad m => ContT w m w -> m w > resetT' m = runContT m return Moreover, Bubble-up semantics proof of Cont bubble elimination is (literally) correct only with reset' (below is my bubble implementation, may be i've written it wrong?): > data Bubble w a b = Bubble (a -> Bubble w a b) ((a -> w) -> Bubble w a w) > | Value b > > instance Monad (Bubble w a) where > return x = Value x > Value x >>= h = h x > Bubble k f >>= h = Bubble (\x -> k x >>= h) f > > convBub'2 :: Bubble w a b -> Cont w b > convBub'2 (Value x) = return x > convBub'2 (Bubble k f) = cont $ \t -> runCont (fC (\x -> runCont (kC x) t)) id > where > --fC :: (a -> w) -> Cont w w > fC = convBub'2 . f > --kC :: a -> Cont w b > kC = convBub'2 . k > > bubbleResetProp :: Eq w => Bubble w a w -> Bool > bubbleResetProp b@(Value x) = reset' (convBub'2 b) == x > bubbleResetProp b@(Bubble k f) = > reset' (convBub'2 b) == reset' (fC (\x -> reset' (kC x))) > where > --fC :: (a -> w) -> Cont w w > fC = convBub'2 . f > --kC :: a -> Cont w b > kC = convBub'2 . k > > infixl 0 === > (===) :: a -> a -> a > (===) = const > > bubbleResetProof :: Bubble w a w -> w > bubbleResetProof (Bubble k f) = > reset' (cont $ \t -> runCont (fC (\x -> runCont (kC x) t)) id) > === runCont (cont $ \t -> runCont (fC (\x -> runCont (kC x) t)) id) id > === (\t -> runCont (fC (\x -> runCont (kC x) t)) id) id > === runCont (fC (\x -> runCont (kC x) id)) id > === reset' (fC (\x -> reset' (kC x))) > where > --fC :: (a -> w) -> Cont w w > fC = convBub'2 . f > --kC :: a -> Cont w b > kC = convBub'2 . k -- Dmitriy Matrosov

2 1

Re: [Haskell-cafe] New release of the book Haskell Programming from first principles
by Johannes Waldmann 12 Jan '16

12 Jan '16

Chris - Impressive amount of work! Since this is "cafe" ... allow me to put my standard rant here: Browsing your table of contents, I certainly agree that lambda calculus is a first principle. But when I teach (beginners or not) I put algebraic data types and pattern matching even before functions. Because I want to first describe data, then transformation of data. (Yes, I know, we can simulate data with functions. We can also simulate lambda calculus with term rewriting. No winner there..) And testing really should go as early as possible (lecture 1 or 2, ideally). I don't really know how to do this from first principles and early, because we need some type-classes here (deriving Eq and Show, and also Serial, for automated test case generation. Which should be a strong selling point.) And I do avoid numbers, lists and strings. Really. Functional programming tragically over-uses lists, and by extension, strings. (Of course, other languages also tragically over-use strings.) When I need a list, I have the students write down the data declaration. When I need numbers (mostly I don't), it's Peano numbers. Yes, lazy lists have a purpose in Haskell (expressing control) but this only works if they're being fused away. Later, when we have modules and type classes (for abstract data types), students can learn to use different representations for sequences. But if you start feeding them lists/strings, they'll think it's natural, and have a hard time switching to Data.Sequence, Data.Vector, Data.Text ... I know I did. Well. I'm sure you've given this a lot of thought. I see that you refer to Brent Yorgey's course https://github.com/bitemyapp/learnhaskell#yorgeys-cis194-course and there we have "data"/"case" in lecture 2. Oh, and I do have to read up on how he sells Applicative/Monad. For me, Monad feels more natural, but that's just because I learned it earlier, and now I have to unlearn it. And that illustrates the point I'm making about lists and strings. Best - Johannes.

2 1

Data declaration vs type classes
by Lian Hung Hon 11 Jan '16

11 Jan '16

Dear haskellers, What is the difference between writing data Task = GroceryTask String | LaundryTask Int doTask :: Task -> IO () doTask (GroceryTask s) = print "Going to " ++ s doTask (LaundryTask n) = print (show n ++ " pieces washed" and class Task a where work :: a -> IO () data GroceryTask = GroceryTask String data LaundryTask = LaundryTask Int instance Task GroceryTask where .. instance Task LaundryTask where .. doTask :: Task a => a -> IO () doTask = work They seem to be similar functionality wise, except that one is on the data level and another is on the class level. How should one go about deciding to use data or class? Is there a semantic difference? Which is more appropriate here? Happy new year, Hon

8 11

[RFC] github-0.14.0 release candidate
by Oleg Grenrus 11 Jan '16

11 Jan '16

Hi, There are lot of breaking changes In upcoming github package, which provides accoss to the Github API, v3 [1] I’d like to hear feedback before pushing the actual release. There are many breaking changes, and would be nice to avoid new breaking changes very soon. So if you spot something which can still be fixed, don’t hesitate to contact me or create a issue on Github [3]. You can find the release candidate at Hackage [2]. Cheers, Oleg Grenrus - [1]: https://developer.github.com/v3/ - [2]: http://hackage.haskell.org/package/github-0.14.0/candidate - [3]: https://github.com/phadej/github/issues

1 0

Promotion of field accessors using DataKinds
by William Yager 11 Jan '16

11 Jan '16

Hello all, Let's say I have some data data Config = Conf (len :: Nat) (turboEncabulate :: Bool) Using DataKinds, we can promote Config to a kind and Conf to a type. However, it does not appear that GHC supports e.g. data Thing (conf :: Config) = Thing data Count (n :: Nat) = Count foo :: Thing conf -> Count (len conf) foo Thing = Count That is, it does not appear to properly replace "len conf" with the value of len from conf. Instead, the way I've found to do this is to define class Lengthed (a :: Config) where type Len a :: Nat instance Lengthed (Conf n) where type Len (Conf n t) = n Now, foo :: Thing conf -> Count (Len conf) works fine. So manually defining a type function that intuitively does the exact same thing as "len" seems to work. Is there a particular reason behind this? Thanks, Will

2 1

Merging the OpenGLRaw and gl packages
by Sven Panne 11 Jan '16

11 Jan '16

Currently there are 2 similar packages on Hackage to access raw OpenGL functionality: OpenGLRaw and gl. Taking a closer look at them, it turns out that they are only superficially different and have a lot of things in common. This is a bit confusing for users, so it might make sense to merge those packages. Therefore I'd like to start a discussion how to do this in detail, collecting user feedback and opinions. I think that haskell-cafe is the right place for this discussion, while an accompanying wiki page is more suitable to collect the results. As a basis I started a page at https://github.com/haskell-opengl/OpenGLRaw/wiki/Merging-OpenGLRaw-and-gl, which is necessarily biased at the moment. ;-) It would be nice to hear your opinions about how the package should look like, what might be missing, what could be done better, which differences I forgot, etc. Cheers, S.

3 9

ANN: true-name 0.1.0.0 released
by Liyang HU 11 Jan '16

11 Jan '16

> Also sent to comp.lang.haskell, & to convince Gmane I'm not top-posting. It is with some shame that I announce ‘true-name’, a package to assist one in violating those pesky module abstraction boundaries via the magick of Template Haskell. http://hackage.haskell.org/package/true-name Take ‘Control.Concurrent.Chan’ for example; you can get your grubby mitts on the ‘Chan’ data constructor, despite it not being exported. Here we pattern match on it, and bind ‘chanR’ and ‘chanW’ to the ‘MVar’s containing the read and write ends of the channel respectively: > chan@[truename| ''Chan Chan | chanR chanW |] <- newChan > writeChan chan (42 :: Int) Now, the type of ’chanR’ references the unexported ‘Stream’ and ‘ChItem’ types. We need the ‘ChItem’ data constructor―which is hidden under a few indirections—but that's not a problem: > streamR <- readMVar chanR > [truename| ''Chan Chan Stream ChItem ChItem | x _ |] <- readMVar streamR > putStrLn $ "chan contains: " ++ show x This gives us a rather dodgy ‘peekChan’. This sort of thing is usually a Bad Idea™, but may sometimes be more palatable than the alternatives. Full example: https://github.com/liyang/true-name/blob/master/sanity.hs Taking another example, suppose we want the ‘Array’ type constructor hidden deep in the bowels of the ‘HashMap’ implementation: ghci> :set -XQuasiQuotes ghci> import Data.HashMap.Strict ghci> :kind [truename| ''HashMap Full Array |] [truename| ''HashMap Full Array |] :: * -> * The ‘Array’ data constructor is one more reification away: ghci> :type [truename| ''HashMap Full Array Array |] [truename| ''HashMap Full Array Array |] :: ghc-prim-0.4.0.0:GHC.Prim.Array# a -> unordered-containers-0.2.5.1:Data.HashMap.Array.Array a Please don't flame me. /Liyang

1 0

pattern matching v. type checking
by Jeffrey Brown 10 Jan '16

10 Jan '16

I am, thanks to an idea from Elliot Cameron, using the Functional Graph Library (FGL) to implement [1] something resembling a hyperggraph, which I'm calling Mindmap, in which relationships can involve any number of things, including other relationships. (By contrast, in a graph, Edges cannot belong to other Edges; only Nodes can.) Here are the types: -- Exprs (expressions) play Roles in Rels (relationships). -- A k-ary (Arity k) Rel consists of a k-ary template and k members. -- Each k-ary Rel emits k+1 Edges toward the other Exprs: -- one connects it to its RelTplt (relationship template) -- k more connect it to each of its k RelMbrs (relationship members) -- The two paragraphs after it will clear up any questions about the next. type Mindmap = Gr Expr Role data Role = RelTplt | RelMbr RelPos deriving (Show,Read,Eq,Ord) data Expr = Str String | Tplt Arity [String] | Rel Arity -- TODO ? deduce the Arity of a Tplt from its [String] -- TODO ? deduce from the graph the Arity of a Rel -- rather than carrying it redundantly in the Rel constructor deriving (Show,Read,Eq,Ord) type RelPos = Int -- the k members of a k-ary Rel take RelPos values [1..k] type Arity = Int The following is a Mindmap that represents the expression "dog needs water" using the subexpressions "dog" (a string), "water" (a string), and "_ wants _" (a relationship two things can have, that is a binary Rel): -- mkGraph :: Graph gr => [LNode a] -> [LEdge b] -> gr a b -- that is, mkGraph takes a list of nodes followed by a list of edges g1 :: Mindmap g1 = mkGraph [ (0, Str "dog" ) , (1, stringToTplt "_ wants _" ) -- produces a Tplt with Arity 2 , (3, Str "water" ) , (4, Rel 2 ) ] [ -- "dog wants water" (4,1, RelTplt) -- Node 1 is the Template for the Rel at Node 4 , (4,0, RelMbr 1) -- Node 0 is the 1st Rel Member of the Rel at Node 4 , (4,3, RelMbr 2) -- Node 3 is the 2nd Rel Member of the Rel at Node 4 ] The next Mindmap encodes the previous statement and a second statement stating that the first is dubious: g2 :: Mindmap g2 = mkGraph [ (0, Str "dog" ) , (1, stringToTplt "_ wants _" ) , (3, Str "water" ) , (4, Rel 2 ) , (5, stringToTplt "_ is _") , (6, Str "dubious" ) , (7, Rel 2 ) ] [ -- "dog wants water" is represented just like it was in g1 (4,1,RelTplt), (4,0, RelMbr 1), (4,3,RelMbr 2), -- "[dog wants water] is dubious" (7,5,RelTplt), (7,4,RelMbr 1), -- Node 4, the first Member of this Rel, is itself a Rel (7,6,RelMbr 2) ] I find myself doing a lot of pattern matching that maybe should be type checking instead, to distinguish between the three Expr constructors: For instance, here is a function that, given a Node at which there is a Rel, returns the Tplt for that Rel: tpltForRelAt :: (MonadError String m) => Mindmap -> Node -> m Expr tpltForRelAt g rn = do ir <-isRel g rn if not ir then throwError $ "tpltForRelAt: Label of LNode " ++ show rn ++ " is not a Rel." else return $ fromJust $ lab g $ head [n | (n,RelTplt) <- lsuc g rn] -- todo ? head is unsafe -- but is only unsafe if graph takes an invalid state -- because each Rel should have exactly one Tplt I had to manually check whether the Expr in question was a Rel. I feel like I'm doing the type system's job. Is there a better way? [1] https://github.com/JeffreyBenjaminBrown/digraphs-with-text -- Jeffrey Benjamin Brown

1 0

Regarding Developing my skills with haskell!
by Abhijit Patel 09 Jan '16

09 Jan '16

Hello, I want to learn some practical application using haskell like some projects or developing a game. Can anyone suggest me some link to develop my skills with haskell ? Cheers, Abhijit

3 2

Re: [Haskell-cafe] Lazy series [was : Preventing sharing]
by Tom Ellis 09 Jan '16

09 Jan '16

Sharing a private conversation, with the permission of Jerzy. On Sat, Jan 09, 2016 at 11:45:00AM +0100, Jerzy Karczmarczuk wrote: > Again: *exps = 1 + integral exps* > > I said that if RHS exps is evaluated, it cannot work. > > >>>But if it evaluates to a thunk ... > >>Then, on which premises you call the language "strict"? > > >Why not? > > > >A thunk could either be a delayed function call, or it could be a memoised > >thunk, such as OCaml (a strict language) provides > > > > http://caml.inria.fr/pub/docs/manual-ocaml/libref/Lazy.html [...] > But in the original expression with exps, you don't delay anything. > You don't construct *exps()*, or equivalent. This variable is just > variable, lexical atom, and either you evaluate it or not. If not, > don't call the language strict. If there is a delay form introduced > by the compiler, the language is not strict. > > If you don't agree, I suggest that instead of asking "why this > doesn't work, it should!" , simply implement it. Oleg has already provided most of the solution http://okmij.org/ftp/ML/powser.ml The aim is exps = 1 + integral exps In Oleg's framework the answer is let exps = I.fix (fun e -> int 1 +% integ e) In a hypothetical OCaml with typeclasses, this becomes let exps = I.fix (fun e -> 1 + integ e) The remaining objection is the presence of the fix. The solution here is to allow the language to support recursive bindings of lazy values[1], not just of function values. The we could write let rec exps = 1 + integ exps If you still do not agree I would appreciate it if you could explain why such a language a) could not exist, or b) would not be called "strict" If you're still not convinced, consider a lazy language, Haskell--, which doesn't allow recursive bindings of non-function types. In Haskell-- you *cannot* write exps = 1 + integral exps but you have to write exps = I.fix (\e -> 1 + integral e) So we see that the nice syntax "exps = 1 + integral exps" is not due to laziness (since Haskell-- is lazy, but you cannot write that). Instead the nice syntax is due to lazy recursive bindings, and this sugar can exist as well in a strict language as it can in a lazy one. Tom [1] Note that recursive bindings are anyway just syntactic sugar for a fixed point. The definition sum = \x -> case x of [] -> 0 (x:xs) = x + sum xs is (essentially) sugar for sum = fix (\sum' x -> case x of [] -> 0 (x:xs) = x + sum' xs) so adding additional sugar for binding lazy values can hardly spoil anything.

3 9

async docs not on hackage for some reason?
by Noon Silk 09 Jan '16

09 Jan '16

Hello, Does anyone have any thoughts why the async docs aren't available on hackage yet? - https://hackage.haskell.org/package/async-2.1.0 It says this version was uploaded a few days ago, but no docs are available. I did a `cabal get` locally and build the docs using stack; so it works fine. -- Noon Silk, ن https://silky.github.io/ "Every morning when I wake up, I experience an exquisite joy — the joy of being this signature."

2 1

Re: [Haskell-cafe] Haskell-cafe] Preventing sharing
by Doug McIlroy 09 Jan '16

09 Jan '16

Oleg rewrote my power-series one-liners to illustrate the fact that lazy lists defined in a strict language need not be very clumsy to use. I had implemented those funstions in many strict languages, one of which was ML using a lazy-list implementation from Dave MacQueen. But after I finally did it in Haskell, I never looked back. Though ML was the best of the strict bunch. Haskell's overloading and cleaner notation made for more perspicuous code. It also enabled elegant code like this for the exponential series: exps = 1 + integral exps As Oleg pointed out, this won't work in a strict language, and must be replaced with something much less vivid: exps = fix (\s 1 + integral s) In slightly more involved cases, such as sins = integral coss coss = 1 - integral sins the strict equivalent becomes murky: sins = fix (\s -> integral (1 - integral s)) coss = derivative sins or (sins, cosx) = fix (\sc -> (integral $ snd sc, 1 - integral $ fst sc) Further, because lazy lists are a new type, they can't be manipulated directly with the standard list vocabulary (map, take, filter, etc.). All such functions must be lifted to the new type. Thus, while lazy lists can be *programmed* in a strict language, they *play* somewhat awkwardly in it. In fairness, I must admit that the beauty of representation by naked lists may not survive when power series are embedded in a more comprehensive algebraic system. For example, if both matrices and power series were defined as list instances of Num, matrices might be confusEd with nested power series. Combinations--matrices of power series and vice versa--could be similarly ambiguous. But it could also turn out to cause no more difficulty than the already extensive degree of polymorphism in arithmetic expressions. Doug

3 3

error while setting it up
by Abhijit Patel 08 Jan '16

08 Jan '16

for the below command I am getting errror !! please suggest me a solution $make ===--- building phase 0 make --no-print-directory -f ghc.mk phase=0 phase_0_builds ghc.mk:159: *** dyn is not in $(GhcLibWays), but $(DYNAMIC_GHC_PROGRAMS) is YES. Stop. make: *** [all] Error 2

3 2

Haskell Weekly News
by Kim-Ee Yeoh 08 Jan '16

08 Jan '16

Folks: Recall the quote from the May Day 2015 issue: <http://haskell.1045720.n5.nabble.com/Haskell-Weekly-News-td5808226.html> The MLs and Haskell remind me of Brian Eno's line about how the first Velvet Underground album only sold 30,000 copies, but "everyone who bought one of those 30,000 copies started a band". This issue spotlights Elm and Idris, two languages implemented in Haskell. Enjoy! *Top Picks:* - Evan Czaplicki of the Elm web-front-end language leaves Prezi for NoRedInk <http://elm-lang.org/blog/new-adventures-for-elm>. A startup dedicated to improving high-school English grammar, NoRedInk already employs 5 engineers writing Elm full-time. A HN comment hyperbolizes that Elm <https://news.ycombinator.com/item?id=10837278#up_10838052> "is Clojure without parens, it's Haskell without academy, it's Redux without facebook, it's duck-typing without quacks, it's MVC without objects, and last but not least Evan Czaplicki (the creator) is the new Aaron Patterson (bright and fun!)." [Ed. Aaron is a Ruby and also Rails core dev.] - Janos Dobronszki, a self-described "Haskell addict, latent Idris fan", introduces Idris <http://crufter.com/2015/01/01/idris-a-language-which-will-change-the-way-yo…> as "a language that will change the way you think about programming <https://news.ycombinator.com/from?site=crufter.com>." He motivates dependent types using the classic list vector example. The Hacker News community enthuses over the article <https://news.ycombinator.com/item?id=10850205> with healthy signs of grassroots static-typing evangelism. Elsewhere, a haskell redditor obtains valuable answers about the tradeoffs that dependently typed programming incurs <https://www.reddit.com/r/haskell/comments/3zc81v/tradeoffs_of_dependent_typ…> . - In "Monads to Machine Code (Part 1)" <http://www.stephendiehl.com/posts/monads_machine_code.html>, Stephen Diehl walks his readers through an LLVM-like runtime machine code generation while introducing the x86 architecture all at the same time. No mean feat, what more x86 as opposed to a RISC architecture. Much-loved on HN <https://news.ycombinator.com/item?id=10842988>. Also on haskell reddit <https://www.reddit.com/r/haskell/comments/3zfca3/monads_to_machine_code_par…>. Compare to Lennart Augustsson's older series on code generation <http://augustss.blogspot.com/search/Label/Code%20generation>. Quality packages on hackage for runtime code generation include harpy <https://hackage.haskell.org/package/harpy> and llvm-general <https://hackage.haskell.org/package/llvm-general>. - A redditor wonders whether 3 nested loops written as a list comprehension <https://www.reddit.com/r/haskell/comments/3zcjn7/optimizing_list_comprehens…> compiles into the tight machine code version of 3 nested loops. Conspicuously absent in the discussion is mention of the Vector package <https://hackage.haskell.org/package/vector> and Don Stewart's 2010 achievements of tight loop optimization <https://donsbot.wordpress.com/2010/02/21/smoking-fast-haskell-code-using-gh…> . *Quotes of the Week:* - ReinH: thanks puregreen for Lens over Tea series puregreen: is grinning all around ReinH: also thanks for not titling it "You could have written lens" johnw: <http://ircbrowse.net/day/haskell/today?id=22057773&timestamp=1451949277#t14…> ReinH, just skip to, "You could have been edwardk", it answer all other questions (Thanks to Gesh for the link.) - From HN: <https://news.ycombinator.com/item?id=10832576#up_10836690> One thing I've learned from using immutable, functional languages (Elixir) is: "Don't tell your computer what to do, tell it how to transform data." While it may seem obvious, it's been a revelation for me and it has totally transformed how I write code, and especially how I test it. - From HN: <https://news.ycombinator.com/item?id=10833240#up_10837893> FP people are nailing composability and reusability to never seen levels just in front of your eyes. You just have to keep them open to see. OOP did it at its time too, it just hit a ceiling; but there's one reason every imperative language is OOP nowadays. - From HN: <https://news.ycombinator.com/item?id=10850205#up_10855934> As someone who learned Haskell and subsequently have been writing a lot of Python, I keep a mental tally of how many of my bugs (some of which took ages to track down) would have been caught immediately by a type system like Haskell's or Idris'. I'd say it's well over half. - From HN: <https://news.ycombinator.com/item?id=10850205#up_10856141> Haskell syntax is the lingua franca when discussing anything related to data types and functional programming these days. *Videos of the Week:* - Watch LambdaConf 2015 <https://www.youtube.com/playlist?list=PLE7tQUdRKcybh21_zOg8_y4f2oMKDHpUS>, organized by John A. De Goes and professionally recorded by Confreaks <http://www.confreaks.com/>. Richard Eisenberg presented on "A practical Introduction to GADTs" <https://www.youtube.com/watch?v=6snteFntvjM>. The video recording gets love over at haskell reddit <https://www.reddit.com/r/haskell/comments/3yw2mg/lambdaconf_2015_videos/> and even a talk summary. -- Kim-Ee

1 0

wrong GHC source files
by Hong Yang 07 Jan '16

07 Jan '16

https://www.haskell.org/ghc/download_ghc_7_10_3#sources reads Source Distribution ----------------------------------------------------------------------------- The source tarballs provide everything necessary to build the compiler, interactive system, and a minimal set of libraries. For more information on building, see the building guide. ghc-7.10.3b-windows-extra-src.tar.bz2 (92 MB) ghc-7.10.3b-windows-extra-src.tar.xz (91 MB) Shouldn't the two files be as follows? ghc-7.10.3b-src.tar.bz2 ghc-7.10.3b-src.tar.xz

2 1

Pattern Matching for record syntax
by Jeon-Young Kang 07 Jan '16

07 Jan '16

Dear All. Hope your 2016 is off to a great start. I would like to get results from pattern matching or something. Here is the my code. data Person = Person {name :: String, age :: Int} names = ["tom", "sara"] -- list of names, String persons = [Person {name = "tom", age = 10}, Person {name="sara", age=9}, Person {name = "susan", age = 8}]. Is there any solution to get the age of "tom" and "sara"? I have no idea of pattern matching for this one. I've tried to use recursion, but I couldn't find any solution for list of records. Sincerely, Young

2 1

LambdaConf 2016: Call for Proposals (May 26 - 29)
by John A. De Goes 07 Jan '16

07 Jan '16

Hi all, We have officially opened the call for proposals for LambdaConf 2016 <http://lambdaconf.us/>LambdaConf 2016 <http://lambdaconf.us/>! LambdaConf is the one of the largest and most respected conferences on functional programming in the world. With more than a hundred hours of high-quality content from leading practitioners and researchers, LambdaConf is designed to take attendees' skills to the next level, whether they are just beginning or are highly experienced in the art of functional programming. Last year, Haskell content truly dominated the conference, with many workshops and well more than a full track of Haskell presentations. This year, we'd like to repeat that, as well as see strong submissions from related languages such as PureScript (PureScript Conf 2016 is co-located with and will immediately precede LambdaConf). We are looking for speakers who want to share their knowledge of the Haskell language (past, present, and future), Haskell libraries, Haskell tools, real-world Haskell use cases, and theory relevant to functional programming (such as type theory, programming language theory, dependent-types, program derivation, category theory). We welcome first-time speakers, experienced presenters, and presentations at all levels. For more information or to submit your proposal, please visit the conference home page <http://lambdaconf.us/> (http://lambdaconf.us <http://lambdaconf.us/>), or the submission form <https://www.surveymonkey.com/r/lambdaconf-2016-cfp>. Please share this CFP with anyone you think might be interested! Regards, John

1 0

Fwd: Fwd: Re: the state of Yarr?
by Dominic Steinitz 07 Jan '16

07 Jan '16

A problem with my email prevented this making it on to the mailing list. Hi Petr, I am not actively developing Yarr but I would very much like to. I keep it from bit-rotting. The problem as always is finding time. On the other hand I don't think repa is very active e.g. upgrading to vector-0.11 took a while to happen although clearly more active than me on Yarr! What I'd like is something like Python's numpy but safer and faster. If you look at the static module in the hmatrix package (https://hackage.haskell.org/package/hmatrix-0.17.0.1/docs/Numeric-LinearAlg…) you can see how type level literals can be used to prevent e.g. multiplying two inconsistent matrices together at compile time. I am sure we could do something better with either Yarr or repa (repa will currently give out of bounds errors at runtime). For reasons I don't understand (I think a bug in Haddock) the documentation does not get generated. There are examples of its use here: https://github.com/leventov/yarr/tree/master/tests. I wrote a blog using repa and Yarr here: https://idontgetoutmuch.wordpress.com/2013/08/06/planetary-simulation-with-… and compare performance. You can safely ignore the theory and need only look at "Repa Implementation", "Yarr Implementation" and "Performance". I think performance will depend on your application. I believe (but haven't confirmed) that repa will outperform Yarr on e.g grid based problems such as numerical methods for diffusions and Poisson. In the case of planets (or stars or particles) where everything is influenced by everything else then repa is a bad fit and Yarr outperforms. If your application is linear algebra, I would think that hmatrix would have what you want or could be extended to give what you want since it is LAPACK under the covers. I am very excited that you are interested in this area; it often feels very lonely. Best wishes, Dominic. On 06/01/2016 09:10, Petr Pudlák wrote: > Hi Dominic, > > what is the current state of Yarr? Is it being actively developed? Is > there some tutorial or documentation available? > > I'm deciding between repa and yarr for some linear algebra > computations. I found some references that yarr is more performant, > but I couldn't find much documentation and the hackage page [1] hasn't > indexed most modules for some reason, so there seems to be no good > place to start from. And the last commit was 9 months ago. > > [1]https://hackage.haskell.org/package/yarr > > Thank you, > Petr

4 4

long-range performance comparisons (GHC over the years)
by Johannes Waldmann 07 Jan '16

07 Jan '16

Dear Cafe, I recently noticed a performance problem due to a fusion rule not firing for a straightforward piece of code. In fact it turned out this was already fixed in HEAD, see https://ghc.haskell.org/trac/ghc/ticket/11344 https://ghc.haskell.org/trac/ghc/ticket/9848 What worries me is that such a regression had been sitting there for over a year (and did not make it to 7.10.3) and I got to thinking: What long-range performance metering do we have? So I tried to made nofib runs for some ghc-{6,7} versions http://www.imn.htwk-leipzig.de/~waldmann/etc/nofib/comparison-k.text This is slightly broken (not all tests can be built for all compilers, and I don't known how to fix this) but there are some interesting numbers already. It seems nofib programs are self-contained (not using any libraries) so they are mainly using numbers, lists, tuples, and user-defined data. This is the heart of (traditional) Haskell, so this is supposed to work really well. The table shows that there are a lot of benchmarks where performance has been increasing. That's good. But not for all! We should certainly ignore all runtimes that are absolutely small. I think it is most interesting to look allocation numbers. A few examples from this list: * exp3_8 (allocation goes up 50 % from 6.* to 7.*) this is addition of Peano numbers. * gcd (allocation goes up 20 % from 7.8 to 7.10) using Integers, tuples (for extended Euclid), lists (for control) * tak (runtime goes up 20 % from 7.6 to 7.8) the plain Takeuchi function, just Int and recursion (it should not allocate at all?) (and I confirmed these by manually running them for more inputs, all measurements done on debian on x86_64 X5365, ghc-6.* installed from binary packages, ghc-7.* built from source) So, can this be explained? Improved? I think we should resist the temptation to change these benchmarks (using seq and ! and Int# and whatnot) Assuming nofib contains typical code, it is the task of the compiler to handle it well. In case you're wondering about my motivation - this was prompted by teaching, I wanted to show that ghc creates efficient code (by fusion) - but it's not just for the show, I generally try to believe in what I teach and I do rely on this for my real code. (Well, by definition, "real" for me might still be "academic" for others...) - Johannes.

3 3

ideas for extending 'tensor'
by Petr Pudlák 06 Jan '16

06 Jan '16

Hi Nicola, I was very excited to see your type-safe tensor package. Are the sources available somewhere for contributing? I'd be interested in trying to extend it to use unboxed vectors, or perhaps even repa or yarr. Are there any future plans like that? Also it'd be interesting to add the distinction between covariant and contravariant indices, although this would be most likely a major change. Or perhaps it'd be possible to add it just as some kind of a wrapper. All the best, Petr

1 1

Regarding GSoC 2016
by Abhijit Patel 06 Jan '16

06 Jan '16

I am Abhijit Patel, B.Tech second year student from Dhirubhai Ambani Institute of Information and Communication Technology (DA-IICT) . I have learnt haskell from the learnyouahaskell.com and I was informed that the tasks for GSoC .I need some guidance and someone who can give me some tasks to raise my level to start contributing to the haskell community.

2 1

FRP : Best way to save signal history if the program needs to temporarily terminate?
by Zans Tangle 06 Jan '16

06 Jan '16

Hi guys, so I'm getting my head around FRP, and the theory is starting to make sense (just seen Conal Elliott's explanation of the original formulation and it was very illuminative). Overall I'm finding signals to be a really nice level of abstraction to reason about my code state. However I'm a little bit stuck on something: lets say I want to switch off the program, but I want it to save the signal history so that I can resume where I left off when I switch it back on. Is there a ... simple.. way to do it? Because at the moment I'm thinking of something along the lines of "build an SQL schema that matches the semantics of each FRP signal, and then build functions to translate between signal and SQL when needed". And at this precise instant I don't really feel too excited about implementing Signal-to-SQL translation from scratch (and I'm not even completely sure what sort of SQL schema would be needed to support higher-order FRP either), so I was wondering if anything like that exists already? Or even something as simple as storing the signal history in a file and just parsing it to recover it? Zans

3 2

the state of Yarr?
by Petr Pudlák 06 Jan '16

06 Jan '16

Hi Dominic, what is the current state of Yarr? Is it being actively developed? Is there some tutorial or documentation available? I'm deciding between repa and yarr for some linear algebra computations. I found some references that yarr is more performant, but I couldn't find much documentation and the hackage page [1] hasn't indexed most modules for some reason, so there seems to be no good place to start from. And the last commit was 9 months ago. [1] https://hackage.haskell.org/package/yarr Thank you, Petr

1 0

hscolour color set for white/light background?
by Conal Elliott 05 Jan '16

05 Jan '16

Does anyone have handy an hscolour ColourPrefs for use with a white/light background? The defaultColourPrefs <https://hackage.haskell.org/package/hscolour-1.23/docs/Language-Haskell-HsC…> look okay with a dark background but not light. Thanks, - Conal

1 0

Spurious memory leak example from the wiki
by Christopher Allen 05 Jan '16

05 Jan '16

I can't get the two examples (sum/product) in: https://wiki.haskell.org/Memory_leak#Holding_a_reference_for_a_too_long_time to behave differently under O2 or O0. Same profile report each time. Have changes to prelude (FTP? Rewrite rules/build stuff for folds?) made these do the same thing? The foldl/foldl' examples behave the same as you might expect. (216mb vs. 1mb of heap) --- Chris Allen

2 2

Compose Conference Call for Participation [NYC, Feb 4-5]
by Gershom B 04 Jan '16

04 Jan '16

=============================================== Call for Participation Compose Conference 2016 February 4-5, 2016 New York, NY http://www.composeconference.org/ =============================================== The practice and craft of functional programming :: Conference Compose is a conference for typed functional programmers, focused specifically on Haskell, OCaml, F#, SML, and related technologies. Typed functional programming has been taken up widely, by industry and hobbyists alike. For many of us it has renewed our belief that code should be beautiful, and that programming can be as enjoyable as it is practical. Compose is about bringing together functional programmers of all levels of skill and experience — from technical leads to novices, and from long-time hackers to students just getting started. It will feature a keynote by Eugenia Cheng on her work popularizing mathematics, two days of great talks, and plans are underway for a weekend hackathon/unconference. * Invited Talks: Eugenia Cheng: How to Bake 'How to Bake Pi': reflections on making abstract mathematics palatable * Local Information (venue): http://www.composeconference.org/2016/ * Accepted Talks and Tutorials Aditya Siram: FLTKHS - Easy Native GUIs in Haskell, Today! Austin Seipp: Cryptography and Verification with Cryptol Kenneth Foner: 'There and Back Again' and What Happened After Krzysztof Cieslak: Ionide and state of F# open source environment Leonid Rozenberg: The Intersection of Machine Learning, Types and Testing Luite Stegeman: Fun with GHCJSi Markus Mottl: AD-OCaml - Parallel Algorithmic Differentiation for OCaml Mindy Preston: Composing Network Operating Systems Niki Vazou: Liquid Types for Haskell Paulmichael Blasucci: (Nearly) Everything You Ever Wanted to Know About F# Active Patterns but were Afraid to Ask Rachel Reese: Chaos Testing at Jet Riccardo Terrell: Functional Reactive Programming for Natural User Interface Stephen Compall: Add a type parameter! One 'simple' design change, a panoply of outcomes Stephanie Weirich: Dynamic Typing in GHC Tikhon Jelvis: Analyzing Programs with Z3 Zvonimir Pavlinovic, Tim King and Thomas Wies: Improving Type Error Localization for Languages with Type Inference * Full abstracts: http://www.composeconference.org/2016/speakers/ * Registration: http://composeconference.eventbrite.com * Follow @composeconf on twitter for news: https://twitter.com/composeconf * On freenode irc, chat will fellow attendees at #composeconference * Corporate sponsorships are welcome. Current sponsors list forthcoming. * Policies (diversity and anti-harassment): http://www.composeconference.org/conduct * Email us with any questions at info(a)composeconference.org * Please forward this announcement to interested parties and lists.

1 0

Haskell popularity
by Henk-Jan van Tuyl 03 Jan '16

03 Jan '16

L.S., Haskell scores quite high on GitHub and Stack Overflow, see: http://redmonk.com/sogrady/2015/07/01/language-rankings-6-15/ Regards, Henk-Jan van Tuyl -- 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://folding.stanford.edu/ http://Van.Tuyl.eu/ http://members.chello.nl/hjgtuyl/tourdemonad.html Haskell programming --

5 4

wxHaskell + GHCi
by Henk-Jan van Tuyl 03 Jan '16

03 Jan '16

L.S., For people who gave up on wxHaskell in the past, because wxHaskell didn't run (properly) in GHCi: I just found out, that wxHaskell programs run properly in GHCi on Windows, if you use the newest wxHaskell plus GHC 7.10.3 (both the 32 bit and the 64 bit version). Regards, Henk-Jan van Tuyl -- 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://folding.stanford.edu/ http://Van.Tuyl.eu/ http://members.chello.nl/hjgtuyl/tourdemonad.html Haskell programming --

3 5

For one cabal'ised library: running specific benchmarks & tests, and obtaining multiple Travis reports
by Rob Stewart 03 Jan '16

03 Jan '16

Hi, Three questions: 1) running specific criterion benchmark groups, 2) running specific test-framework test groups, and 3) getting multiple Travis CI reports for one cabal'ised library. 1. Running specific criterion benchmark groups Given this benchmark harness: main = defaultMain [ bgroup "fib" [ bench "1" $ whnf fib 1 , bench "5" $ whnf fib 5 , bench "9" $ whnf fib 9 , bench "11" $ whnf fib 11 ] ] How do I run one specific group benchmar, or a specific benchmark in a specific group? Can I run: $ cabal bench "fib" or $ cabal bench "fib/1" 2. Running specific test-framework test groups Given this test harness with test-framework: main = defaultMain tests tests = [ testGroup "Sorting-Group-1" [ testProperty "sort1" prop_sort1, testProperty "sort2" prop_sort2, testProperty "sort3" prop_sort3 ], testGroup "Sorting-Group-2" [ testProperty "sort4" prop_sort4, testProperty "sort5" prop_sort5, testProperty "sort6" prop_sort6, testCase "sort7" test_sort7, testCase "sort8" test_sort8 ] ] Can I run: $ cabal test "Sorting-Group-1" or $ cabal test "Sorting-Group-1/sort3" 3. Separating cabal'ised project to separate Travis CI badges For my current project, I get one Travis CI report for all of HUnit and QuikCheck tests I write for a cabal'ised library expressed with test-framework. For example, if 108 tests fail I get one Travis CI report saying #108 failing tests, and I get one Travis CI badge of the form: https://travis-ci.org/<my_username>/<library_name>.png?branch=master What I'd really like is to retrieve multiple Travis CI reports and multiple Travis CI badges for one Haskell libray. E.g. API tests: passing (with a URL for a green badge). Parser tests: #108 failing (with a URL for a red badge). Messaging tests: #16 failing (with a URL for a red badge). How could I refactor my test groups so that Travis CI will provide me multiple reports for one cabal'ised project? Thanks! -- Rob Stewart

2 1

Month in haskell-ide-engine December 2015
by Alan & Kim Zimmerman 01 Jan '16

01 Jan '16

Welcome Haskell IDE Engine (future) users, [also available online at https://github.com/haskell/haskell-ide-engine/blob/master/docs/Report-2015-…] Haskell IDE Engine progress report for December 2015. What is Haskell IDE Engine? Not an IDE, still no release, it is a work in progress. It is a common point to join together the effort of integrating tools into an IDE and the effort of writing tools for an IDE, by providing an API in the middle that each of these parties can work from and to. Important developments This month has been mostly about turning ideas into practice, and dealing with the details that come out when things become concrete. The more concrete things we have are: 1. Auto-generated API documentation (@cocreature) One of the principles of HIE is that each plugin/command provides a PluginDescriptor documenting the commands it provides, parameters they take and return types. Moritz Kiefer has created a module[1] to take this information and generate API documentation[2]. The information is present, but help with styling / presentation will be gladly accepted. [1] https://github.com/haskell/haskell-ide-engine/tree/master/hie-docs-generator [2] https://haskell.github.io/haskell-ide-engine/ 2. Leksah context menu (@jpmoresmau) JP Moresmau has extended the Leksah integration[3][4] to now provide a context-specific menu providing available HIE commands. This includes the ability to invoke HaRe to do refactorings. To enable this we now have a specific hie-base[5] module with just the basic types which can be included in the IDE side if it is fortunate enough to use haskell. [3] https://github.com/JPMoresmau/leksah/tree/hie_integration [4] https://github.com/JPMoresmau/leksah-server/tree/hie_integration [5] https://github.com/haskell/haskell-ide-engine/tree/master/hie-base 3. Deeper Emacs integration (@cocreature) The Emacs integration uses the PluginDescriptor to generate a set of elisp functions corresponding to each plugin command. The macro generating these has been extended to populate the docstrings for these. It also handles the HieDiff return type which means it can apply the changes from a HaRe refactoring, or any other plugin generating a diff. It prompts interactively for any additional parameters required. 4. New plugins applyrefact is a wrapper around Matthew Pickering's library to apply hlint changes to source code. egasync is an example wrapper showing how a plugin can launch its own process in the server and stream output from it back to the IDE, if the transport used supports this. Otherwise the transport will batch it up when a request is received for the output. Current project focus The current project focus is still on getting our collective heads straight on what actually needs to be done, and providing working integrations to at least 2 IDEs to get a better feel for what is needed. Both of these are well in hand, and if anyone would like to join in the discussion happens via the github issue tracker and docs section of the project, as well as IRC at #haskell-ide-engine on freenode. Issues closed in December Decide on matching an existing IDE protocol or designing a new one #2 Representation of arbitrary types for a plugin #14 Plugin function definition #16 Add QuickCheck tests for FromJSON / ToJSON instances #48 Check PluginDescriptor on loading #52 Add a signal handler to flush logs on exit #58 Plugin startup / private data #83 Create a diff type #95 Replace logging package #112 Split between haskell-ide-engine and haskell-plugin-api #118 Document existance of module-management package and ghc-vis #124 Provide ghc-modi transport? #125 Sort out ghc-mod session management #127 Git integration #128 apply-refact plugin #131 emacs: how to run hie with arguments / logging #134 Change HieDiff to represent a standard patch format #138 Pull requests merged in December Detect plugin param name collisions #115 Bring in a diff type, and introduce semantic types #116 New logger #120 Rework api split #122 (elisp) Add log of hie process input / output #123 Ghc mod session #130 Apply refact plugin #133 Ghc mod find #135 Plugin state #137 Change HieDiff to use a patch format #139 Hare context #141 Initial example async process plugin #143 Base split #144 Support more commands #145 Add tests for hie-create-command #146 Add integration test for hie-hare-rename #147 Move to a plugin/command url scheme #148 Documentation generator #149 Contributors active in December Alan Zimmerman, Daniel Gröber, JP Moresmau, Michael Sloan, Moritz Kiefer, Tobias G. Waaler Contributing Haskell IDE Engine needs volunteers like any other open source project. For more information see: https://github.com/haskell/haskell-ide-engine Also drop by our IRC channel: #haskell-ide-engine at irc.freenode.net. Thanks!

1 0