- Haskell-Cafe - Haskell.org

Munich Haskell Meeting, 2016-05-30 @ 19:30 Max Emanuel Brauerei
by Christian Neukirchen 27 May '16

27 May '16

Dear all, Next week, our monthly Munich Haskell Meeting will take place again on Monday, May 30 at *Max Emanuel Brauerei* at 19h30. For details see here: http://chneukirchen.github.io/haskell-munich.de/dates.html **Please note the changed location!** If you plan to join, please add yourself *quickly* 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-may-2016/ Everybody is welcome! cu, -- Christian Neukirchen <chneukirchen(a)gmail.com> http://chneukirchen.org

1 0

Hackage (partially) down?
by Bardur Arantsson 27 May '16

27 May '16

Hi all, I'm getting Error 503 Connection timed out Connection timed out Guru Mediation: Details: cache-ams4123-AMS 1464323906 827600523 Varnish cache server when trying to browse Hackage this morning. Anyone else having the same problem? (downforeveryoneorjustme.com says that "it's just me", so I'm guessing this is some sort of CDN issue?) Regards,

4 3

Re: [Haskell-cafe] Haskell newb trying to write a basic program.
by Erik Rantapaa 27 May '16

27 May '16

Have a look at the HaskellForMaths package. Using the Math.Algebra.Group.PermutationGroup module the expression `elts (_A n)` will return all the permutations of A_n. On Thursday, May 26, 2016 at 6:39:52 PM UTC-5, Blake Sims wrote: > > Hi, > > I am a newb to Haskell and programming in general, but I was trying to > write a basic program to find the elements for the alternating group for > any n. > > For the symmetric group I wrote something like this > > input Data.List > > symmetric n = permutations ([1..n]) > > What if I just want to find the even permutations? What is the quick and > dirty way of doing this? I was looking at the package Data.Matrix and > messing around with permutation matrices, but there has got to be a quicker > and easier way of doing it. I am skimming the book learn you a Haskell, but > my attention span is pretty short so if someone could direct me in the > right direction I'd be much obliged. >

1 0

GHC 8.0.1 Compile time regression + Trac ticket privileges
by aditya siram 26 May '16

26 May '16

[x-post from Reddit reply] Thanks so much for all the hard work! Unfortunately I have a compile time performance regression to report on my FLTKHS <https://github.com/deech/fltkhs> library. I also don't have a minimal example. There is a demo that took about 15 seconds compile and link in 7.10.3, but with no changes now takes over a minute in 8.0.1. I've reproduced this across machines and operating systems. Since there was interest expressed in using this example as a benchmark if any GHC devs are still willing to help, I'm willing to walk them through getting the library set up etc. It's not a long process. The tip of my Github branch has been updated to build with GHC 8.0.1. I made myself a Trac account but apparently I don't have Ticket privileges so it won't let me create one. My username is 'deech'. Thanks! -deech

2 2

A Java bytecode interpreter written in Haskell
by Erik Dominikus 26 May '16

26 May '16

(Please keep expectations low for now; this is just a weekend project.) I have written, in Haskell, something that aspires to be a Java Virtual Machine (but I don't call it a JVM yet as it doesn't fully comply with the spec). The code is available here: https://github.com/edom/haji This is similar to Frege [3], but while Frege aims to run a variant of Haskell on Java, this project tries the other direction: running a subset of Java on Haskell. Thanks. Best, Erik Some related stuffs: [1] https://github.com/MateVM/MateVM [2] https://hackage.haskell.org/package/hs-java [3] https://github.com/Frege/frege [4] https://wiki.haskell.org/GHC:FAQ#Why_isn.27t_GHC_available_for_.NET_or_on_t… [5] https://github.com/levans/Open-Quark

3 4

Interacting with Java in GHCVM
by Rahul Muttineni 25 May '16

25 May '16

Hi Haskell-Cafe, I've been working on a JVM backend for GHC [1] and I took some time to flesh out a design for the Java FFI [2] which will pretty much decide whether the project will be useful or not. I would love feedback from the community on how to improve the design or requests for important interop features that I have neglected. Thanks, Rahul Muttineni [1] http://github.com/rahulmutt/ghcvm [2] https://gist.github.com/rahulmutt/355505bce57c7c2cffd7d4cf5edddad4

4 8

Example of FunBind without wrapping AbsBind?
by Robin Palotai 25 May '16

25 May '16

I was playing with the AST's typechecked tree, and found some examples of the subject, but can't tell what is the rule for that to occur. It was a local binding. Do you have a hint and/or a minimal example? Thanks! Robin

1 0

ANN: new #haskell-atom channel, Atom setup doc
by Simon Michael 24 May '16

24 May '16

Hi all, Recently I helped a newcomer set up Haskell and Atom (the text editor/IDE - not the embedded systems DSL), and also for the first time succeeded in getting a "modern IDE experience" working with my own projects. I've saved my notes so far - I hope you'll also find them useful: https://github.com/simonmichael/haskell-atom-setup In the process I found some issues, looked for help in many places, and wished the #haskell-atom IRC channel existed. So I've started it: #haskell-atom on Freenode I'm an Emacs man, but I try all the available Haskell IDEs periodically. Atom is the first one where I've succeeded in getting inline error reporting working, and it's the only one I could recommend to a new programmer or a mainstream IDE lover right now. So I think this channel is worth having, and will grow. All welcome! Best, -Simon

2 2

1st CfP: IFL 2016 (28th Symposium on Implementation and Application of Functional Languages)
by publicityifl＠gmail.com 24 May '16

24 May '16

Hello, Please, find below the first call for papers for IFL 2016. Please forward these to anyone you think may be interested. Apologies for any duplicates you may receive. best regards, Jurriaan Hage Publicity Chair of IFL --- IFL 2016 - Call for papers 28th SYMPOSIUM ON IMPLEMENTATION AND APPLICATION OF FUNCTIONAL LANGUAGES - IFL 2016 KU Leuven, Belgium In cooperation with ACM SIGPLAN August 31 - September 2, 2016 https://dtai.cs.kuleuven.be/events/ifl2016/ Scope The goal of the IFL symposia is to bring together researchers actively engaged in the implementation and application of functional and function-based programming languages. IFL 2016 will be a venue for researchers to present and discuss new ideas and concepts, work in progress, and publication-ripe results related to the implementation and application of functional languages and function-based programming. Peer-review Following the IFL tradition, IFL 2016 will use a post-symposium review process to produce the formal proceedings. All participants of IFL 2016 are invited to submit either a draft paper or an extended abstract describing work to be presented at the symposium. At no time may work submitted to IFL be simultaneously submitted to other venues; submissions must adhere to ACM SIGPLAN's republication policy: http://www.sigplan.org/Resources/Policies/Republication The submissions will be screened by the program committee chair to make sure they are within the scope of IFL, and will appear in the draft proceedings distributed at the symposium. Submissions appearing in the draft proceedings are not peer-reviewed publications. Hence, publications that appear only in the draft proceedings are not subject to the ACM SIGPLAN republication policy. After the symposium, authors will be given the opportunity to incorporate the feedback from discussions at the symposium and will be invited to submit a revised full article for the formal review process. From the revised submissions, the program committee will select papers for the formal proceedings considering their correctness, novelty, originality, relevance, significance, and clarity. The formal proceedings will appear in the International Conference Proceedings Series of the ACM Digital Library. Important dates August 1: Submission deadline draft papers August 3: Notification of acceptance for presentation August 5: Early registration deadline August 12: Late registration deadline August 22: Submission deadline for pre-symposium proceedings August 31 - September 2: IFL Symposium December 1: Submission deadline for post-symposium proceedings January 31, 2017: Notification of acceptance for post-symposium proceedings March 15, 2017: Camera-ready version for post-symposium proceedings Submission details Prospective authors are encouraged to submit papers or extended abstracts to be published in the draft proceedings and to present them at the symposium. All contributions must be written in English. Papers must use the new ACM two columns conference format, which can be found at: http://www.acm.org/publications/proceedings-template For the pre-symposium proceedings we adopt a 'weak' page limit of 12 pages. For the post-symposium proceedings the page limit of 12 pages is firm. Authors submit through EasyChair: https://easychair.org/conferences/?conf=ifl2016 Topics IFL welcomes submissions describing practical and theoretical work as well as submissions describing applications and tools in the context of functional programming. If you are not sure whether your work is appropriate for IFL 2016, please contact the PC chair at tom.schrijvers(a)cs.kuleuven.be. Topics of interest include, but are not limited to: - language concepts - type systems, type checking, type inferencing - compilation techniques - staged compilation - run-time function specialization - run-time code generation - partial evaluation - (abstract) interpretation - metaprogramming - generic programming - automatic program generation - array processing - concurrent/parallel programming - concurrent/parallel program execution - embedded systems - web applications - (embedded) domain specific languages - security - novel memory management techniques - run-time profiling performance measurements - debugging and tracing - virtual/abstract machine architectures - validation, verification of functional programs - tools and programming techniques - (industrial) applications Peter Landin Prize The Peter Landin Prize is awarded to the best paper presented at the symposium every year. The honored article is selected by the program committee based on the submissions received for the formal review process. The prize carries a cash award equivalent to 150 Euros. Programme committee Chair: Tom Schrijvers, KU Leuven, Belgium - Sandrine Blazy, University of Rennes 1, France - Laura Castro, University of A Coru√±a, Spain - Jacques, Garrigue, Nagoya University, Japan - Clemens Grelck, University of Amsterdam, The Netherlands - Zoltan Horvath, Eotvos Lorand University, Hungary - Jan Martin Jansen, Netherlands Defence Academy, The Netherlands - Mauro Jaskelioff, CIFASIS/Universidad Nacional de Rosario, Argentina - Patricia Johann, Appalachian State University, USA - Wolfram Kahl, McMaster University, Canada - Pieter Koopman, Radboud University Nijmegen, The Netherlands - Shin-Cheng Mu, Academia Sinica, Taiwan - Henrik Nilsson, University of Nottingham, UK - Nikolaos Papaspyrou, National Technical University of Athens, Greece - Atze van der Ploeg, Chalmers University of Technology, Sweden - Matija Pretnar, University of Ljubljana, Slovenia - Tillmann Rendel, University of T√ºbingen, Germany - Christophe Scholliers, Universiteit Gent, Belgium - Sven-Bodo Scholz, Heriot-Watt University, UK - Melinda Toth, Eotvos Lorand University, Hungary - Meng Wang, University of Kent, UK - Jeremy Yallop, University of Cambridge, UK Venue The 28th IFL will be held in association with the Faculty of Computer Science, KU Leuven, Belgium. Leuven is centrally located in Belgium and can be easily reached from Brussels Airport by train (~15 minutes). The venue in the Arenberg Castle park can be reached by foot, bus or taxi from the city center. See the website for more information on the venue.

1 0

Dev/tools/git/Haskell role in London
by Don Stewart 24 May '16

24 May '16

https://donsbot.wordpress.com/2016/05/24/haskell-devtoolsgit-role-at-standa… I have a new role at SCB this time in the "Modelling Infrastructure" team to work on our Haskell-based continuous integration and testing system on top of git. This is a London role. More details in the linked post.

1 0

Stack build with GHC 8?
by David Turner 24 May '16

24 May '16

Hi, My name appears in the Stackage GHC 8 mega-issue [ https://github.com/fpco/stackage/issues/1476] and I'd like to upgrade my packages. I suspect it's just a case of relaxing the upper bound on base to <4.10 but I'd quite like to check that this does, in fact, work. However I'm not sure how to go about doing this since there don't yet seem to be any stackage snapshots that use GHC 8. What's the best way to get around this? Cheers, David

2 1

[ANNOUNCE] GHC 8.0.1 is available!
by Ben Gamari 23 May '16

23 May '16

=============================================== The Glasgow Haskell Compiler -- version 8.0.1 =============================================== The GHC developers are very pleased to announce the release of the first new super-major version of our Haskell compiler in six years, GHC 8.0.1. This release features dozens of exciting developments including, * A more refined interface for implicit call-stacks, allowing libraries to provide more helpful runtime error messages to users * The introduction of the DuplicateRecordFields language extension, allowing multiple record types to declare fields of the same name * Significant improvements in error message readability and content, including facilities for libraries to provide custom error messages, more aggressive warnings for fragile rewrite rules, and more helpful errors for missing imports * A rewritten and substantially more thorough pattern match checker, providing more precise exhaustiveness checking in GADT pattern matches * More reliable debugging information including experimental backtrace support, allowing better integration with traditional debugging tools * Support for desugaring do-notation to use Applicative combinators, allowing the intuitive do notation to be used in settings which previously required the direct use of Applicative combinators * The introduction of Strict and StrictData language extensions, allowing modules to be compiled with strict-by-default evaluation of bindings * Great improvements in portability, including more reliable linking on Windows, a new PPC64 code generator, support for the AIX operating system, unregisterised m68k support, and significant stabilization on ARM targets * A greatly improved user's guide, with beautiful and modern PDF and HTML output * Introduction of type application syntax, reducing the need for proxies * More complete support for pattern synonyms, including record pattern synonyms and the ability to export patterns "bundled" with a type, as you would a data constructor * Support for injective type families and recursive superclass relationships * An improved generics representation leveraging GHC's support for type-level literals * The TypeInType extension, which unifies types and kinds, allowing GHC to reason about kind equality and enabling promotion of more constructs to the type level * ...and more! A more thorough list of the changes included in this release can be found in the release notes, https://downloads.haskell.org/~ghc/8.0.1/docs/html/users_guide/8.0.1-notes.… As always, we have collected various points of interest for users of previous GHC releases on the GHC 8.0 migration page, https://ghc.haskell.org/trac/ghc/wiki/Migration/8.0 Please let us know if you encounter anything missing or unclear on this page. This release is the culmination of nearly eighteen months of effort by over one hundred contributors. We'd like to thank everyone who has contributed code, bug reports, and feedback over the past year. It's only because of their efforts that GHC continues to evolve. How to get it ~~~~~~~~~~~~~ Both the source tarball and binary distributions for a wide variety of platforms are available at, http://www.haskell.org/ghc/ Background ~~~~~~~~~~ Haskell is a standardized lazy functional programming language. The Glasgow Haskell Compiler (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. Supported Platforms ~~~~~~~~~~~~~~~~~~~ The list of platforms we support, and the people responsible for them, can be found on the GHC wiki http://ghc.haskell.org/trac/ghc/wiki/Platforms Ports to other platforms are possible with varying degrees of difficulty. The Building Guide describes how to go about porting to a new platform: http://ghc.haskell.org/trac/ghc/wiki/Building Developers ~~~~~~~~~~ We welcome new contributors. Instructions on getting started with hacking on GHC are available from GHC's developer site, http://ghc.haskell.org/trac/ghc/ Community Resources ~~~~~~~~~~~~~~~~~~~ There are mailing lists for GHC users, develpoers, and monitoring bug tracker activity; to subscribe, use the web interfaces at http://mail.haskell.org/cgi-bin/mailman/listinfo/glasgow-haskell-users http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-devs http://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 Some GHC developers hang out on the #ghc and #haskell of the Freenode IRC network, too: http://www.haskell.org/haskellwiki/IRC_channel Please report bugs using our bug tracking system. Instructions on reporting bugs can be found here: http://www.haskell.org/ghc/reportabug

5 4

Help moving a bounds check into a case branch
by David Feuer 23 May '16

23 May '16

Sorry for the terrible subject line, but I'm a but stuck here. A couple days ago I overhauled Data.Sequence.splitAt, greatly improving its performance. You can see the new implementation at https://github.com/haskell/containers/blob/e8b1f664a631e3795dfd14f2d8c2b39c… . There's one spot where I'm still stuck, however. Much like the original implementation, I check that the splitting index is before the end of the sequence (to ensure correctness). I go further, in fact, checking that the splitting index is positive, in order to avoid allocating a new tree-top in a trivial split. Logically, this check should be moved into the Deep case branch in splitTreeE, to avoid pattern matching on the top of the tree twice and performing redundant comparisons. However, when I make that move, the split/append benchmark gets worse. When I looked at the Core, it seemed that I confused GHC somehow. I ended up with a join point taking an extra argument that it totally ignored. I can fix that benchmark by marking the splitTreeMiddleE function INLINE, but then the zipWith benchmark went screwy. Unless I can get non-fragile results, I'm just going to accept the redundant case match. If anyone has any ideas, please let me know. Thanks, David Feuer

1 0

Re: [Haskell-cafe] TDNR without new operators or syntax changes
by Jeremy . 22 May '16

22 May '16

Yes, that it indeed was I meant. AntC seems to be replying to a much more complicated/invasive proposal than what I had intended, apologies if I wasn't clear. (I see in retrospect that I may have misunderstood the original TDNR proposal, understandably leading to confusion.) 1. If the compiler encounters a term f a, and there is more than one definition for f in scope (after following all of the usual rules for qualified imports); 2. And exactly one of these definitions matches the type of a (or the expected type of f if given); 3. Then this is the definition to use. That is all, although point 2 could be extended to consider the return type of f or other arguments as well. Even with the extension on, it would have no effect on programs which compile without it. This has nothing to do with ORF, which relies on magic type classes (although there is some overlap in what it can achieve). The primary use-case I had in mind is disambiguating name clashes between local and/or unqualified imports. Cross-posting to cafe and libraries as this doesn't seem to have attracted a lot of interest in users. Maybe it's just a boring proposal, maybe I didn't post it to the right list.

3 2

Going insane over overlapping instances
by Brian Hurt 22 May '16

22 May '16

This is driving me nuts. So I have a type class HasStructParser I've defined. Details are irrelevant except that if you have HasStructParser defined, then ToJSON is also defined. So I have: instance HasStructParser s => ToJSON s where ... But now, any type that defines ToJSON any other way causes an Overlapping Instances error to happen- the conflict being between the real ToJSON implementation and the one deriving from HasStructParser- this despite the fact that there is no implementation for HasStructParser for the given type. Now, I don't want to allow Overlapping Instances because if there are *real* overlapping instances, I want that to be an error. For instance, if a structure did implement HasStructParser and some other implementation of ToJSON, I want to know. I suppose I could go: newtype JSON a = JSON a instance HasStructParser s => ToJSON (JSON s) where ... But this strikes me as being ugly- now I have to add pointless JSON constructors everywhere I want to convert to (or from) JSON. And this also pollutes my type signatures all over the place- now I can't write a servant endpoint type like: :<|> "foo" :> "bar" :> Get '[JSON] [Foo] I have to write: :<|> "foo" :> "bar" :> Get '[JSON] [JSON Foo] And, of course, if I want to have multiple different types of outputs, now we're off to the races. So my question is, is there a way to do this without throwing the baby out with the bath water (turning on overloaded instances) or being seriously ugly? Or am I just screwed? Brian

2 1

Representation of 3-D objects in non-continuous space
by Michael Litchard 22 May '16

22 May '16

I've been poking at the problem that I've talked about in the following threads. https://groups.google.com/forum/#!searchin/haskell-cafe/michael$20litchard|… https://groups.google.com/forum/#!searchin/haskell-cafe/michael$20litchard|… And my misguided conclusions here https://groups.google.com/forum/#!topic/haskell-cafe/PMtYhVQ5nNQ I'm trying to write a clone in haskell of the space-system implemented in http://swmud.org. The biggest error in my thinking so far is assuming I could do without spatial extent. Nope, these objects in space will have to have spatial extent. So no octree for me. The advice and comments from the first two threads prompted me to investigate R-trees. I could only find specifics about how to describe 2-D. Until I found this paper on layered R-Trees. http://www.isprs.org/proceedings/XXXIII/congress/part4/1216_XXXIII-part4.pdf This looks like what I want. Here's my re-formulation of the criteria: (1) Objects in space will be either ships that can move or stationary things like non-moving game-controlled ships, space-stations , moons and planets. (2) Objects will have spatial extent. Will use bounding volumes to help determine collisions. (3) Space is non-continuous (4) Movement happens by setting a destination vector and a speed. There's no steering exactly, but you can change destination while moving, slow down or stop suddenly. (5) Represent this space with a layered R-tree, This tree will at most have say, 200-300 objects in it, most of which could be moving around in this space. It's the number of objects that have me wondering if layered r-tree might be too heavy-weight. If so, Any links to R-tree variants that include bounding volumes? I could only find ones with bounding boxes.

1 1

ANNOUNCE: testbench-0.1.0.0
by Ivan Lazar Miljenovic 22 May '16

22 May '16

I've just released a new library onto Hackage that aims to help you writing comparison-oriented benchmarks by: a) reducing the duplication found when using criterion directly b) let you test your benchmarked values/functions to ensure that they have the same result/satisfy a given predicate c) provide more comparison-oriented output I've written more about it here: https://ivanmiljenovic.wordpress.com/2016/05/23/test-your-benchmarks/ Or you could go straight to the Hackage page here: http://hackage.haskell.org/package/testbench -- Ivan Lazar Miljenovic Ivan.Miljenovic(a)gmail.com http://IvanMiljenovic.wordpress.com

1 0

Haskell Meetup group in Delhi, India
by Anupam Jain 21 May '16

21 May '16

Hi all, I just started a meetup group for Haskellers in and around Delhi NCR, India. The plan is to organise regular (monthly) meetups, talks, workshops etc for Haskell / FP enthusiasts at all skill levels. Anyone interested is welcome to join at - http://meetu.ps/c/2K4ft/FT8H/f. Also, since we are just getting started, the best way to help right now would be to spread the word! Thanks, Anupam Jain

1 0

ANN: stack-1.1.2
by Emanuel Borsboom 20 May '16

20 May '16

Release notes: - Official FreeBSD binaries are now available <http://docs.haskellstack.org/en/stable/install_and_upgrade/#freebsd> ( #1253 <https://github.com/commercialhaskell/stack/issues/1253>). Major changes: - Extensible custom snapshots implemented. These allow you to define snapshots which extend other snapshots. See #863 <https://github.com/commercialhaskell/stack/issues/863>. Local file custom snapshots can now be safely updated without changing their name. Remote custom snapshots should still be treated as immutable. Behavior changes: - stack path --compiler was added in the last release, to yield a path to the compiler. Unfortunately, --compiler is a global option that is useful to use with stack path. The same functionality is now provided by stack path --compiler-exe. See #2123 <https://github.com/commercialhaskell/stack/issues/2123> - For packages specified in terms of a git or hg repo, the hash used in the location has changed. This means that existing downloads from older stack versions won’t be used. This is a side-effect of the fix to #2133 <https://github.com/commercialhaskell/stack/issues/2133> - stack upgrade no longer pays attention to local stack.yaml files, just the global config and CLI options. #1392 <https://github.com/commercialhaskell/stack/issues/1392> - stack ghci now uses :add instead of :load, making it potentially work better with user scripts. See #1888 <https://github.com/commercialhaskell/stack/issues/1888> Other enhancements: - Grab Cabal files via Git SHA to avoid regressions from Hackage revisions #2070 <https://github.com/commercialhaskell/stack/pull/2070> - Custom snapshots now support ghc-options. - Package git repos are now re-used rather than re-cloned. See #1620 <https://github.com/commercialhaskell/stack/issues/1620> - DESTDIR is filtered from environment when installing GHC. See #1460 <https://github.com/commercialhaskell/stack/issues/1460> - stack haddock now supports --hadock-arguments. See #2144 <https://github.com/commercialhaskell/stack/issues/2144> - Signing: warn if GPG_TTY is not set as per man gpg-agent Bug fixes: - Now ignore project config when doing stack init or stack new. See #2110 <https://github.com/commercialhaskell/stack/issues/2110> - Packages specified by git repo can now have submodules. See #2133 <https://github.com/commercialhaskell/stack/issues/2133> - Fix of hackage index fetch retry. See re-opening of #1418 <https://github.com/commercialhaskell/stack/issues/1418#issuecomment-2176338…> - HPack now picks up changes to filesystem other than package.yaml. See #2051 <https://github.com/commercialhaskell/stack/issues/2051> - “stack solver” no longer suggests —omit-packages. See #2031 <https://github.com/commercialhaskell/stack/issues/2031> - Fixed an issue with building Cabal’s Setup.hs. See #1356 <https://github.com/commercialhaskell/stack/issues/1356> - Package dirtiness now pays attention to deleted files. See #1841 <https://github.com/commercialhaskell/stack/issues/1841> - stack ghci now uses extra-lib-dirs and extra-include-dirs. See #1656 <https://github.com/commercialhaskell/stack/issues/1656> - Relative paths outside of source dir added via qAddDependentFile are now checked for dirtiness. See #1982 <https://github.com/commercialhaskell/stack/issues/1982> - Signing: always use --with-fingerprints ------------------------------ Thanks to all our contributors for this release: - Benno Fünfstück @bennofs <https://github.com/bennofs> - Emanuel Borsboom @borsboom <https://github.com/borsboom> - Levi Notik @levinotik <https://github.com/levinotik> - Michael Sloan @mgsloan <https://github.com/mgsloan> - Michael Snoyman @snoyberg <https://github.com/snoyberg> - Oleg Grenrus @phadej <https://github.com/phadej> - Sebastian Graf @sgraf812 <https://github.com/sgraf812> - Simon Jakobi @sjakobi <https://github.com/sjakobi> - Tim Dysinger @dysinger <https://github.com/dysinger> - Yann Esposito @yogsototh <https://github.com/yogsototh> - Yuji Yamamoto @igrep <https://github.com/igrep> And thanks also to the 150+ contributors to past releases!

1 0

ANNOUNCE: accelerate-typelits
by Martin Heuschober 20 May '16

20 May '16

I want to announce my first haskell project big/clean enough so I consider it possibly useful to others - accelerate-typelits is a library that provides vectors/matrices in a typesafe way - i.e. The dimension of the entities are stored on type level as (Nats). There is basic vector/matrix functionality, documentation and tests for those functions (mostly properties). If I have time I will provide some basic examples and a bit more complicated example within the next week. It is available on hackage https://hackage.haskell.org/package/accelerate-typelits as well as on github https://github.com/epsilonhalbe/accelerate-typelits. I would be happy to get some feedback. - Martin

2 4

Modeling space for a MUD - revisited.
by Michael Litchard 20 May '16

20 May '16

This is a continuation of a conversation started in the following two links. https://groups.google.com/forum/#!searchin/haskell-cafe/michael$20litchard|… https://groups.google.com/forum/#!searchin/haskell-cafe/michael$20litchard|… I am trying to model a 3-D space for a mudlike. Here's the criteria I have so far: (1) Objects in space will be either ships that can move or stationary things like non-moving game-controlled ships, space-stations , moons and planets. (2) Objects will not have spatial extent (3) Space is non-continuous (4) Collision happens only when one object is stationary or each moving objects are moving directly toward each other, on the same line. (5) Movement happens by setting a destination vector and a speed. There's no steering exactly, but you can change destination while moving, slow down or stop suddenly. (6) Octree looks like the data structure I want to use for modeling. I'm looking at http://hackage.haskell.org/package/Octree as best library for my application, if I am right about how to go about updating. I'm not sure I am. I think I can use the octree to track things in space, rather than having a node for each point. At most there will be say, 200 objects in space, therefore at most 200 nodes in the tree. So I am visualizing the following steps: (1) Begin with a [(Vector3 <http://hackage.haskell.org/package/Octree-0.5.4.2/docs/Data-Octree.html#t:V…>, a)]. This includes stationary objects and ships already in space. (2) If a new ship entered this space, add it to end of list. (3) make Octree a from above list (4) ships move by setting destination vector and then speed, calculate next Vector3 they will be at next tick (5) Make a new [(Vector3 <http://hackage.haskell.org/package/Octree-0.5.4.2/docs/Data-Octree.html#t:V…>, a)] (6) Go to (1) The first problem with this is in creating a new Octree from a list, when I would rather just recreate the new tree with a subtree of the nodes that changed. The library I am considering does not offer that operation. Maybe this is not a real problem considering the maximum objects in space will be 200. There may be other problems with my thinking here. I look to haskell-cafe for any insight it may offer.

1 0

Re: [Haskell-cafe] ANNOUNCE: accelerate-typelits
by Johannes Waldmann 20 May '16

20 May '16

> .. a library that provides vectors/matrices in a typesafe way Nice! But what does it have to do with accelarate :-) I mean, we could also use this somewhere in Data.Array? Else, it's re-invented all over the place - and poorly, e.g., https://github.com/jwaldmann/ersatz/blob/master/tests/Z001.hs#L51 - J.W.

1 0

What's your favorite flavor of Iterator type
by Silvio Frischknecht 19 May '16

19 May '16

Hello, We know about Foldable, but sometimes you just want more functionality like: give me the rest of the string! Or a function to build pieces back together. I've been experimenting a bit and come up with 6 flavors of Iterators that do the same thing. Of course they all work for containers like ByteStrings, Text. 1) Haskell98 version (I like) data Iterator98 list ele = Iterator98 { next98 :: Maybe (ele, Iterator98 list ele), ... rest98 :: list, concat98 :: [list] -> list } -- How we can create an Iterator98 listIter98 :: [a] -> Iterator98 [a] a -- How the sum type looks sum98 :: (Num n) => Iterator98 listN n -> n Performance: *3 I'll also usually give the type of the constructor and sum functions. I also benchmarked the sum functions for [] and compared them to the best sum function I could come up with (which is significantly faster than the sum in Prelude!!! because it's strict. Whoever came up with the idea of making it non-strict, must have been drunk at the time :)). I like how handy and simple typed the Haskell98 version is. There are absolutely no superfluous Types or Contexts. However, *3 is quite a heavy penalty and it might even get worse when more functions are added. 2) Haskell98 Explicit (ambivalent) data IteratorExplicit98 iter list ele = IteratorExplicit98 { iterExplicit98 :: iter, nextExplicit98 :: iter -> Maybe (ele, iter) ... restExplicit98 :: iter -> list } listIterExplicit98 :: [a] -> IteratorExplicit98 [a] [a] a sumExplicit98 :: (Num n) => IteratorExplicit98 it list n -> n Performance: *1 It is explicit and it is still quite nice to use. There is however always that extra argument. Note: `iter` and `list` could potentially be different (in all examples). They are in Haskell however usually the same. Performance could be different, if you create and destroy a lot of data of type IteratorExplicit98. However, that won't usually be the case. 3) TypeFamilies (I don't like) class IteratorTF i where type ListTF i type ElemTF i nextTF :: i -> Maybe (ElemTF i, i) ... restTF :: i -> ListTF i instance IteratorTF2Class [ele] ele where ... sumTF :: (Num n, IteratorTF it, ElemTF it ~ n) => it -> n Performance: *1 I used to like type families. But now I'm a bit fed up with ~ contexts. This would be the "Rust" version. Interesting point: List and Elem functions could be separated into two classes. I.e. Note that no list type exists in the type of "sum". 4) TypeFamilies2 (ambivalent) class IteratorTF2Class list ele where data IteratorTF2 list ele nextTF2 :: IteratorTF2 list ele -> Maybe (ele, IteratorTF2 list ele) ... restTF2 :: IteratorTF2 list ele -> list instance IteratorTF2Class [ele] ele where data IteratorTF2 [ele] ele = ListIterTF2 [ele] sumTF2 :: (Num n, IteratorTF2Class list n) => IteratorTF2 list n -> n Performance: *1 Better than the last. However, IteratorTF2Class, IteratorTF2 are two Type-ish things where one would be preferred. This is my preferred method where all functions are carried in the type. 5) MultiParameterTypeClasses and Functional Dependencies (ambivalent) class IteratorMPTC iter list ele | iter -> list, iter -> ele where nextMPTC :: iter -> Maybe (ele, iter) ... restMPTC :: iter -> list instance IteratorMPTC [a] [a] a where sumMPTC :: (Num n, IteratorMPTC it list n) => it -> n Performance: *1 About the same as 3). The user will still be exposed to various individual types ":: it". That is not as bad as it is in "Rust", since (as already stated) in Haskell usually "list == it". This is similar to the parsec approach. class (Monad m) => Stream iter m ele | iter -> ele Parsec has no "rest" function so the "list" type is not needed. But they have an additional monad type. 6) Existential Quantification (my favorite) data IteratorEQ list ele = forall iter . IteratorEQ { iterEQ :: iter, nextEQ :: iter -> Maybe (ele, iter) ... restEQ :: iter -> list } listIterEQ :: [a] -> IteratorEQ [a] a sumEQ :: (Num n) => IteratorEQ list n -> n Performance: *1 Looks as nice as Haskell98 and is as fast as Haskell98Explicit. Btw. This is probably how It would be done in "C" with iter = void*. Additional thoughts: * Do we really need the "list" type. Couldn't we simply return iterators instead of the original "list" type. In 3) and 5), they will *usually* be the same anyway. * In 3) and 5) the typeclasses could be split to separate ele and list. * On the other hand combining Iterators will be very annoying for 3) and 5) data ZipIterator ... instance IteratorMPTC (ZipIterator (?) (elem, elem')) ? (elem, elem') where zip :: (IteratorMPTC iter list elem, IteratorMPTC iter' list' elem') -> ZipIterator ? (elem, elem') Which is your favorite? Why? Did I forget any good ones? Cheers Silvio

2 1

ANNOUNCE: Sifflet 2.3.0 - recursion learning aid / visual programming language
by gdweber＠iue.edu 19 May '16

19 May '16

Sifflet 2.3.0 is now available on Hackage. This release brings Sifflet up to date, so it compiles with GHC 7.10.3, newer versions of depended-on libraries, and builds in a cabal sandbox. Sifflet is the visual, functional programming language and support system for students learning about recursion. Sifflet programmers define functions by drawing diagrams, and the Sifflet interpreter uses the diagrams to show how function calls are evaluated. The Sifflet library (formerly sifflet-lib package) is reintegrated into, and deprecated in favor of, the sifflet package. A test suite is added. Personal Note ------------- It's been about 18 months since I've been able to work on this project or do any serious Haskell development. A lot has changed in the Haskell world -- a lot of catching up to do! It feels good getting back to Haskell again. About Sifflet ------------- Sifflet is a visual, functional programming language intended as an aid for learning about recursion. * A picture explains Sifflet better than words: please see the screenshot showing how to evaluate 3!: http://pages.iu.edu/~gdweber/software/sifflet/home.html * Features: - Visual editor. - Visual tracer/debugger which shows how recursive and other function calls are evaluated. To support active learning and avoid screen clutter, Sifflet displays only as much of the computation as the user requests. - Carefully crafted tutorial with 44 pictures, about 26 pages if printed. - Number, string, and list data types. - Small collection of primitive functions. - Runnable examples of compound functions. - Sifflet functions can be exported to Scheme, Python 3, and Haskell. References ---------- * Download: http://hackage.haskell.org/package/sifflet * Home page: http://pages.iu.edu/~gdweber/software/sifflet/home.html * Sifflet Tutorial: http://pages.iu.edu/~gdweber/software/sifflet/doc/tutorial.html * Change log: http://pages.iu.edu/~gdweber/software/sifflet/ChangeLog.html -- Gregory D. Weber, Ph. D. http://pages.iu.edu/~gdweber/ Associate Professor of Informatics Tel (765) 973-8420 Indiana University East FAX (765) 973-8550

1 0

How about a special syntax for generalised (= MonadPlus) comprehension?
by Alexey Muranov 19 May '16

19 May '16

If i understand correctly, the main reason that generalised comprehension was removed from Haskell 98 must have been that its syntax "collides" with the syntax for lists. Indeed, if ``` [x^2 | x <- msum (map return [0..10]), x `mod` 2 == 1] ``` is made ad-hoc polymorphic, then so probably should `[]` and `[1,2,3]`. Moreover, for consistency, the meaning of `[]` as the list type constructor (like in `[]Int` or `[Int]`), should probably be changed to denote an arbitrary instance of `MonadPlus` :). My question is: why not to have a special syntax for `MonadPlus` comprehension? For example: ``` {| x + y | x <- Just 1, y <- Just 2 |} ``` or ``` [* x + y | x <- Just 1, y <- Just 2 *] ``` Then matching analogs of `[]` and `[1,2,3]` could be made: ``` {||} :: Maybe Int -- Nothing {| Just 1, Just 2, Just 3 |} :: Maybe Int -- Just 1 ``` Alexey.

2 3

ANNOUNCE: Haskell Communities and Activities Report (30th ed., May 2016)
by Mihai Maruseac 19 May '16

19 May '16

On behalf of all the contributors, we are pleased to announce that the Haskell Communities and Activities Report (30th edition, May 2016) is now available, in PDF and HTML formats: http://haskell.org/communities/05-2016/report.pdf http://haskell.org/communities/05-2016/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 September 2016: target deadline for contributions to the November 2016 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

2 1

Is there a way to query the availability of an extension? Or could we?
by David Feuer 17 May '16

17 May '16

We have __GLASGOW_HASKELL__ to tell us what GHC version we're running (if we're running GHC), and Cabal sets up MIN_VERSION_blah macros and (when applicable) the __HADDOCK_VERSION__ macro. But what if we're running some other compiler? It seems rather painful to have to write code that enables or disables various extensions based on what version N of compiler C happens to support. Not to mention that this is even a pain when just dealing with GHC, since it involves digging through release notes or waiting to see how Travis throws up. Is there some better way? If not, could we add one? __Have_ScopedTypeVariables__ could tell us if the ScopedTypeVariables extension is available. Then instead of saying "We need ScopedTypeVariables" when we can (painfully) do without, we can just use it precisely when we have it.

3 3

All combinations in order.
by Christian Brolin 17 May '16

17 May '16

Hmm, I tried to post this via google groups but it was rejected. So I try to mail the list instead. Sorry for any duplicates. Hi list! How to transform a list of streams of elements into a stream of lists of elements such that all combinations of exactly one element of each input stream is present? I.e. something like this: | |type Streama =[a] |tr ::[Streame]->Stream[e] tr = sequence | But I want the order of the output lists so the ones with early elements come first. The above starts with the first elements from each stream but does not treat the streams fairly. All the elements of the last stream are used before the next element of the second last stream is used, i.e. | > tr [[1..3], [1..2], [1..3]] [[1,1,1],[1,1,2],[1,1,3],[1,2,1]..... | I don't want the third element of one stream before I have seen all the combinations of the first two elements of each stream and so on. In this case I want something like this: | [[1,1,1], [1,1,2], [1,2,1], [2,1,1], [1,2,2], [2,1,2], [2,2,1], [2,2,2], [1,1,3].... | Also [2,1,1] comes before [1,2,2] because the former contains two first element and one second element while the latter contains only one first element and two second elements. The number of streams are fairly low but the sequences can be very long (almost infinte :) and I want the first results without having to go though a full stream. Also the streams may vary in length so one stream may ran out of elements before the others. If that happens, the non-empty streams should contrbute fairly with new elements, i.e: | > sequence_ $ map print $ tr [[1..2], [3..5]] -- two times three equals to six combinations [1,3] -- 1: first and first [1,4] -- 2: first and second [2,3] -- 3: second and first [2,4] -- 4: second and second [1,5] -- 5: first and third [2,5] -- 6: second and third | Note, I'm not just interested to handle infinite streams (nor infinite number of streams) using some diagonal algorithm. I have looked at the Omega library. But it doesn't return the combinations in wanted order. If someone still wonder about the output ordering, the following program may help: | importData.List(sort,sortBy) type Streama =[a] tr ::Orde =>[Streame]->Stream[e] tr =sortBy myOrder .sequence wheremyOrder ::Orde =>[e]->[e]->Ordering myOrder xs ys =compare (reverse $ sort xs)(reverse $ sort ys) main =sequence_ $ map print$ tr [[1..3],[1..2],[1..3],[1..4]] | But this of course is not a valid solution since it inspects every combinations before producing any output. Attached the sample output.

2 1

representing institutions in haskell
by rick 16 May '16

16 May '16

Has anyone here taken an interest in representing institutions [1] in Haskell? Institutions originated in work on CLEAR [2] which was the first algebraic specification language with rigorous semantics. Institutions take some time to explain, or unravel if you follow the reference, but they come with a convenient slogan : "Truth is invariant under change of notation." The stretch goal of institutions is transforming logics while preserving satisfaction. They are conceived in terms of categorical abstractions, so it's natural to represent them in categories. I hope some folks here find institutions a useful domain to apply their work on categories. I've attached two samples in Haskell that uses some standard libraries : Arrow, Monad, Category and Dual. The first sample, ri-0, outlines the essentials. The category of signatures, constructions in the categories, signature morphisms, sentences, models and the satisfaction condition. Using plain old Nat reduces the complexity of the exposition. I provide a constructive witness for satisfaction of the morphism from conjunction to disjunction. You may recognize that I borrow some Bird/Hinze notation on Functors like mapSign. And you find some experiments with Quickcheck and Yampa. Ri-0 runs from main, but just computes the witness to the satisfaction condition. The second sample, ri-1, builds on ri-0. Rather than Nat, I use Either to inject disjunction into the exposition. The exposition becomes more complex, but the increased complexity is justified because maintaining satisfaction under change on notation is central to institutions. The functions prodSum takes conjunction to disjunction and sumProd takes disjunction to conjunction. I owe a citation to @BartoszMilewski and his work on categories for programmers where I first saw these functions. The satisfaction condition and witness appear more complex in ri-1, but its really just the substitution of the signature morphism on product and sum rather than plain old Nat as in ri-0. I also plan a better write up, but before I do I expect to learn much from an email exchange with interested folks here. Thanks for taking a look at this material. 1. https://cseweb.ucsd.edu/~goguen/pps/ins.ps 2. http://hopl.info/showlanguage.prx?exp=945 -- Rick

1 0

[Final CFP] Haskell 2016
by Geoffrey Mainland 16 May '16

16 May '16

======================================================================== ACM SIGPLAN CALL FOR SUBMISSIONS Haskell Symposium 2016 Nara, Japan, 22-23 September 2016, directly after ICFP http://www.haskell.org/haskell-symposium/2016 ======================================================================== The ACM SIGPLAN Haskell Symposium 2016 will be co-located with the International Conference on Functional Programming (ICFP 2016) in Nara, Japan. The Haskell Symposium aims to present original research on Haskell, discuss practical experience and future development of the language, and to promote other forms of denotative programming. Topics of interest include: * Language Design, with a focus on possible extensions and modifications of Haskell as well as critical discussions of the status quo; * Theory, such as formal semantics of the present language or future extensions, type systems, effects, metatheory, and foundations for program analysis and transformation; * Implementations, including program analysis and transformation, static and dynamic compilation for sequential, parallel, and distributed architectures, memory management, as well as foreign function and component interfaces; * Libraries, that demonstrate new ideas or techniques for functional programming in Haskell; * Tools, such as profilers, tracers, debuggers, preprocessors, and testing tools; * Applications, to scientific and symbolic computing, databases, multimedia, telecommunication, the web, and so forth; * Functional Pearls, being elegant and instructive programming examples; * Experience Reports, to document general practice and experience in education, industry, or other contexts. Papers in the latter three categories need not necessarily report original academic research results. For example, they may instead report reusable programming idioms, elegant ways to approach a problem, or practical experience that will be useful to other users, implementors, or researchers. The key criterion for such a paper is that it makes a contribution from which other Haskellers can benefit. It is not enough simply to describe a standard solution to a standard programming problem, or report on experience where you used Haskell in the standard way and achieved the result you were expecting. More advice is available via the Haskell wiki: (http://wiki.haskell.org/HaskellSymposium/ExperienceReports) Regular papers should explain their research contributions in both general and technical terms, identifying what has been accomplished, explaining why it is significant, and relating it to previous work, and to other languages where appropriate. In addition, we solicit proposals for: * System Demonstrations, based on running software rather than novel research results. These proposals should summarize the system capabilities that would be demonstrated. The proposals will be judged on whether the ensuing session is likely to be important and interesting to the Haskell community at large, whether on grounds academic or industrial, theoretical or practical, technical, social or artistic. Please contact the program chair with any questions about the relevance of a proposal. Travel Support: =============== Student attendees with accepted papers can apply for a SIGPLAN PAC grant to help cover travel expenses. PAC also offers other support, such as for child-care expenses during the meeting or for travel costs for companions of SIGPLAN members with physical disabilities, as well as for travel from locations outside of North America and Europe. For details on the PAC program, see its web page (http://pac.sigplan.org) Proceedings: ============ Accepted papers will be included in the ACM Digital Library. Authors must grant ACM publication rights upon acceptance (http://authors.acm.org/main.html) Authors are encouraged to publish auxiliary material with their paper (source code, test data, etc.); they retain copyright of auxiliary material. Accepted proposals for system demonstrations will be posted on the symposium website but not formally published in the proceedings. All accepted papers and proposals will be posted on the conference website one week before the meeting. Publication date: The official publication date of accepted papers is the date the proceedings are made available in the ACM Digital Library. This date may be up to two weeks prior to the first day of the conference. The official publication date affects the deadline for any patent filings related to published work. Submission Details: =================== Submitted papers should be in portable document format (PDF), formatted using the ACM SIGPLAN style guidelines (http://www.acm.org/sigs/sigplan/authorInformation.htm) The text should be in a 9-point font in two columns. The length is restricted to 12 pages, except for "Experience Report" papers, which are restricted to 6 pages. Papers need not fill the page limit---for example, a Functional Pearl may be much shorter than 12 pages. Each paper submission must adhere to SIGPLAN's republication policy, as explained on the web. Demo proposals are limited to 2-page abstracts, in the same ACM format as papers. "Functional Pearls", "Experience Reports", and "Demo Proposals" should be marked as such with those words in the title at time of submission. The paper submission deadline and length limitations are firm. There will be no extensions, and papers violating the length limitations will be summarily rejected. Papers may be submitted at: https://icfp-haskell2016.hotcrp.com/ Submission Timetable: ===================== Early Track Regular Track System Demos ---------------- ------------------- --------------- 1st April Paper Submission 20th May Notification 6th June Abstract Submission 10th June Paper Submission 17th June Resubmission Demo Submission 8th July Notification Notification Notification 31st July Camera ready due Camera ready due Deadlines stated are valid anywhere on earth. The Haskell Symposium uses a two-track submission process so that some papers can gain early feedback. Papers can be submitted to the early track on 1st April. On 20th May, strong papers are accepted outright, and the others will be given their reviews and invited to resubmit. On 17th June, early track papers may be resubmitted and are sent back to the same reviewers. The Haskell Symposium regular track operates as in previous years. Papers accepted via the early and regular tracks are considered of equal value and will not be distinguished in the proceedings. Although all papers may be submitted to the early track, authors of functional pearls and experience reports are particularly encouraged to use this mechanism. The success of these papers depends heavily on the way they are presented, and submitting early will give the program committee a chance to provide feedback and help draw out the key ideas. Program Committee: =================== James Cheney University of Edinburgh Iavor Diatchki Galois David Duke University of Leeds Richard Eisenberg University of Pennsylvania Ken Friis Larsen University of Copenhagen Andy Gill University of Kansas Zhenjiang Hu National Institute of Informatics Ranjit Jhala UC San Diego Yukiyoshi Kameyama University of Tsukuba Geoffrey Mainland (chair) Drexel University Mary Sheeran Chalmers University of Technology David Terei Stanford Niki Vazou UC San Diego Dimitrios Vytiniotis Microsoft Research =====================================================================

1 0

Confirmation Email for Hackage Account?
by Christopher Howard 15 May '16

15 May '16

Hi. How long does it usually take to receive the confirmation email for a hackage account registration? -- http://justonemoremathproblem.com To protect my privacy, please use PGP encryption. It's free and easy to use! My public key ID is 0x340EA95A (pgp.mit.edu)

2 4

[ANN] process-extras-0.4.1
by David Fox 14 May '16

14 May '16

I thought I should announce the process-extras package, available from hackage <https://hackage.haskell.org/package/process-extras>. It extends the process reading functions in System.Process to allow output types ByteString and Text, both strict and lazy. It also provides a function readCreateProcessLazy that can read from processes whose output is infinite - the regular readProcess functions block until they find EOF. There are also some new usage examples in the README.md file. This package has a long history, so if you are familiar with an older version you may want to take another look. Best, David Fox

1 0

Yesos forms and types with foreign keys
by fr33domlover 14 May '16

14 May '16

Hello, I have a question about RESTful web apps in Haskell. I'm using Yesod but I suppose the same question can apply to any other framework with type safety features. Suppose I have entities A and B defined in my Persistent model file. One of A's fields is a foreign key referring to B. Each A has its own unique B. The process of creating a new A would be: 1. Set the user a web form via GET 2. Receive for field data via POST 3. Validate the input 4. Insert a new B value to the DB, and get its ID 5. Define an A value which includes that ID as a foreign key, and insert the new A value to the DB In Yesod, If I use a form of type 'AForm A', running the form must return a complete A value. But when I runFormPost, I don't have the B entity yet so I don't have an ID for the foreign key! Ideas what I can do: - Set that field to some dummy value, and override it later when I insert the B value and get its ID - Define a 'NewA' type which has the same fields as A except for that foreign key field - Insert to the DB in the form itself. Define my form as an MForm so that I have access to Handler monad and use runDB to insert to the DB right in the form itself, i.e. form success means the DB has been updated I know little about REST common practice but afaik to allow alternative representations, e.g. a JSON API, my forms need to return entity types, e.g. A and not some partial NewA. Also my forms so far are all simple AForms which just do validation, sometimes against the DB, and never insert or delete anything. Insertion and deletetion I always do in the handlers. The dummy value may work, I already have one case where I use it, but it's ugly and requires that I rely on the specific underlying type of the key, e.g. Int64 for postgresql but could be ByteString for other backends if I ever want to change. Maybe some 'dummyKey' function could make it prettier, if at all this is a good approach. What should I do here? --fr33

1 0

Re: [Haskell-cafe] Haskell-Cafe Digest, Vol 153, Issue 17
by Julian Leviston 14 May '16

14 May '16

If you’re on the mac, Haskell for Mac is very good to start with. http://haskellformac.com http://www.happylearnjavascripttutorial.com/ <http://www.happylearnjavascripttutorial.com/> - begin programming with JavaScript today using our awesome new method! http://www.happylearnhaskelltutorial.com/ <http://www.happylearnhaskelltutorial.com/> - begin programming with Haskell today using our awesome new method! > On 14 May 2016, at 10:00 PM, haskell-cafe-request(a)haskell.org wrote: > > Date: Fri, 13 May 2016 15:47:29 -0300 > From: Henson <jfsihenson(a)gmail.com <mailto:jfsihenson@gmail.com>> > To: haskell-cafe(a)haskell.org <mailto:haskell-cafe@haskell.org> > Subject: [Haskell-cafe] Haskell Better Editor > Message-ID: <57362141.7070205(a)gmail.com <mailto:57362141.7070205@gmail.com>> > Content-Type: text/plain; charset=windows-1252; format=flowed > > Friends, > > What's the better text editor for Haskell development? > More productive and more rapid learning curve? > Any trick for initiating in haskell and rapid advance? > Please let your comments. > > Thank you, > Josenildo

1 0

Problems with function recursion in Haskell
by Henson 13 May '16

13 May '16

Hi, I'm new in Haskell and I need help in recursion. That function below is returning "*** Exception: Prelude.head: empty list" and I need resolve that: execNTimes 0 [] = return() execNTimes n xs = if n<=0 || null xs then return() else do si <- getLine let s = words si l = read (s !! 1) :: Int r = read (s !! 2) :: Int if head s=="Q" then do let z = slice l r xs m = foldl lcm 1 z print (m `mod` (toInteger 1000000007)) else do let s1 = update l r xs execNTimes (n-1) s1 execNTimes (n-1) xs Anybody can me help? Thank you, Josenildo Silva

12 13

Using parallels for fibonacci
by Michael Litchard 11 May '16

11 May '16

I am trying to efficiently use multicores for my fizzbuzz <https://github.com/mlitchard/swiftfizz> project. My fizzbuzz uses a Fibonacci generator as input, and this is where it can get computationally heavy. I believe I have picked the best algorithm for my project (please correct this if wrong), and now I am trying to use the parallel package <https://hackage.haskell.org/package/parallel-3.2.1.0>. I am not getting any better performance in the sense that if I try to compute the 100th Fibonacci number, it is still computing , using 4 cores, several minutes later. Here is my attempt. Please show me how to use this library right. from src/FizzBuzz.hs fizzBuzzFib :: Integer -> [Text] fizzBuzzFib ub = parMap rdeepseq fizzbuzz $! fibSeq ub from src/FizzFub.hs fibSeq :: Integer -> [Integer] fibSeq ub = withStrategy (parBuffer buffer rdeepseq) $ genericTake ub fibbwhere buffer = 100 fibb :: [Integer] fibb = 0 : 1 : zipWith (+) fibb (tail fibb)

2 2

Template Haskell Tutorial
by Dominik Bollmann 11 May '16

11 May '16

Hi, I've been diving into Template Haskell recently and thought to write down what I've learned. The result hopes to be a practical, example-driven introduction to Template Haskell's main features: https://wiki.haskell.org/A_practical_Template_Haskell_Tutorial I hope it serves others new to Template Haskell. It's all on the Haskell wiki, so feedback and improvements are welcome! Cheers, Dominik.

2 1

Applying a Constraint to a Proxy'd type
by Ivan Lazar Miljenovic 11 May '16

11 May '16

I'm not sure if it's possible (and I have an alternate method of doing this so it isn't strictly speaking _necessary_, but would make the code cleaner if I can), but I would like to convert a "value" of kind (k -> Constraint) into one of kind (Proxy k -> Constraint). I can achieve this using a type family (note: I've also made this polymorphic in terms of the Proxy type used, but that isn't necessary): > type family LiftConstraint_ c pa :: Constraint where > LiftConstraint_ c (proxy a) = c a > LiftConstraint_ c pa = () ~ Bool -- A nonsensical failing Constraint value which has the problem that it can't be partially applied (which I also need). This can be wrapped up in a typeclass: > class (LiftConstraint_ c pa) => LiftConstraint c pa > instance (LiftConstraint_ c pa) => LiftConstraint c pa The problem with this is that if I try and use it somewhere that - having already a type of kind (c :: * -> Constraint) from the environment - that expects a function of type (forall a. (c a) => a -> b) with a fixed "b" value, then trying to use something like this function prevents it from working (for the purposes of argument, assume the old specification of Num that had an Eq superclass; this is the way I can produce the smallest example): > fn :: forall pn. (LiftConstraint Num (Proxy n)) => Proxy n -> Bool > fn = join (==) . asProxyTypeOf 0 The resulting error message is: "Could not deduce (a ~ Proxy n0) ..." This occurs even if I make the type of fn polymorphic in terms of the proxy type or if I make LiftConstraint_ specific. Note that the error goes away if I make the definition to be "fn = const True"; it's only if I try and _use_ the proxy value. I've tried defining and using an IsProxy type family + class but that fails to the same basic problem: it can't tell that the provided value can be pulled apart to get what's in the Proxy. Any ideas? -- Ivan Lazar Miljenovic Ivan.Miljenovic(a)gmail.com http://IvanMiljenovic.wordpress.com

2 2

Haskell Weekly News
by Kim-Ee Yeoh 11 May '16

11 May '16

*Top Picks:* - Oskar Wickström rewrites the Oden-to-Go transpiler from Racket to Haskell <http://oden-lang.org/blog/compiler/2016/01/18/the-haskell-rewrite.html>. Oden is an FP language comprising an ML type system and LISP syntax. Oskar explains that he made the migration because of several advantages that Haskell offered over Racket: exhaustive pattern-match checking, type-guided refactoring, monad transformers, and faster execution times. Apropos, the convo over at lobste.rs <https://lobste.rs/s/8hidko/the_haskell_rewrite_the_motivation_for_moving_aw…> links to this claim by Gabriel Gonzalez: "Haskell is an amazing language for writing your own compiler. If you are writing a compiler in another language you should genuinely consider switching." - Reviewing 2015 work month-by-month, Gracjan Polak tells the story of how he decided to lead the development of Haskell Mode <https://github.com/haskell/haskell-mode/wiki/Haskell-Mode-2015-retrospective>, "a bunch of Emacs major and minor modes put together in a single package." Discussion over at /r/haskell <https://www.reddit.com/r/haskell/comments/425gn4/haskell_mode_2015_retrospe…> . - Jared Tobin presents monadic versions of five recursion-schemas <http://jtobin.ca/monadic-recursion-schemes/>, namely: cata-, ana-, para-, apo-, and hylomorphisms. *Quotes of the Week:* - Tim Kellogg: <https://lobste.rs/s/erxkun/redundancy_vs_dependencies_which_is_worse/commen…> I’ve known a few old programmers nearing retirement that have a long list of very impressive accomplishments. The older and more accomplished they get, the more they prefer redundancy over dependency. The oldest and most accomplished will write their own load balancers, TCP stacks, loggers, everything if need be. Are they on to something? - From HN: <https://news.ycombinator.com/item?id=10972051#up_10979314> If you have the time, I'd advise you to learn Haskell, in order to stretch your mind and become an excellent OCaml developer, the way learning Latin makes you a better French or Italian writer. - HN markov chain parody site headline: <http://news.ycombniator.com/comments/comments_419.html> $690 for an hour minimum wage for state management in haskell *Recorded Talk of the Week:* - On Dec 17 last year <http://www.meetup.com/haskellhackersathackerdojo/events/226870399/>, Andrew Gibiansky demoed IHaskell, a Mathematica-like "capable graphical alternative" to the ghci REPL at the NorCal Hacker Dojo. Thanks go to Joe "begriffs" Nelson who recorded the talk and summarized it into bullet points <http://begriffs.com/posts/2016-01-20-ihaskell-notebook.html>. Joe's page was well-received at both Hacker News <https://news.ycombinator.com/item?id=10942969> and Haskell Reddit <https://www.reddit.com/r/haskell/comments/41xnhw/demo_of_ihaskell_notebook_…> . p.s. There will be no News next week. HWN will resume the week after. -- Kim-Ee

2 2

OAuth2 and OpenID Connect in Haskell
by Luke Taylor 10 May '16

10 May '16

Hello all, I've written a blog article as an introduction to the Haskell project I've been working on, which may be of interest to some people here. It's an OpenID Connect identity provider. http://broch.io/posts/oauth2-openid-connect-haskell/ I'd really welcome any feedback on other/better ways of doing some of things it talks about. Cheers, Luke.

1 0

Re: [Haskell-cafe] Automatic differentiation (AD) with respect to list of matrices in Haskell
by Miguel A. Santos 10 May '16

10 May '16

Awesome! Lots of new info! And more importantly, I got it to work. > > I still need to work on it a bit more, but things seems to be getting > clearer. > > On Sun, May 8, 2016 at 2:25 PM, Moritz Kiefer < > moritz.kiefer(a)purelyfunctional.org> wrote: > >> >> Miguel A. Santos <miguel.a.santos.l(a)gmail.com> writes: >> >> > Thanks a lot for your quick answer. >> > >> > First, I can't get your modifications through: What are Scalar & Mode? >> ghc >> > says type/class not in scope. >> >> Oh sorry you need to import Numeric.AD for that. Mode is a typeclass >> with an associated type called Scalar. You can just think of it as some >> magic that allows you to use constants in your function. >> >> > Yes. I figured out as well. I was only importing its Mode.Reverse as R. > > > >> > Some more questions to help me understand your suggestions below. >> > >> > >> > On Sun, May 8, 2016 at 1:14 PM, Moritz Kiefer < >> > moritz.kiefer(a)purelyfunctional.org> wrote: >> > >> >> >> >> There are two orthogonal errors going on here: >> >> >> >> 1. You need to use auto to embed constants. See the comments at the >> code >> >> below on how to use it. >> >> >> >> Ah, that solves indeed the first problem. Thanks! >> > >> > >> >> 2. You need to wrap [Matrix a] in a newtype. grad requires you to >> >> provide a function f a -> a, however sc2 _ has the type [Matrix a] -> a >> >> so if you replace [] by f you end up with f (Matrix a) -> a which >> >> results in the error you’re seeing. >> >> >> > >> > I've problems following you here. For example this is legit and works >> > grad (\[x,y] -> x^2y^3) [5,7] >> > >> > That is, grad here is taking a function f [a,a] -> a. That seems to >> work as >> > well with sc1 in my example: I do get the rigth gradient. >> >> That function has type [a] -> a which can be rewritten as [] a -> a and >> if you unify [] and f you have f a >> -> a which is exactly what you need. >> >> However in sc2 you have a function of type [Matrix a] -> a which can be >> rewritten as [] (Matrix a) -> a and if you unify f and [] you end up >> with f (Matrix a) -> a. However Matrix a and a are not the same type so >> you get an error. >> >> > I got confused by the expression "[the] function f a -> a": I though the > word 'function' was referring to the symbol 'f'. > > Yet, I still can't follow things completely...uhm, issuing :type grad in > ghci I get > grad > :: (Num a, Traversable f) => > (forall s. > Data.Reflection.Reifies s Numeric.AD.Internal.Reverse.Tape => > f (Numeric.AD.Internal.Reverse.Reverse s a) > -> Numeric.AD.Internal.Reverse.Reverse s a) > -> f a -> f a > > which I'd say could be simplified to > grad :: Num a => ( f Reverse s a -> Reverse s a) -> f a -> f a > > Now, It's not only that I don't see your "grad expects a 'f a -> a' ", but > I don't even see how something like grad (\[x,y]-> x*y) [2,3] fits...or do > I? The notation 'f' seems was misleading me. I'd say what's important is > its type, name Traversable f. [] seems to fit there, isn't? So the first > argument of grad more or less would be what you were referring to ( f a -> > a) , the second it the point to calculate the gradient at (of course a [a], > or, [] a, hence, f a) and it does yield a "vector" (on paper). > Interestingly, its implementation means that grad's output is the same type > the input of the function we want to take its gradient of. > > I think it starts making sense to me now. > > >> >> >> Miguel A. Santos <miguel.a.santos.l(a)gmail.com> writes: >> >> >> >> > mv _ [] = [] >> >> > mv (M []) _ = [] >> >> > mv ( M m ) v = ( dot (head m) v ) : (mv (M (tail m)) v ) >> >> > --- two matrices >> >> >> >> You need explicit type annotations to make this polymorphic here >> because >> >> of the monomorphism >> >> restriction. >> >> >> >> >> > Just for the sake of learning how to use that jargon in this context: >> > which/what is that monomorphism restriction are you referring to? Also, >> > when you say my mbW1 is polymorphic, do you mean, given my definition of >> > it, ghc cannot adscribe it one _unique_ type signature, but that will >> vary >> > depending on the context? >> >> I’m going to refer you to the haskell report [1] for information on the >> monomorphism restriction. By polymorphic I’m referring to the choice of >> a which is now left open. >> >> Thanks!! > > >> >> mbW1 :: Num a => Matrix a >> >> > mbW1 = M $ [[1,0,0],[-1,5,1],[1,2,-3]] >> >> > mbW2 = M $ [[0,0,0],[1,3,-1],[-2,4,6]] >> >> > --- two different scoring functions >> >> >> >> -- Provide a type signature and map auto over the constants >> >> sc1 :: (Floating b, Mode b) => [Scalar b] -> Matrix b -> b >> >> sc1 v m = foldr (+) 0 $ (phi' . (mv m) ) (map auto v) >> >> >> > >> >> -- Provide a type signature, use auto and use the newtype >> >> newtype MatrixList a = MatrixList [Matrix a] deriving >> >> (Functor,Foldable,Traversable) >> >> >> >> sc2 :: (Floating a,Mode a) => [Scalar a] -> MatrixList a -> a >> >> sc2 v [m1, m2] = foldr (+) 0 $ (phi' . (mv m2) . phi' . (mv m1) ) (map >> >> auto v) >> >> >> >> > strToInt = read :: String -> Double >> >> > strLToIntL = map strToInt--- testing >> >> > main = do >> >> > putStrLn $ "mbW1:" ++ (show mbW1) >> >> > putStrLn $ "mbW2:" ++ (show mbW2) >> >> > rawInput <- readFile "/dev/stdin" >> >> > let xin= strLToIntL $ lines rawInput >> >> > putStrLn "sc xin mbW1" >> >> >> >> -- That needs an explicit type annotation because mbW1 is polymorphic >> >> print $ sc1 xin (mbW1 :: Matrix Double) --- ok. = >> >> >> >> uhm...but it doesn't seem to give any problem, especially not after >> using >> > auto...I've still problems getting an intuition on when ghc does need >> "my >> > help" and when it can walk on it own. >> >> Hm maybe you don’t need it after all. I thought I got an error >> locally. Sorry I don’t have any good tip on how to get an >> intuition. I add them when I’m unsure about the type of something myself >> to help me to figure it out and when I get an error. >> >> >> > putStrLn "grad (sc1 xin) mbW1" >> >> > print $ grad ( sc1 xin) mbW1 -- yields an error: expects >> xin >> >> > [Reverse s Double] instead of [Double] >> >> > putStrLn "grad (sc1 [3,5,7]) mbW1" >> >> > print $ grad ( sc1 [3,5,7]) mbW1 --- ok. = >> >> > putStrLn "sc2 xin [mbW1,mbW2]" >> >> > print $ sc2 xin [mbW1, mbW2] >> >> > putStrLn "grad (sc2 [3,5,7) [mbW1,mbW2]" >> >> >> >> -- Use the newtype defined above >> >> print $ grad ( sc2 [3,5,7]) (MatrixList [mbW1, mbW2]) --- >> Error: >> >> see text >> >> >> >> Also as a general recommendation, write your type signatures >> explicitely >> >> at least for top level definitions. >> >> >> > >> > What do you mean by "top level" definitions? --again, just a side >> comment >> > to fine-tune my jargon registers. >> >> Top level definitions are the definitions in your module that are not in >> a let or where. So basically everything that’s accessible from other >> definitions outside of the current one. >> >> > I still have to learn my way through all types. Sometimes this rule makes > my life a bit too hard, specially > when I just want to quickly test some ideas, like here: logistic expects a > Floating a but if I don't make things > explicit, ghc was finding its way around my use of Num a and this Floating > requirement of the exp function. > > I'll keep this rule in mind. > > Thanks a lot!! > > Regards, > MA > PD: Forgot to reply to the list before... > > Cheers Moritz >> >> [1] https://www.haskell.org/onlinereport/decls.html#sect4.5.5 >> > >

1 1

Summer of Haskell Mentors
by Edward Kmett 10 May '16

10 May '16

If you are interesting in helping out as a possible mentor for this year's Summer of Haskell, please email me, and include MENTOR in the title. Thank you! -Edward

1 0

origin of my fibonacci test
by Michael Litchard 10 May '16

10 May '16

I have some code that checks to see if a number is a fibonacci number. It's not mine, I got it from somewhere and I need to credit it. I am pretty sure I got it from Stack Exchange but my search for it went nowhere. If this looks familiar to you, or you can tell me better ways to search, please let me know. isFib :: Integer -> Bool isFib n = n == a where (_, a, _) = unFib (1, 1) n unFib :: (Integer, Integer) -> Integer -> (Integer,Integer,Integer) unFib (a, b) n | n < a = (0, 0, 1) | n < e = (2*k, c, d) | otherwise = (2*k + 1, e, f) where (k, c, d) = unFib (fibPlus (a, b) (a, b)) n (e, f) = fibPlus (a, b) (c, d) fibPlus :: (Integer, Integer) -> (Integer, Integer) -> (Integer,Integer) fibPlus (a, b) (c, d) = (bd - (b - a)*(d - c), a*c + bd) where bd = b*d

3 3

Myrtle Software is looking for Haskell developers for exciting graphics/compilers/hardware work
by Joe Hermaszewski 09 May '16

09 May '16

https://www.myrtlesoftware.com/vacancies/ We're a small software company in Cambridge, UK. We are working on some cool tech for lowering image processing algorithms to efficient hardware designs with a focus on putting these in autonomous vehicles. Our compiler is written completely in Haskell as well as some other tools we've written in house. We are looking to hire some more Haskell talent to help drive things forward. Please ask if you have any questions!

1 0

Re: [Haskell-cafe] Problems with function recursion in Haskell
by Johannes Waldmann 09 May '16

09 May '16

> ... homework ... it is highly unlikely that you will > find any help in the list or on stackoverflow. Quite often students do find homework "help" on stackoverflow. Of course SO will do nothing to discourage that. I'm not saying they should delete homework questions outright, but if they'd want quality, they'd introduce a "homework" tag so that these questions can be avoided more easily by people who would want to use SO to read/write quality answers/questions. But it seems that SO's goal is mostly numbers, that is, users. Actually, viewers for the job ads. And as long as the advertisers are paying ... Anyway, back to Haskell (but not leaving rant mode): the code example in the original question, although being rather short, manages to showcase several features that should be avoided in introductory teaching: numbers, lists, strings, and IO. (*) But, perhaps the instructor had a specific motivation. We can only guess, and that is why the recommended way for getting help with homework is (in that order): pay attention in class, then work on the exercises on your own, then with fellow students, and with the remaining questions, go to your instructor. - J.W. (*) and, recently, we should also avoid tuples https://mail.haskell.org/pipermail/libraries/2016-February/026678.html (I like the "matlab league" characterisation)

1 0

WST 2016 - First Call for Papers
by Salvador Lucas 09 May '16

09 May '16

========================================================================== WST 2016 - 1st Call for Papers 15th International Workshop on Termination September 5-7, 2016, Obergurgl, Austria http://cl-informatik.uibk.ac.at/events/wst-2016/ ========================================================================== The Workshop on Termination (WST) traditionally brings together, in an informal setting, researchers interested in all aspects of termination, whether this interest be practical or theoretical, primary or derived. The workshop also provides a ground for cross-fertilization of ideas from term rewriting and from the different programming language communities. The friendly atmosphere enables fruitful exchanges leading to joint research and subsequent publications. The event is held as part of CLA 2016 http://cl-informatik.uibk.ac.at/events/cla-2016/ IMPORTANT DATES: * submission June 22, 2016 * notification July 12, 2016 * final version August 3, 2016 * workshop September 5-7, 2016 TOPICS: The 15th International Workshop on Termination welcomes contributions on all aspects of termination and termination analysis. Contributions from the imperative, constraint, functional, and logic programming communities, and papers investigating applications of complexity or termination (for example in program transformation or theorem proving) are particularly welcome. Topics of interest include all aspects of termination. This includes (but is not limited to): * certification of termination and complexity proofs * challenging termination problems * comparison and classification of termination methods * complexity analysis in any domain * implementation of termination and complexity methods * implicit computational complexity * infinitary normalization * non-termination analysis and loop detection * normalization in lambda calculi * operational termination of conditional rewrite systems * ordinal notation and subrecursive hierarchies * SAT, SMT, and constraint solving for (non-)termination analysis * scalability and modularity of termination methods * termination analysis in any domain * well-founded relations and well-quasi-orders COMPETITION: There will be a live complexity and termination competition during the workshop, including time to present both the results and the tools of the participants. More details will be provided in a dedicated announcement on the competition. PROGRAM COMMITTEE: * Ugo Dal Lago Bologna University * Jörg Endrullis VU University Amsterdam * Yukiyoshi Kameyama University of Tsukuba * Salvador Lucas Universidad Politécnica de Valencia * Aart Middeldorp University of Innsbruck, co-chair * Andrey Rybalchenko Microsoft Research * Thomas Ströder RWTH Aachen * René Thiemann University of Innsbruck, co-chair * Andreas Weiermann Ghent University INVITED SPEAKERS: * Rainer Hähnle TU Darmstadt SUBMISSION: Submissions are short papers/extended abstract which should not exceed 5 pages. There will be no formal reviewing. In particular, we welcome short versions of recently published articles and papers submitted elsewhere. The program committee checks relevance and provides additional feedback for each submission. The accepted papers will be made available electronically before the workshop. Papers should be submitted electronically via the submission page: http://www.easychair.org/conferences/?conf=wst2016 Final versions should be created using LaTeX and the LIPIcs style file http://drops.dagstuhl.de/styles/lipics/lipics-authors.tgz

1 0

Automatic differentiation (AD) with respect to list of matrices in Haskell
by Miguel A. Santos 08 May '16

08 May '16

I am trying to understand how can I use Numeric.AD (automatic differentiation) in Haskell. I defined a simple matrix type and a scalar function taking an array and two matrices as arguments. I want to use AD to get the gradient of the scoring function with respect to both matrices, but I'm running into compilation problems. Here is the code: ------------------------------- {-# LANGUAGE DeriveTraversable, DeriveFunctor, DeriveFoldable #-}import Numeric.AD.Mode.Reverse as Rimport Data.Traversable as Timport Data.Foldable as F --- Non-linear function on "vectors" logistic x = 1.0 / (1.0 + exp(-x) ) phi v = map logistic v phi' (x:xs) = x : (phi xs) --- dot product dot u v = foldr (+) 0 $ zipWith (*) u v --- simple matrix typedata Matrix a = M [[a]] deriving (Eq,Show,Functor,F.Foldable,T.Traversable) --- action of a matrix on a vector mv _ [] = [] mv (M []) _ = [] mv ( M m ) v = ( dot (head m) v ) : (mv (M (tail m)) v ) --- two matrices mbW1 = M $ [[1,0,0],[-1,5,1],[1,2,-3]] mbW2 = M $ [[0,0,0],[1,3,-1],[-2,4,6]] --- two different scoring functions sc1 v m = foldr (+) 0 $ (phi' . (mv m) ) v sc2 :: Floating a => [a] -> [Matrix a] -> a sc2 v [m1, m2] = foldr (+) 0 $ (phi' . (mv m2) . phi' . (mv m1) ) v strToInt = read :: String -> Double strLToIntL = map strToInt--- testing main = do putStrLn $ "mbW1:" ++ (show mbW1) putStrLn $ "mbW2:" ++ (show mbW2) rawInput <- readFile "/dev/stdin" let xin= strLToIntL $ lines rawInput putStrLn "sc xin mbW1" print $ sc1 xin mbW1 --- ok. = putStrLn "grad (sc1 xin) mbW1" print $ grad ( sc1 xin) mbW1 -- yields an error: expects xin [Reverse s Double] instead of [Double] putStrLn "grad (sc1 [3,5,7]) mbW1" print $ grad ( sc1 [3,5,7]) mbW1 --- ok. = putStrLn "sc2 xin [mbW1,mbW2]" print $ sc2 xin [mbW1, mbW2] putStrLn "grad (sc2 [3,5,7) [mbW1,mbW2]" print $ grad ( sc2 [3,5,7]) [mbW1, mbW2] --- Error: see text -------------------------------- The last line (grad on sc2) gives the following error: --------------------------------- Couldn't match type ‘Reverse s (Matrix Double)’ with ‘Matrix (Reverse s (Matrix Double))’ Expected type: [Reverse s (Matrix Double)] -> Reverse s (Matrix Double) Actual type: [Matrix (Reverse s (Matrix Double))] -> Reverse s (Matrix Double) In the first argument of ‘grad’, namely ‘(sc2 [3, 5, 7])’ In the second argument of ‘($)’, namely ‘grad (sc2 [3, 5, 7]) [mbW1, mbW2]’ --------------------------------- I don't understand where the "Matrix of Matrix" in the actual type seen comes from. I'm feeding the grad with a curried version of sc2, making it a function on a list of Matrix. Commenting out the two offending lines runs without problem, i.e., the first gradient works and is correctly calculated (I'm feeding [1,2,3] as input to the program): ------------------- mbW1:M [[1.0,0.0,0.0],[-1.0,5.0,1.0],[1.0,2.0,-3.0]] mbW2:M [[0.0,0.0,0.0],[1.0,3.0,-1.0],[-2.0,4.0,6.0]] sc1 xin mbW11232.0179800657874893 grad (sc1 [3,5,7]) mbW1 M [[3.0,5.0,7.0],[7.630996942126885e-13,1.2718328236878141e-12,1.7805659531629398e-12],[1.0057130122694228e-3,1.6761883537823711e-3,2.3466636952953197e-3]] sc2 xin [mbW1,mbW2]1.8733609463863194 ------------------- Both errors are an issue. I want to take the gradient of any such sc2 scoring function, depending on an array of matrices, evaluated at any given "point" xin. Clearly, I'm not yet understanding the AD library well enough. Any help would be appreciated. -- Public key ID: E8FE60D7 Public key server: see, e.g., hkp://keys.gnupg.net

2 1

Could Haddock export documentation with type family applications normalised?
by Oliver Charles 08 May '16

08 May '16

Hi all, I'm working on a library that uses quite a lot of type "magic" (as some would call it), but really it's all just implementation details. The type families are necessary for me to write the code, but an outside understanding of these type families shouldn't be necessary to understand the library. Unfortunately, Haddock does not align with that goal. To give you a feeling for things, take the following types: data Expr (t :: k) data AsHaskell (t :: k) data BaseType = DBInt | DBText type family Col (f :: k -> *) (a :: k) :: * type instance Col Expr (a :: BaseType) = Expr a type instance Col AsHaskell (a :: BaseType) = BaseTypeAsHaskell a type family BaseTypeAsHaskell (bt :: BaseType) :: * where BaseTypeAsHaskell 'DBInt = Int BaseTypeAsHaskell 'DBText = String class Lit (exprType :: k) where lit :: Col AsHaskell exprType -> Expr exprType instance Lit 'DBInt where lit = ... instance Lit 'DBText where lit = ... (I am modelling the interaction with remote relational databases, to provide a little more context) Now when I export this, I end up with the following: Fine, not much needs to change there. Haddock now also gives me specialised types for instances, but these don't go far enough: Instances Lit BaseType DBInt Methods lit :: Col (TYPE Lifted) DBInt (AsHaskell DBInt) exprType -> Expr DBInt exprType But this is considerably less helpful: First, it seems to be broken, as it mentions the exprType variable, when is just DBint. Secondly, it mentions all sorts of kinds which are, in my opinion, unreadable in the current form. All of these problems would be solved if we just normalised this type family application as far as possible. What I *really* want to export is: Instances Lit DBInt Methods lit :: Int -> Expr DBInt This is the type I want my users to be aware of. Has this been discussed before? If not, how do people feel about this? Ollie

2 2

Storing big datasets
by Mikhail Volkhov 08 May '16

08 May '16

Hi! I'm using ACID package as main database -- it's simple and... ACID (which is cool of course). So now I need to store up to ~30GB of data in a single data structure (!) that will be constantly updated (some kind of a huge tree set). Here's a question -- how to operate that big structure? 1. It doesn't even fit in RAM 2. It should be updated atomically and frequently (every 10 seconds up to 500 elements out of 10^7). 3. What structures should I use? I'd like to store up to 10^6~10^7 some simple elements there too, that will be gigabytes of data. So it seems to me I can't use Data.Set. Thanks for any ideas! -- Volkhov Mikhail M3#38 ITMO study group 17' Computer Technologies Department

6 13

The maths behind the Fastest Fibb In The West.
by Michael Litchard 07 May '16

07 May '16

I've been working on a project that needs a good fibonacci generator, and I'm to the point where can now improve upon this one: https://wiki.haskell.org/The_Fibonacci_sequence#Fastest_Fib_in_the_West thanks to this guy: https://groups.google.com/forum/#!topic/haskell-cafe/HUgbAUCvCp4 He suggested breaking up a guard into two diffeent functions, which I can do, but I don't know what to call them because I don't know why the operations are different. I'm referring to this section: fib' (f, g) p | p = (f*(f+2*g), f^2 + g^2) | otherwise = (f^2+g^2, g*(2*f-g)) I'd like to know the reason why each guard does two entirely different things, so I know what to call the functions when I seperate them out.

2 3