- Haskell-Cafe - Haskell.org

DSLDI 2017: Call for Talk Proposals
by Lindsey Kuper 20 Jun '17

20 Jun '17

********************************************************************* FIRST CALL FOR TALK PROPOSALS DSLDI 2017 Fifth Workshop on Domain-Specific Language Design and Implementation October 22, 2017 Vancouver, Canada Co-located with SPLASH http://2017.splashcon.org/track/dsldi-2017 https://twitter.com/wsdsldi ********************************************************************* Deadline for talk proposals: 7th of August, 2017 Well-designed and implemented domain-specific languages (DSLs) can achieve both usability and performance benefits over general-purpose programming languages. By raising the level of abstraction and exploiting domain knowledge, DSLs can make programming more accessible, increase programmer productivity, and support domain-specific optimizations. ## Workshop Goal Domain-Specific Language Design and Implementation (DSLDI) is a workshop intended to bring together researchers and practitioners interested in discussing how DSLs should be designed, implemented, supported by tools, and applied in realistic contexts. The focus of the workshop is on all aspects of this process, from soliciting domain knowledge from experts, through the design and implementation of the language, to evaluating whether and how a DSL is successful. More generally, we are interested in continuing to build a community that can drive forward the development of modern DSLs. ## Workshop Format DSLDI is a single-day workshop and will consist of an invited speaker followed by moderated audience discussions structured around a series of short talks. The role of the talks is to facilitate interesting and substantive discussion. Therefore, we welcome and encourage talks that express strong opinions, describe open problems, propose new research directions, and report on early research in progress. Proposed talks should be on topics within DSLDI’s area of interest, which include but are not limited to: * solicitation and representation of domain knowledge * DSL design principles and processes * DSL implementation techniques and language workbenches * domain-specific optimizations * human factors of DSLs * tool support for DSL users * community and educational support for DSL users * applications of DSLs to existing and emerging domains * studies of usability, performance, or other benefits of DSLs * experience reports of DSLs deployed in practice ## Call for Talk Proposals We solicit talk proposals in the form of short abstracts (max. 2 pages). A good talk proposal describes an interesting position, open problem, demonstration, or early achievement. The submissions will be reviewed on relevance and clarity, and used to plan the mostly interactive sessions of the workshop day. Publication of accepted abstracts and slides on the website is voluntary. * Deadline for talk proposals: August 7th, 2017 * Notification: September 11th, 2017 * Workshop: October 22nd, 2017 * Submission website: https://dsldi17.hotcrp.com/ ## Workshop Organization Co-chairs: * Lindsey Kuper (lindsey(a)composition.al) Intel Labs * Eric Walkingshaw (eric.walkingshaw(a)oregonstate.edu) Oregon State University Follow us on Twitter at https://twitter.com/wsdsldi Program committee: * Nada Amin (EPFL/University of Cambridge) * Eric Holk (Google) * Gabriele Keller (Data61, CSIRO (formerly NICTA) and UNSW) * Rebekah Leslie-Hurd (Intel Labs) * Chris Martens (NCSU) * Lee Pike (Galois) * Jonathan Ragan-Kelley (UC Berkeley) * Jesús Sánchez Cuadrado (Autonomous University of Madrid) * Vincent St-Amour (Northwestern University) * Philip Wadler (University of Edinburgh)

1 0

[Announcement] Haskell game for iOS
by Ivan Perez 20 Jun '17

20 Jun '17

Dear all (I hope this is not seen as spam. My sincere apologies if you see it as such.) This is just to let you know that we have released a Haskell game for iOS on the App Store. https://itunes.apple.com/us/app/magic-cookies/id1244709871 There is also an Android version [1]. It's the same Haskell code with just a few minor adaptations [2] (the iOS version is actually simpler). Issues with either version can be reported online [3]. I hope this is seen as yet another step reached by Haskell. This game is written in the FRP variant Yampa, and uses SDL2 for graphics. While the game is not open source, we've had to extend existing Haskell libraries and tools to make this possible. These changes will now be sent as pull requests to the corresponding projects. We have also developed in-house tooling to make the development, compilation and deployment process for mobile platforms smooth [4]. Recompiling and deploying a new version online is now automatic and takes less than 1 minute. These tools also run directly on Travis and publish new versions of our games directly to stores. We have already started distributing our toolchain to private users, and our plan is to release immediately. We'd like to thank all the users who tried the game before the release, many during Zurihac last weekend. Also, many thanks to the people who worked on GHC and the ARM backends over the years, and to all those who work daily to make Haskell better. We really mean that. Once again, I hope this is not seen as spam, but as something worth celebrating. And, also, that you enjoy playing. Best wishes Ivan -- Keera Studios [1] https://play.google.com/store/apps/details?id=uk.co.keera.games.magiccookies [2] https://www.facebook.com/keerastudios/photos/a.301326223216244.89053.300854… [3] https://github.com/keera-studios/magic-cookies [4] http://keera.co.uk/blog/2017/06/01/haskell-android-ios/

4 3

Master programme with Haskell prospects
by Georgi Nakov 20 Jun '17

20 Jun '17

Hi all, I was pondering on Master programme with "good" Haskell-related prospects upon completion (regardless whether it's in academia or industry). Currently the only options available to me are Master in Logic at University of Amsterdam and Computing Science at Utrecht. The latter has more emphasis on FP and Haskell while the former seems more concerned with the mathematical/philosophical foundations. Any thoughts or direct observations on these programmes would be greatly appreciated. Thanks. Best regards, Georgi

3 2

Vancouver Haskell Meetup session - Jun 22, 2017
by Román González 20 Jun '17

20 Jun '17

Dear All, I'm happy to announce there will be a Haskell Meetup that is going to be held at Unbounce HQ this Thursday, Jun 22, 2017 This is intended to be a Newcomer friendly session, so basics of Why Haskell and Haskell used in production will be the main topics of the event. If you live in Vancouver, would hope to see you there. https://www.meetup.com/Vancouver-Haskell-Unmeetup/ Cheers. Roman.-

1 0

Re: [Haskell-cafe] MultiCase alternative
by Oleg 20 Jun '17

20 Jun '17

Richard A. O'Keefe wrote: > Let Pi be the pattern (i,_) | (_,i) > In SML, > fun f P1 ... Pn (0,0) = true > | f _ ... _ _ = false > > fun g () = f (1,1) (2,2) ... (n,n) (1,1) > > (So far it has taken 3 minutes on a fast machine to not > > finish compiling these 3 lines of code... I fear the worst.) I can't speak for SML, but I was curious to try your example in OCaml, which also supports OR patterns. Here is how it looks in OCaml: let f = function ((1,_)|(_,1)), ((2,_)|(_,2)), ((3,_)|(_,3)), ((4,_)|(_,4)), ((5,_)|(_,5)), ((6,_)|(_,6)), ((7,_)|(_,7)), ((8,_)|(_,8)), (0,0) -> true | _ -> false ;; let g () = f ((1,1),(2,2),(3,3),(4,4),(5,5),(6,6),(7,7),(8,8),(1,1)) ;; let _ = g ();; It compiled instantly. I was curious what it is compiled to. Enclosed in the result, in an intermediate language called Lambda (before optimizations). It seems the size of the code is linear in n. Not too bad. BTW, match/1207 is the identifier called match with the timestamp 1207. The timestamps tell distinct identifiers with the same given name apart. Also, 1a means true and 0a means false (and also unit and the empty list). >From personal experience, OR patterns are quite handy when handing an AST where many of the alternatives are to be handled the same. That said, supporting OR patterns in MetaOCaml was responsible for some of the most complex code there. ocamlc -c -dlambda p.ml (setglobal P! (let (f/1199 = (function param/1206 (let (match/1207 =a (field 0 param/1206)) (catch (catch (if (!= (field 0 match/1207) 1) (if (!= (field 1 match/1207) 1) (exit 1) (exit 2)) (exit 2)) with (2) (let (match/1227 =a (field 1 param/1206)) (catch (if (!= (field 0 match/1227) 2) (if (!= (field 1 match/1227) 2) (exit 1) (exit 4)) (exit 4)) with (4) (let (match/1245 =a (field 2 param/1206)) (catch (if (!= (field 0 match/1245) 3) (if (!= (field 1 match/1245) 3) (exit 1) (exit 6)) (exit 6)) with (6) (let (match/1261 =a (field 3 param/1206)) (catch (if (!= (field 0 match/1261) 4) (if (!= (field 1 match/1261) 4) (exit 1) (exit 8)) (exit 8)) with (8) (let (match/1275 =a (field 4 param/1206)) (catch (if (!= (field 0 match/1275) 5) (if (!= (field 1 match/1275) 5) (exit 1) (exit 10)) (exit 10)) with (10) (let (match/1287 =a (field 5 param/1206)) (catch (if (!= (field 0 match/1287) 6) (if (!= (field 1 match/1287) 6) (exit 1) (exit 12)) (exit 12)) with (12) (let (match/1297 =a (field 6 param/1206)) (catch (if (!= (field 0 match/1297) 7) (if (!= (field 1 match/1297) 7) (exit 1) (exit 14)) (exit 14)) with (14) (let (match/1305 =a (field 7 param/1206)) (catch (if (!= (field 0 match/1305) 8) (if (!= (field 1 match/1305) 8) (exit 1) (exit 16)) (exit 16)) with (16) (let (match/1311 =a (field 8 param/1206)) (if (!= (field 0 match/1311) 0) (exit 1) (if (!= (field 1 match/1311) 0) (exit 1) 1a)))))))))))))))))) with (1) 0a))) g/1201 = (function param/1205 (apply f/1199 [0: [0: 1 1] [0: 2 2] [0: 3 3] [0: 4 4] [0: 5 5] [0: 6 6] [0: 7 7] [0: 8 8] [0: 1 1]]))) (seq (apply g/1201 0a) (makeblock 0 f/1199 g/1201))))

2 1

Re: [Haskell-cafe] Probabilistic programming in Haskell with bali-phy
by dominic＠steinitz.org 19 Jun '17

19 Jun '17

> While we're mentioning Haskell-embedded languages for probabilistic > programming, there is yet another, Hakaru. > > github: https://github.com/hakaru-dev/hakaru > docs: https://hakaru-dev.github.io/ > hackage: https://hackage.haskell.org/package/hakaru-0.4.0 > > It can be used either embedded or via an external syntax. It can act as > a sampler, but also do code generation (to Haskell, to C, more coming), > simplification (via Maple if it is installed) and disintegration (aka > conditioning). > > It uses quite a number of advanced Haskell features (though works in 7.8 > onwards) to insure safety of the embedded language. See > https://hackage.haskell.org/package/hakaru-0.4.0/docs/Language-Hakaru-Synta… > if you are curious about that. > > Jacques There are production strength PPLs like Stan and PyMC3. They aren’t Haskell but if you actually want to model something then they are my “go to” tools. There’s also LibBI which uses Sequential Monte Carlo rather than Hamiltonian Monte Carlo. Stan and LibBI are C++ with interfaces (I use the word very loosely) from e.g. R, Python, Matlab, etc. PyMC3 as you might guess is entirely Python. Both have very good communities. In Haskell there is also monad-bayes https://github.com/adscib/monad-bayes <https://github.com/adscib/monad-bayes> and baysig, the latter sadly not publicly available (last time I checked). If you have a hidden state model (e.g. stochastic volatility) then there is also particle filtering (aka Sequential Monte Carlo) using https://hackage.haskell.org/package/kalman-1.0.0.2 <https://hackage.haskell.org/package/kalman-1.0.0.2>. I just looked at the commit log for monad-bayes and it seems to use HMC these days :) and supports ADVI. I spent a bit of time at the recent Zurihac with Alexander Vershilov making some very small steps towards a symplectic integrator package which could form the basis for HMC in Haskell. Dominic Steinitz dominic(a)steinitz.org http://idontgetoutmuch.wordpress.com

1 0

MultiCase alternative
by Baa 19 Jun '17

19 Jun '17

Hello, Everyone! As I understand "MultiCase" proposal was not approved, so my question is: is there alternatives to multi-case? I have code like: case x of A a -> .. B b -> .. C c -> --same-- D c -> --same-- and I want to merge code of "C c" with "D c" branch. Anywhere, in general: is any alternatives to make "OR"s in patterns? I don't see how to do it with pattern guards, pattern synonyms, views extensions and don't see another related extensions. Something like "(C|D) c -> ..." === Best regards, Paul

12 24

Re: [Haskell-cafe] Probabilistic programming in Haskell with bali-phy
by Oleg 18 Jun '17

18 Jun '17

It seems worth mentioning then another Haskell embedded language for probabilistic programming http://okmij.org/ftp/kakuritu/Hakaru10/index.html It also lets us write probabilistic models as Haskell programs. It supports both discrete and continuous distributions, conditioning, as well as branching (mixing models). It takes care to statically preclude senseless models (forcing conditioning only on external data). The 'Model' is *not* a monad. Not everything can be or should be a monad. Hakaru10 also takes care to avoid the problems that are frequent in implementations of Wingate algorithms. It also uses incremental evaluation. As to semantic problems of probabilistic programming languages, http://okmij.org/ftp/kakuritu/index.html shows a couple of them.

4 5

Announce: Probablistic programming in Haskell with bali-phy
by Benjamin Redelings 17 Jun '17

17 Jun '17

Hi, I'm working on a project to implement support for probabilistic programming with models written as Haskell programs. This is similar to Bayesian graphical models (e.g. BUGS, JAGS) and to full probabilistic programming systems like Church / Venture. http://www.bali-phy.org/models.php This project is not very mature, but it is used as the core of the MCMC software mentioned above, which is relatively mature. Probabilistic programs are written using the probability monad. I've implemented a Haskell interpreter in C++ that records execution traces of the Haskell programs. These execution traces depend on some number of (random) variables, and when one of the variables is changed (during MCMC), the parts of the execution trace that depend on the changed variables are invalidated and recomputed. This saves work by not recomputing the probability of the new state from scratch. I can provide DOT graphs of the execution traces if anyone is interested. The problem domain I've been focusing on is evolution of DNA sequences on binary trees. You can see some of the code for that problem domain here: https://github.com/bredelings/BAli-Phy/blob/master/modules/ The code for the interpreter is here: https://github.com/bredelings/BAli-Phy/blob/master/src/computation/ -BenRI

2 3

Issue 59 :: Haskell Weekly
by Taylor Fausak 15 Jun '17

15 Jun '17

\ Haskell Weekly \/\/ Issue 59 <https://haskellweekly.news/issues/59.html> Welcome to another issue of Haskell Weekly! Haskell is a purely functional programming language that focuses on robustness, concision, and correctness. This is a weekly summary of what's going on in its community. ## Featured - Haskell on Android and iOS <http://keera.co.uk/blog/2017/06/01/haskell-android-ios/> > With our framework, writing professional Haskell apps and games becomes a reality. In minutes one can have the complete toolchain and see the first app running on a phone or published on the online store. If you weren't considering using Haskell yet, we hope you soon change your mind. - Translating a C++ parser to Haskell <http://www.haskellforall.com/2017/06/translating-c-parser-to-haskell.html> > Recently I translated Nix's derivation parser to Haskell and I thought this would make an instructive example for how C++ idioms map to Haskell idioms. This post targets people who understand Haskell's basic syntax but perhaps have difficulty translating imperative style to a functional style. - The `ReaderT` design pattern <https://www.fpcomplete.com/blog/2017/06/readert-design-pattern> > What many languages address via patterns, in Haskell we address via language features (like built-in immutability, lambdas, laziness, etc.). However, I believe there is still room for some high-level guidance on structuring programs, which I'll loosely refer to as a Haskell design pattern. - Front Row is hiring a senior backend Haskell engineer (ad) <https://frontrow.workable.com/j/463B843754> > Come change how 6.5+ million K-12 US students learn Math, Language Arts, Social Studies and more. Use data, advanced type systems, great product design and deep pedagogy to change lives. - 10 things Idris improved over Haskell <https://deque.blog/2017/06/14/10-things-idris-improved-over-haskell/> > This post describes some of the pleasant surprises you get trying out Idris, coming from the Haskell world. These pleasant surprises have nothing to do with the dependent typing features. They are simple yet impacting modifications, which improve the developer experience substantially. - Migrating text metrics to pure Haskell <https://markkarpov.com/post/migrating-text-metrics.html> > text-metrics-0.3.0 is written in pure Haskell, almost as fast as the previous versions (especially for not very long inputs), and is more correct (we handle characters represented as two `Word16` values properly). - ZuriHac 2017 recap <https://jship.github.io/posts/2017-06-11-zurihac-recap.html> > This was my first time attending ZuriHac and it was too much fun --- will definitely be back next year! Big thanks to Jasper Van der Jeugt, Simon Meier, and all of the HSR folks that made the event happen. Props to the Haskell community too for being friendly and inviting. - Haddock markup quick reference <https://github.com/aisamanra/haddock-cheatsheet/blob/c3485d33e6bb42beb41c97…> > This page is a single-page quick reference for the markup used in GHC's Haddock documentation format. It doesn't list all the details of the format, just the basic markup, so for the vagaries and edge-cases of the syntax, it would be helpful to consult the Haddock user guide. - Haskell Summer of Code <https://jaredweakly.com/blog/haskell-summer-of-code/> > The performance tests do two things: first, they make sure that when people change the compiler, they don't accidentally make it slower; secondly, they make sure that when people change the compiler, they don't accidentally make the generated code less efficient. - Use hpack <https://e.xtendo.org/haskell/hpack> > One of the remaining problems is that the `project.cabal` file is in a custom format. Custom formats are generally not good because you can't leverage the existing tools and free-ride other people's work. - Haskell taketh away: Limiting side effects for parallel programming <https://www.youtube.com/watch?v=lC5UWG5N8oY> > In designing parallel programming abstractions, taking away user capabilities is as important as granting them. In this talk, I'll explain the role of this idea in several different parallel programming libraries for Haskell, C++, and other languages --- spanning from shared memory to big data. ## Package of the week This week's package of the week is generic-lens, a library that exposes generic data structure operations as lenses. <https://hackage.haskell.org/package/generic-lens-0.2.0.0> ## In brief - Binary instances for GADTs (or: RTTI in Haskell) <https://www.well-typed.com/blog/2017/06/rtti/> - Data structures are antithetical to functional programming <http://degoes.net/articles/kill-data> - Drive-by Haskell contributions <http://ndmitchell.com/downloads/slides-drive-by_haskell_contributions-09_ju…> - On friendly contributing policies <https://ro-che.info/articles/2017-06-12-friendly-contributing-policies> - Taking a close look at lenses <https://mmhaskell.com/blog/2017/6/12/taking-a-close-look-at-lenses> - Teaching Haskell for understanding <https://docs.google.com/presentation/d/1_I5mYXivG5NbOHnICld_Xo41uOyAT57Yade…> - The Haskell Cast episode 14: Richard Eisenberg on dependent types <http://www.haskellcast.com/episode/014-richard-eisenberg-on-dependent-types…>

1 0