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

A tiny language called Z: http://chrisdone.com/z/

Cool! Sounds like a wikirace for music. https://en.wikipedia.org/wiki/Wikipedia:Wikirace

You can disable the analytics from within Atom by disabling this package: https://atom.io/packages/metrics

> the paper ignores the reason why people kicked and screamed for the functionality to begin with

No it doesn't. The explicitly talk about this in section 7: "The acceptance of Typed Racket in the commercial and open-source Racket community suggests that (some) programmers find a way around the performance bottlenecks of sound gradual typing."

> Reticulated Python is still an order of magnitude faster than Ruby

Are you suggesting that a slower variant of Python is ten times faster than Ruby? That doesn't match my experience. For what it's worth, Ruby outperforms Python in some benchmarks: http://benchmarksgame.alioth.debian.org/u64q/ruby.html

I know of a tiny language called Z: http://chrisdone.com/z/

I think subtitles are supposed to be placed at particular places on the screen.

That is true. I think you can work around it by prepending a space to the title. So this one would be " cssnext: use tomorrow's CSS syntax, today".

For Haskell in particular, you are better off using Hoogle [1] or Hayoo [2].

[1]: https://www.haskell.org/hoogle/?hoogle=%3E%3D%3E [2]: http://hayoo.fh-wedel.de/?query=%3E%3D%3E

I liked the article, but I did not like the eye in the header blinking at me as I read it.

I thought the engineering category did a good job separating their blog posts: https://github.com/blog/category/engineering

The decisions the Elm team make continue to impress me. I like that they are willing to break from tradition in order to create a better programming environment. In particular, changing the head function to be total is a great move.

    head : List a -> Maybe a

Compare that with the same function in Haskell.

    head :: [a] -> a

To me, the Elm version makes more sense. (It also avoids having to explain that "[a]" means "list of 'a's".)