- Haskell-Cafe - Haskell.org

7.10.2 : Compilation slowdown.
by aditya siram 01 Oct '15

01 Oct '15

Hi all, Since upgrading to 7.10.2 from 7.8.4 I'm seeing a significant increase in compilation time. I understand this is a known issue but since I'm seeing something like a 3x slowdown but not across the board, I thought I'd ask. Compilation time for the library I'm writing has remained about the same. I am seeing the slowdown when compiling executables that use the library. There are no other dependencies except base so I'm guessing it something in my library causing the issue. I lean heavily on the FFI, OverlappingInstances and HList style programming in my library which leads me to believe that one of these is causing it. I am seeing no difference in compilation speeds by adding the per instance OVERLAPPING pragmas. Can anyone advise or instruct me on how to profile the compiler? Thanks! -deech

3 4

ANNOUNCE: Megaparsec – an improved and actively maintained fork of Parsec
by Artyom 01 Oct '15

01 Oct '15

Hello! I'd like to announce the release of Megaparsec, a fork of Parsec that has been in the works for the past 2 months. There's a lot of improvements and bugfixes under the hood – as well as a new test suite with 128 Quickcheck tests covering 80% of code (Parsec has only 3 tests, by the way) – but first I'd like to explain why a fork was needed, since forking a popular library is a pretty drastic measure and should be accompanied by an explanation. (A disclaimer: I've been given permission to announce the library, but I'm neither the author nor an expert on parsing.) Hackage: https://hackage.haskell.org/package/megaparsec Changelog (including a list of differences from Parsec): https://hackage.haskell.org/package/megaparsec/changelog Github: https://github.com/mrkkrp/megaparsec If you ever had any ideas about what Parsec should've done differently, or what amazing new combinators it should include, etc., post your ideas here: https://github.com/mrkkrp/megaparsec/issues Why fork Parsec instead of writing a new library ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ There are many parsing libraries on Hackage; Parsec was one of the first to appear, and it's still the one that is recommended to beginners when they ask about doing parsing in Haskell. Most other libraries aren't exactly trying to compete with Parsec – instead they explore new directions. Like it or not, it remains a fact that a lot of people are being recommended Parsec, a lot of people are using Parsec, and a lot of people will probably continue to use Parsec since there's no clear alternative to it. Writing a new and *different* library probably won't change it. Even new and *similar* libraries (trifecta and attoparsec are similar enough) haven't removed the need for Parsec, only mitigated it somewhat. Perhaps one day trifecta or something else will completely replace Parsec, but right now we still have to put up with Parsec. So, what we need (or at least what would be nice to have) is simply a better Parsec. What's wrong with original Parsec ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Parsec's development has stagnated long ago; you'd have a hard time getting your pull request merged, even if the only thing it does is fixing a typo (I'm not even talking about anything more controversial than that). Parsec isn't perfect or bug-free, and there *is* a need for those pull requests – just look at its Github page, where you'll find 8 unmerged PRs (and 9 open issues): https://github.com/aslatter/parsec In addition to things that could be fixed but simply aren't, there are some inconveniences (and bugs!) that are hard to fix without breaking backwards compatibility: * “notFollowedBy eof” will just silently not do what you expect it to do (a bug old enough to be considered an undocumented feature) * “<|>” and “many” are redefined and so importing Text.Parsec clashes with Control.Applicative (this can't be trivially fixed in Parsec because its “<|>” has different precedence from Control.Applicative's “<|>”) * you can't wrap Parser into monad transformers (I'm talking about things like “WriterT [String] Parser a” – if this was possible, there'd be no need for “user state” baked into ParsecT) * “Text.Parsec.Token” is not flexible enough for many needs; if you depend on it, one day you may find that you have to copy the whole module to get the behavior you want (look at https://github.com/aslatter/parsec/issues/15 and https://github.com/aslatter/parsec/issues/24, for example). In short, there may be a lot of value in improving Parsec – and that's where Megaparsec comes in. What is Megaparsec and how is it different ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Megaparsec “reboots” the development of Parsec. It's not backwards compatible, but it *is* compatible enough to avoid having to rewrite all Parsec tutorials, and code written for Parsec can be converted to use Megaparsec pretty mechanically. Given that, I would recommend using Megaparsec instead of Parsec from now on, unless you need compatibility with GHCs older than 7.10. Here is a detailed account of some of the bigger changes: === Error reporting === Megaparsec's errors messages are significantly more accurate than Parsec's in some cases, as the following demonstration shows. Parsec: > parseTest (try (string "let") <|> string "lexical") "le" parse error at (line 1, column 1): unexpected end of input expecting "lexical" Megaparsec: > parseTest (try (string "let") <|> string "lexical") "le" parse error at line 1, column 1: unexpected "le" expecting "let" or "lexical" And here's another one, showing off how sometimes “try a <|> b” is a bit less harmful than usual. Just in case, I'm talking about this blog post: http://blog.ezyang.com/2014/05/parsec-try-a-or-b-considered-harmful/ If you don't want to read it in full, the gist of it is that if you use “try” too liberally, Parsec's error messages become much worse than they could be. In this example, we're trying to parse a simple version of Haskell's import statements, which can look either as “import Foo” or “import qualified Foo as B”. If you write a parser like this: try pQualifiedImport <|> pImport you will get an uninformative error message on the following input: import qualified Foo s B Specifically, the “try pQualifiedImport” branch will fail, and then the “pImport” branch will stumble upon “qualified” – while the actual error isn't there, but in misspelled “as”. The advice given in the blog post (“The scope of backtracking try should be minimized”) is good, and applies to Megaparsec just as well as it applies to Parsec. However, a curious thing is that in this particular case Parsec *should* be able to tell you that the error is in misspelled “as”, because Parsec implements the longest match rule – errors that occur later in text are given precedence over errors that occur earlier. The code is there, but somehow it doesn't do what it's supposed to do (and Megaparsec fixes that). Here's the code from the article, rewritten for Megaparsec: import Text.Megaparsec import qualified Text.Megaparsec.Lexer as L data Stmt = QualifiedImport String String | Import String deriving (Show) pStmt = try pQualifiedImport <|> pImport pImport = do keyword "import" Import <$> upperCaseIdentifier pQualifiedImport = do keyword "import" keyword "qualified" QualifiedImport <$> upperCaseIdentifier <*> (keyword "as" *> upperCaseIdentifier) upperCaseIdentifier = lexeme $ (:) <$> upperChar <*> many (alphaNumChar <|> oneOf "_.") lexeme = L.lexeme (hidden space) keyword = L.symbol (hidden space) And here are the error messages it produces. Megaparsec: > parseTest (pStmt >> eof) "import qualified Foo s B" parse error at line 1, column 22: unexpected 's' expecting "as" Parsec (with minor modifications): > parseTest (pStmt >> eof) "import qualified Foo s B" parse error at (line 1, column 8): unexpected "q" expecting uppercase letter === Integration with monad transformers === The key type of Parsec is “ParsecT” (others, such as “Parsec” and “Parser”, are just type synonyms). It lets you use parsers with other monads – for instance, if you use “ParsecT String () IO”, you can have IO in your parsers. This is the reason, by the way, why “char” has the type char :: Stream s m Char => Char -> ParsecT s u m Char instead of a simpler char :: Char -> Parser Char (If it was the latter, you wouldn't be able to use “char” and IO in the same parser.) However, even this type isn't general enough for all things you might want to do. Imagine that you want some parsers to generate warnings when they are run, and later you want to collect those warnings and do something with them. This sounds like what Writer was invented for, so you try to use it. Now all your parsers have this type: ParsecT String () (Writer [Warning]) (Where “Warning” is, say, a synonym for String.) Unfortunately, this is not how you should've composed ParsecT and Writer, because this way you don't get backtracking – in other words, if you try to do optional (try someParser) and someParser generates warnings but then fails, “optional” won't be able to make them disappear – they will still be recorded. Same with State – if you do x <* notFollowedBy y and “y” changes the state, this change will be recorded even tho it's not what you want most of the time. (You can use Parsec's internal state and it *will* work, but it doesn't help you when you want to use Writer or something else instead of State.) What you want in such situations is WriterT [Warning] Parser () StateT YourState Parser () ... but you can't get it because “char” and all other primitive parsers simply don't have those types. With Parsec, the only solution is to apply “lift” to all parsers you want to use, which is pretty annoying. Megaparsec solves this by introducing an mtl-style “MonadParsec” class, making primitive parsers members of this class, and providing instances of MonadParsec for various monad transformers. (If you have ever used the ‘parsers’ library, you may recognise this approach.) I think being able to get backtracking behavior without relying on inelegant ways like “Parsec user state” is pretty neat, even if it's not something every Parsec user needs. === Lexing === Parsec has a lexing module (Text.Parsec.Token): http://hackage.haskell.org/package/parsec/docs/Text-Parsec-Token.html If you're not familiar with lexing, the idea is as follows. When you are parsing a programming language, you often have to solve the same set of problems – parsing numbers, string literals (with all those escaping rules), identifiers/operators/keywords, comments, making all parsers handle whitespace (since there can be whitespace between pretty much any 2 tokens), and so on. With “Text.Parsec.Token” you could just specify what counts as whitespace, as a comment, as an identifier character, etc. and get a set of parsers “for free”. Parsec achieves this by defining a huge structure called “GenLanguageDef” that contains the specification of your language: data GenLanguageDef s u m = LanguageDef { commentStart :: String, commentEnd :: String, commentLine :: String, nestedComments :: Bool, identStart :: ParsecT s u m Char, identLetter :: ParsecT s u m Char, opStart :: ParsecT s u m Char, opLetter :: ParsecT s u m Char, reservedNames :: [String], reservedOpNames :: [String], caseSensitive :: Bool } Then you use “makeTokenParser” on it to generate another huge structure containing lots of useful parsers: makeTokenParser :: GenLanguageDef ... -> GenTokenParser ... data GenTokenParser s u m = TokenParser { identifier :: ParsecT s u m String, operator :: ParsecT s u m String, charLiteral :: ParsecT s u m Char, stringLiteral :: ParsecT s u m String, natural :: ParsecT s u m Integer, integer :: ParsecT s u m Integer, float :: ParsecT s u m Double, lexeme :: forall a. ParsecT s u m a -> ParsecT s u m a, parens :: forall a. ParsecT s u m a -> ParsecT s u m a, braces :: forall a. ParsecT s u m a -> ParsecT s u m a, comma :: ParsecT s u m String, colon :: ParsecT s u m String, ... } What's the problem with this approach? It's very inflexible – the moment you want to change something that wasn't supposed to be changed, you're on your own. Do you want to special-case “-- |” comments to use them as doc strings? The easiest solution is to copy the whole module into your own project: https://github.com/aslatter/parsec/issues/15 Do you want to handle newlines by yourself (for instance, to allow them to be expression separators)? The easiest solution is to fork Parsec: https://github.com/aslatter/parsec/issues/24 (Even if those turn out not to be the easiest solutions, it's still somewhat telling that they were what the authors ended up with.) Megaparsec uses a simpler, more flexible approach. See the docs here: https://hackage.haskell.org/package/megaparsec/docs/Text-Megaparsec-Lexer.h… The linked module provides 3 categories of functions: * “integer”, “decimal”, “float”, “charLiteral”, etc are generic parsers that you can use to parse... well, things that they are named after. Some of those – like “integer” – are occasionally useful even if you're not parsing any languages (how often did you have to write “read <$> many1 digit”? now you don't have to). * “skipLineComment” and “skipBlockComment” generate comment parsers, and “space” combines them together. You can make comment parsers arbitrarily complex before passing them to “space”, or you can write your own space-skipping combinator. * “lexeme”, “symbol”, and “symbol'” make lexemes out of things; a lexeme, by convention, expects no leading whitespace and skips all trailing whitespace. So, instead of having parsers being passed to each other under the hood, you now have to pass them by yourself – except that you don't actually have to do much passing, because you can just write import qualified Text.Megaparsec.Lexer as L lexeme = L.lexeme space symbol = L.symbol space and off you go: keyword = label "keyword" . symbol parens = between (symbol "(") (symbol ")") ... etc ... How you can help ~~~~~~~~~~~~~~~~ * Take a project, modify it to use Megaparsec, file an issue if you've encountered any difficulties. * Take a Parsec tutorial and rewrite it for Megaparsec. (And then please send an email so that a link to your tutorial could be added to the README file.) * As I've already mentioned before, if you have any ideas about what could be changed/improved in Parsec, they likely apply to Megaparsec as well – propose them on the issue tracker. * Report typos in documentation (same goes for mistakes, unclear phrasing, etc). If you're shy (like me) and don't like opening issues, just ping me on IRC (I'm “indiagreen” on Freenode) if you spot anything.

6 6

SURVEY: How do you use Hackage?
by Rick Dzekman 01 Oct '15

01 Oct '15

I recently posted some criticisms of the Haskell User Experience on my site. Afterwards Greshom B. and I had a brief chat over email about any recommendations I had. I suggested that the first step in improving the User Experience of any product is research. I think Hackage is something that needs looking at and we agreed that getting some qualitative data was really important. This survey is an attempt to find out how different people use Hackage. If you're able to participate in the survey, you can either submit a response on this webform <https://docs.google.com/forms/d/1YTqI4BNTQ5PHipsJqxvPMnLsxvz6GA_yHm_fO6RhK8…> or submit a response on Reddit <https://www.reddit.com/r/haskell/comments/3n0vaw/survey_how_do_you_use_hack…> . If you have any questions or comments please feel free to email: haskell-usability-survey(a)haskell.org Thanks, Rick Dzekman

1 0

Re: [Haskell-cafe] Haskell-Cafe Digest, Vol 145, Issue 41
by David Banas 30 Sep '15

30 Sep '15

Thanks for your reply, Tom. That last expression doesn’t seem to have the correct type: Prelude Control.Applicative> let l1 = \x f -> pure f <*> x Prelude Control.Applicative> :t l1 l1 :: Applicative f => f a -> (a -> b) -> f b Prelude Control.Applicative> let l2 = \x f -> fmap f x Prelude Control.Applicative> :t l2 l2 :: Functor f => f a -> (a -> b) -> f b Prelude Control.Applicative> let l3 = \x f -> ($ x) <*> pure f Prelude Control.Applicative> :t l3 l3 :: a1 -> a -> (a1 -> a -> b) -> b Is there a typo? Thanks, -db On Sep 29, 2015, at 9:08 AM, haskell-cafe-request(a)haskell.org wrote: > Message: 2 > Date: Tue, 29 Sep 2015 16:40:38 +0100 > From: Tom Ellis <tom-lists-haskell-cafe-2013(a)jaguarpaw.co.uk> > To: haskell-cafe(a)haskell.org > Subject: Re: [Haskell-cafe] Question, re: Typeclassopedia Ex. 4.2.1 > Message-ID: <20150929154037.GS14111@weber> > Content-Type: text/plain; charset=us-ascii > > On Tue, Sep 29, 2015 at 07:48:05AM -0700, David Banas wrote: >> pure (flip ($)) <*> x <*> pure f = (interchange) >> pure (flip ($)) <*> pure ($ f) <*> x = (homomorphism) > > For one thing, this step doesn't look right. <*> does not associate that > way. > > It's probably worth at least putting each expression into ghci to check they > have the same time > > Prelude> import Control.Applicative > Prelude Control.Applicative> let l = \x f -> pure (flip ($)) <*> x <*> pure f > Prelude Control.Applicative> :t l > l :: Applicative f => f a -> (a -> b) -> f b > Prelude Control.Applicative> let l2 = \x f -> pure (flip ($)) <*> pure ($ f) <*> x > Prelude Control.Applicative> :t l2 > l2 :: Applicative f => f (((a -> b1) -> b1) -> b) -> a -> f b > > I imagine you're probably going to want to go via ($ x) rather than ($ f), > and possibly use that 'pure f <*> x = fmap f x = ($ x) <*> pure f'. > > Tom

1 0

Initial public release of Haskell bindings for SLEPc
by Marco Zocca 30 Sep '15

30 Sep '15

Dear all, I have published the first version of my Haskell bindings for the SLEPc parallel eigenproblem library; it's available at https://github.com/ocramz/slepc-hs So far, only the most basic functionality is wrapped, and there is no exception control or high-level types and combinators, but it showcases a number of aspects of Haskell foreign-function interface design (using `inline-c`). I am also developing Haskell bindings for PETSc, thanks to the similar design of the two libraries, and I hope to release it before the end of the year. My biggest hope however is to contribute to the conversation between the functional programming and high-performance computing communities, as I feel the expressiveness and correctness guarantees provided by the former can be of great advantage to the latter. I look forward to your feedback; Kind regards, Marco Zocca

1 0

Haskell Weekly News
by Kim-Ee Yeoh 30 Sep '15

30 Sep '15

*Top picks:* - Neil Mitchell reports a stack overflow with 7.10.2 maximumBy <https://ghc.haskell.org/trac/ghc/ticket/10830> that regresses from 7.8.3. His sixth sense points to the Foldable-Traversable coup <https://ghc.haskell.org/trac/ghc/wiki/Prelude710/FTP> (aka BBP: Burning Bridges Proposal) as culprit. Joachim Breitner investigates and verifies that the bug's indeed caused by BBP's redefinition of maximumBy that changed out foldl1 for foldr1. Neil guesses that with foldl1, "the strictness analysis managed to kick in and optimise things." Joachim opines that "this is more a BBP design issue than a compiler bug." For now, roll your own maximumBy if you're affected. - A reddit question <https://www.reddit.com/r/haskell/comments/3jvyf7/services_for_learners/> asks whether there's a way for "haskell learners to learn haskell from haskell gurus, one-on-one for a fee?" An answer points to CodeMentor <https://www.codementor.io/haskell-experts> where haskellers charge from $15 to $60 per quarter-hour of consultation. Heinrich Apfelmus chimes in to say he's at HackHands <https://hackhands.com/>. - Yair Chuchem, who worked at Google for a year, reveals <https://www.reddit.com/r/haskell/comments/3ij91q/who_works_at_google_and_ho…> how a software engineer's performance metric is gamed to the detriment of the Organizer of the World's Information. Not quite Wally's "I'm gonna write me a new minivan this afternoon" <http://dilbert.com/strip/1995-11-13> but close. To the indignation of his managers, Yair left Google to work with Eyal Lotem on his passion: an Abstract-Syntax-Tree-driven IDE called Lamdu <http://peaker.github.io/lamdu/>, which redditors have already unpacked here <https://www.reddit.com/r/haskell/comments/3k8ek3/lamdu_blog_designing_progr…> . - Ph.D. student Rob Zinkov <http://zinkov.com/posts/2015-08-25-building-a-probabilisitic-interpreter/> demoes a rudimentary Probabilistic Programming Interpreter based on importance sampling. *Quotes of the Week:* - User kyllo on HN: <https://news.ycombinator.com/item?id=10276498#up_10277862> It's an exciting time for Haskell developers right now, we just got an a awesome new build tool (stack), an incredible new server-side framework (servant) and our compile to JS tool (GHCJS) is improving by leaps and bounds. - @gfixler: Was OOP created as a business model to sell complex tooling? @jonruttenberg: <https://twitter.com/jonruttenberg/status/638329205483249664> @gfixler Was #haskell created as a business model to sell complex blog posts? - User breadbox on HN observes: <https://news.ycombinator.com/item?id=10122333#up_10126413> "People think that confidence follows skills, but it’s usually the other way around where skills follow confidence." This is a fact that really needs to be more widely acknowledged. (It also casts the microagressions that have the effect of chipping away at the confidence of women and minorities in a rather uncomfortable light.) - User mgrennan on HN: <https://news.ycombinator.com/item?id=10122784#up_10123667>I understand it is our nature to push away from parents to strike out on our own. I also understand why older people resist change. Magic happens when the young seek to understand the wisdom of their elders and elders hold on to explorer spirit of their youth. -- Kim-Ee

1 0

Haskell Engineer Needed for Machine Learning Startup
by Charles Weitzer 30 Sep '15

30 Sep '15

Voleon Capital Management LP is a startup quantitative hedge fund located in Berkeley, California. We would like to hire a senior software engineer with strong functional programming experience as soon as possible. Voleon's founders previously worked together at one of the most successful quantitative hedge funds in the world. Our CEO has a PhD in Computer Science from Stanford and has been CEO and founder of a successful Internet infrastructure startup. Our Chief Investment Officer has a PhD in Statistics from Berkeley. Voleon's team includes PhD's from leading departments in statistics, computer science, and mathematics. We have made several unpublished advances in the field of machine learning and in other areas as well. Here is our formal job description: ********************************************************** * Senior Software Engineer * Technology-driven investment firm employing cutting-edge statistical machine learning techniques seeks an exceptionally capable software engineer. You will architect and implement new production trading systems, machine learning infrastructure, data integration pipelines, and large-scale storage systems. The firm researches and deploys systematic trading strategies designed to generate attractive returns without being dependent on the performance of the overall market. Join a team of under 30 people that includes a Berkeley statistics professor as well as over ten PhD's from Berkeley, Chicago, CMU, MIT, Princeton, Stanford, and UCLA, led by the founder and CEO of a successful Internet infrastructure technology firm. The firm's offices are walking distance from BART and the UC Berkeley campus in downtown Berkeley, California. We have a casual and collegial office environment, catered lunches, and competitive benefits packages. We seek candidates with a proven track record of writing correct, well-designed software, solving hard problems, and delivering complex projects on time. You should preferably have experience designing and implementing fault-tolerant distributed systems. Experience with building large-scale data infrastructure, stream processing systems, or latency-sensitive programs is a bonus. We are growing rapidly. Willingness to take initiative and a gritty determination to productize are essential. Required experience: - strong experience developing in a functional programming environment (Haskell, Erlang, others). - developing with C/C++/Python/Go in a Linux environment with a focus on performance, concurrency, and correctness. - working in TCP/IP networking, multi-threading, and server development. - working with common Internet protocols (IP, TCP/UDP, SSL/TLS, HTTP, SNMP, etc.). - architecting and designing highly available systems. - architecting and designing large-scale data management infrastructure. - working in large codebases and building modular, manageable code. Preferred experience.: - debugging and performance profiling, including the use of tools such as strace, valgrind, gdb, tcpdump, etc. - working with build and test automation tools. - working with well-defined change management processes. - diagnosing RDBMS performance problems, exploiting indexing, using EXPLAIN PLAN, optimizing at the code layer, etc. - working with messaging queues (RabbitMQ, Redis, etc.) as well as distributed caching systems. Interest in financial applications is essential, but experience in finance is not a primary factor in our hiring. Benefits and compensation are highly competitive. ********************************************************** The above job description is just a starting point in terms of possible duties and seniority. We can be very flexible for the right person. If you are interested please apply on our website: http://voleon.com/apply/. If you have any questions or if you know of anyone who might be interested, let us know the best way to get in touch and we can discuss details. Thank you, Charles Weitzer Senior Recruiter Voleon Capital Management LP Office: 510.704.9870 x 7012 Mobile: (510) 558-9182 www.Voleon.com<http://www.voleon.com/>

1 0

Data.Foldable.all and empty list
by Lana Black 30 Sep '15

30 Sep '15

Hello, Is there any particular reason why the 'all' function returns True when supplied with an empty list (or any other foldable)? I'm aware that it is implemented via All monoid instance, my question is whether this behaviour is intentional or it can be considered a bug.

5 4

Parsing, infixes and on-the-fly precedence
by Jeffrey Brown 29 Sep '15

29 Sep '15

I imagine a parser that operates on (String,[String]) pairs, for which the second element allows the user to define precedence on the fly. For instance, it would read the pair (x,y) = ("a , b : c", [":" , ","]) as "(a , (b : c))" because y informs the parser that in x the colon binds first, then the comma. I know it is possible, because Haskell does it already! In Haskell we can define novel infix operators on the fly, including their precedence relative to each other. I don't know how, though, so that's my question. -- Jeffrey Benjamin Brown

4 5

Question, re: Typeclassopedia Ex. 4.2.1
by David Banas 29 Sep '15

29 Sep '15

Hi all, In trying to solve exercise 4.2.1 in Typeclassopedia, I’ve come up with the following: To prove: pure f <*> x = pure (flip ($)) <*> x <*> pure f Proof: pure (flip ($)) <*> x <*> pure f = (interchange) pure (flip ($)) <*> pure ($ f) <*> x = (homomorphism) pure (flip ($) ($ f)) <*> x = (definition of flip) pure ($ ($ f)) <*> x = (interchange) x <*> pure ($ f) = (interchange) (Is this step valid?) pure f <*> x Is the last step in my proof valid? Thanks, -db

2 1