taylorfausak

To give you a single data point, our Haskell code base at ITProTV is about 50,000 lines of code. Reloading the project after a change in GHCi takes slightly less than one second. We haven't spent any significant effort on speeding up compile speeds, for what it's worth. It's fast enough.

> Rasa is putting extensions first from the very beginning, I've read that Yi has plans to extract their renderers into extensions but hasn't been able to easily extract them at this point. In rasa, EVERYTHING is an extension (for better or worse I suppose we'll see).

https://www.reddit.com/r/haskell/comments/5l0a2i/rasa_modula...

> I named it after the concept of 'tabula rasa' which means roughly 'blank slate' which I thought was fitting for an editor

https://www.reddit.com/r/haskell/comments/5l0a2i/rasa_modula...

From John MacFarlane, the author of the CommonMark spec:

> If anyone wants to contribute a BNF, please do! But I'm very skeptical that it can be done, due to the many quirks of the syntax.

https://github.com/jgm/CommonMark/issues/113#issuecomment-60...

I think it's a little misleading to call that "a while". The post says "156 private repositories" were affected during a "ten-minute window" representing "0.0013% of the total operations at the time".

It sounds like you might like PureScript [1] or GHCJS [2] more than Elm. Have you tried either of those?

[1]: http://www.purescript.org/ [2]: https://github.com/ghcjs/ghcjs

The migration guide [1] suggests that instead of primes you can use underscores. And instead of backticks you can use pipelining.

[1]: https://github.com/elm-lang/elm-platform/blob/11c8ecb81a58b8...

I tried this out in PureScript [1]. I also made each type class have only one member and didn't specify any class hierarchy. I like how it works, but I don't know if anyone else does. It allows you to recreate the category theory type classes [2] if you want to:

    class (HasMap f) <= Functor f
    class (Functor f, HasApply f) <= Apply f
    class (Apply f, HasPure f) <= Applicative f
    class (Apply m, HasChain m) <= Bind m
    class (Applicative m, Bind m) <= Monad m

[1]: https://github.com/tfausak/purescript-neon/blob/v0.5.4/src/N... [2]: https://pursuit.purescript.org/packages/purescript-prelude/1...

That's correct.

    {-# LANGUAGE DuplicateRecordFields #-}
    data A = B { x :: Bool }
           | C { x :: Int }

    Example.hs:2:1: error:
      • Constructors B and C give different types for field ‘x’
      • In the data type declaration for ‘A’

My impression is that PureScript aims to not be configurable. For example, the compiler does not allow you to disable warnings. Other tools, like `psa`, can do that, but the base language is always the same.

Specifically related to language extensions, there is this wiki page: https://github.com/purescript/purescript/wiki/Differences-fr...

> The PureScript compiler does not support GHC-like language extensions.

Sorry, I meant that you pretty much always want RankNTypes instead of Rank2Types. My fault for not specifying.

Thanks for that link! I haven't seen that wiki page before. Even so, only 4 extensions have been removed. I know others are de facto deprecated, like Rank2Types.

I picked scoped type variables as an example because it's been in GHC since version 6.4. That was released in March 2005, so it had plenty of time to make it into the Haskell2010 language standard.

Very few extensions have been deprecated: http://hackage.haskell.org/package/Cabal-1.24.0.0/docs/src/L...

Convenient, widely-used extensions that have been around for a long time aren't yet part of the language standard: https://prime.haskell.org/ticket/67

This post explores the differences in those two styles: http://www.yesodweb.com/blog/2015/10/beginner-friendly-code-...

> It seems like my progression as a Haskeller results in forcing myself to write in a harder-to-parse style to make my code shorter, to satisfy some base need for "better" code, even though by most measurements I just made, the longer/explicit/pattern matching code is in fact better.

This is another flaw that PureScript fixes: No language pragmas.

Nix (and NixOS) are certainly nice to use with Haskell, but Stack is good. The post even says so:

> Stackage solved the consistent set of packages, and Stack made it even easier. I now consider Haskell package management a strength for large projects, not a risk.

You can also build IO on top of the effect system https://github.com/slamdata/purescript-io :)

That doesn't compile to Haskell.

Yes, all functions in Elm also have arity 1. That example desugars into this:

    connectWords = \ firstWord -> \ secondWord -> firstWord ++ secondWord