Hacker Newsnew | past | comments | ask | show | jobs | submit | taylorfausak's commentslogin

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...


So it's basically as useless for general processing as Markdown, because you won't have a grammar from which you can generate parser, hence all the parsers will be handcoded with various quirks differing from one to another and none of which will produce a parse tree.


I'm baffled. Without a formal grammar CommonMark is useless. Who implements a parser without a formal grammar?


If the syntax has so many issues that you can't specify a formal grammar, there's a problem with the spec.


If it's hard to write a BNF, it's also hard to write a parser.


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".


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...


Personally I do not like underscores. It can get real ugly.

So instead of:

    map3 f ( x, cmd ) ( y, cmd' ) ( z, cmd'' ) =
I will have to write:

    map3 f ( x, cmd ) ( y, cmd_ ) ( z, cmd__ ) =
https://github.com/Fresheyeball/elm-return/pull/4/files#diff...

And it affects package API too: https://github.com/elm-lang/svg/commit/40b761d66b48fcc28f5b5...

However that's just a matter of taste and does not deter me from continuing to use Elm.


Use numbers instead of backticks or underscores. There's a reason we got rid of roman numerals.


My mistake, I thought you were saying I could still have the syntax features I wanted in the language. I like the range syntax, and backticks, and calling functions'. I also liked signals and having access to more stuff that is now 'magic' in the Elm compiler.


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


No, those don't really appeal to me. I think Elm had a great middle ground for a while pre-0.16 with Signals. I'm just disappointed at what I see as a lack of positive change for the language. The more stuff that becomes compiler magic the worse the language is going to get IMO.


> The more stuff that becomes compiler magic the worse the language is going to get IMO.

Not sure what you mean here. Elm 0.18 has less compiler magic, not more.



Yes, but that's not new in 0.18


Did you read my comment? I mentioned the removal of Signals and it's replacement with the 'magic' Html.app


Html.App used to be a namespace, I suspect you mean Program? In any case, how is that any more, or less, magic than Signals? Considering that the compiler has removed syntax in later versions, later versions of Elm has less magic than earlier versions.


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’


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.


I don't think this is a flaw, in fact I think it neatly solves the problem of how to extend the language without committing to a design too eagerly and provides a platform for experimentation.

There are pragmas that GHC implements that are now widely held to be problematic, but we wouldn't know this without an implementation, and using pragmas, we are realistically able to deprecate and remove these extensions.


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


That's not anywhere near a complete list of deprecated extensions and there are others that have been completely removed from the language [1]. It's unfortunate that ScopedTypeVariables hasn't been standardised, but there hasn't been a new standard since 2010, so it's not hugely surprising.

https://ghc.haskell.org/trac/ghc/wiki/LanguagePragmaHistory


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.


I'd expect either Rank2Types or RankNTypes to be included in Haskell', you may be thinking of ImpredicativeTypes.

Wow, I did not realize ScopedTypeVariables had been around for so long.


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


Does PureScript have some alternative approach to growing the language? Or is your comment suffixed with an implicit "for now"? :)


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.


Consider applying for YC's Summer 2026 batch! Applications are open till May 4

Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: