June 2017 - Haskell-Cafe

Why can't GHC infer record fields?
by Clinton Mead 23 Jun '17

23 Jun '17

I asked this below question on Stack Overflow <https://stackoverflow.com/questions/44714711/silly-duplicated-record-fields…> and I got an answer suggesting that GHC doesn't support type inference of overloaded record fields. But I'm wondering why this is the case. Consider the following: {-# LANGUAGE DuplicateRecordFields #-} data A = A { name :: String } data B = B { name :: String } main = print $ name (A "Alice") When compiled, I get the following message (on GHC 8.0.2) duplicatedrecords.hs:7:16: error: Ambiguous occurrence ‘name’ It could refer to either the field ‘name’, defined at duplicatedrecords.hs:5:14 or the field ‘name’, defined at duplicatedrecords.hs:3:14 But if I modify the main line as follows: main = print $ name ((A "Alice") :: A) Compilation proceeds successfully. I'm not sure why I need the :: A here, it seems to be clear that (A "Alice") is of type A due to the A constructor. It's worth noting that the following compiles fine: data A = A { a_name :: String }data B = B { b_name :: String } class Name t where name :: t -> String instance Name A where name = a_nameinstance Name B where name = b_name main = print $ name (A "Alice") We can even go further as follows, allowing different result types: {-# LANGUAGE TypeFamilies #-} data A = A { a_name :: String }data B = B { b_name :: Int } class Name t where type family T t name :: t -> T t instance Name A where type T A = String name = a_name instance Name B where type T B = Int name = b_name main = print $ name (A "Alice") It seems like GHC just has to mechanically add a class for each unique record name and an instance for each record in each data type. This will mean however that name x == name y not implying that the types of x and y are the same but I'd expect that when using this extension anyway. Just wondering if there's anything tricky I'm missing here regarding the implementation or that it just needs someone to implement it?

2 1

exceptions, errors, random
by Dennis Raddle 23 Jun '17

23 Jun '17

I am wondering what exception/error and random classes I should use for my application. The application will be doing Monte Carlo backtracking search. I want it to be multithreaded and run on all four cores on my MacBook. I need detailed error messages in order to investigate errors. So I will throw errors or exceptions, then catch them in lower functions and annotate them with the parameters or computations within the lower function, then re-throw until finally the exception pops into the terminal. Because it's multi-threaded, at least some parts will needs to be in IO. Also, because it's a Monte Carlo algorithm it will need to make pseudorandom choices. Perhaps I should put everything in the IO monad? This will give me access to threads and the standard generator seed. But how about throwing, catching/rethrowing exceptions in IO? I have done this in pure code before: not sure if it's better to do it that way, in which case I could put some kind of state monad to hold the random seed together with an error monad and IO at the core of the monad stack. Any advice welcome. D

2 8

Having trouble with this recursive Parsec parser
by Cody Goodman 23 Jun '17

23 Jun '17

Hi all, I'm having trouble with a recursive parsec parser that keeps recursing on one type of end tag and terminates on another type of end tag. I'm sure I'm stuck on something silly, but here's what I have so far. Git repo with stack/cabal project: https://github.com/codygman/megaparsectest/blob/master/library/Example.hs Code I have so far (I deleted a few different approaches I tried because I thought they would clutter things up and make it harder to assist me with this issue): {-# LANGUAGE QuasiQuotes #-} -- | An example module. module Example where import Text.Megaparsec import Text.RawString.QQ import Text.Megaparsec.String -- input stream is of the type ‘String’ import qualified Text.Megaparsec.Lexer as L import Control.Monad (void, join) ex :: String ex = [r| begin field1 string begin field11 int field12 string end subsection; // optional end; |] data Field = Field String String deriving Show data Block = Fields [Field] | Block [Field] deriving Show sc :: Parser () sc = L.space (void spaceChar) lineCmnt blockCmnt where lineCmnt = L.skipLineComment "//" blockCmnt = L.skipBlockComment "/*" "*/" field :: Parser Field field = dbg "field" $ do sc Field <$> someTill ((oneOf' (['a'..'z'] ++ ['0'..'9']))) spaceChar <*> some ((oneOf' (['a'..'z'] ++ ['0'..'9']))) endEof = do sc *> string "end" *> char ';' *> sc *> eof pure "" endIdent = do string "end" *> sc ident <- someTill ((oneOf' (['a'..'z'] ++ ['0'..'9']))) (char ';') sc *> eof pure ident block = error "TODO implement" -- Thanks, -- Cody

1 0

Issue 60 :: Haskell Weekly
by Taylor Fausak 22 Jun '17

22 Jun '17

\ Haskell Weekly \/\/ Issue 60 <https://haskellweekly.news/issues/60.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 ## - Understanding ResourceT <https://www.fpcomplete.com/blog/2017/06/understanding-resourcet> > Instead of just teaching you how to use the library, this post will demonstrate why you need it and how it works internally, to help you avoid some of the potential pitfalls of the library. - Announcing Weeder: dead export detection <https://neilmitchell.blogspot.com/2017/06/announcing-weeder-dead-export-det…> > Most projects accumulate code over time. To combat that, I've written Weeder which detects unused Haskell exports, allowing dead code to be removed (pulling up the weeds). - Dhall is now a template engine <http://www.haskellforall.com/2017/06/dhall-is-now-template-engine.html> > Now you can use Dhall as a template engine with the newly released dhall-text library which provides a dhall-to-text executable for templating text. - Front Row is hiring a senior backend Haskell engineer <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. - Testing PostgreSQL for fun <https://hackernoon.com/testing-postgresql-for-fun-af891047e5fc> > In this post I'll show how to make database programming fun by using packages that make testing easy. I'll walk through a example of building a durable queue backed with PostgreSQL. - Exceptional Servant handling <http://www.parsonsmatt.org/2017/06/21/exceptional_servant_handling.html> > There are various good reasons why you might want to strip ExceptT from your Servant handlers. There are various good reasons why you wouldn't want to do that. I'm in the first camp --- I don't want ExceptT over IO. - On competing with C using Haskell <https://two-wrongs.com/on-competing-with-c-using-haskell> > By writing very straight-forward pure, functional Haskell code without any special trickery, you can get performance equivalent to what you'd get by calling out to a C function, which is also in the same order of magnitude as the same algorithm implemented in a program completely written in C. - How well does it work? Profiling in Haskell <https://mmhaskell.com/blog/2017/6/19/profiling-in-haskell> > This is where benchmarking and profiling come in. We're going to take a specific problem and learn how we can use some Haskell tools to zero in on the problem point. - The chain in blockchain <http://haroldcarr.com/posts/2017-06-19-the-chain-in-blockchain.html> > This post develops a simple blockchain with the goal of understanding the basics of the chain. The most straightforward part of a blockchain is the chain itself, a sequence of blocks. - Mezzo: type-safe music composition <https://github.com/DimaSamoz/mezzo/blob/1d46c5edd5d7d360a027a614c618bb2830d…> > Its novelty is in the fact that it can enforce various rules of music composition statically, that is, at compile-time. This effectively means that if you write "bad" music, your composition will not compile --- think of it as a very strict spell-checker for music. - Linear types 101 and its relevance to streams <https://m0ar.github.io/safe-streaming/2017/06/19/linear-types-101.html> > It creates a resource aware type system, which not only knows types of values but also number of uses; a linearly typed value is guaranteed to only have one reference to it at any time, duplication or ignoring will not compile. ## Package of the week ## This week's package of the week is async, a library that allows you to run IO operations asynchronously and wait for their results. <https://www.stackage.org/lts-8.19/package/async-2.1.1.1> ## In brief ## - An alternate definition of Haskell's Functor type class <https://github.com/rampion/kinder-functor/blob/20e5c57/README.md> - Configurable data types <http://mazzo.li/posts/customizable-data-types.html> - Generic unification <https://ro-che.info/articles/2017-06-17-generic-unification> - The linearity monad <https://www.cis.upenn.edu/~jpaykin/papers/pz_linearity_monad_2017.pdf) (pdf> - A terminal interface for Tetris <https://github.com/samtay/tetris/blob/5d9c74c/README.md>

1 0

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