Comment by hillcapital

1 year ago

They recently changed the syntax to add parens, commas and use `|arg|` for closures :)

https://github.com/roc-lang/roc/releases/tag/0.0.0-alpha2-ro...

24 comments

hillcapital

Reply
3836293648  1 year ago

Are the Roc people really doing everything they can to ruin everything they had going for them? Appealing to those who know nothing and won't be willing to touch anything FP at the cost of annoying those who actually want to try it is just so stupid

darthrupert  1 year ago

I say this as someone who enjoys reading Rust more than Haskell or Elm -- that looks like a really bad idea for aesthetic reasons anyway. I mean if you want the syntax to look like Zig or Rust, perhaps go all the way there instead of making a kind of a mutant hybrid like this. Syntax is superficial and the semantics actually matter, but that doesn't mean the syntax can be just anything.

Is there some deeper technical reason for making such changes?

trescenzi  1 year ago

oh wow it went from being a very clear language to looking more like a hodgepodge of a few different languages.

IshKebab  1 year ago

Ah great improvements! I don't know why the sibling comments are so negative; this is clearly better.

  • tasuki  1 year ago

    Why? I'm used to \ meaning lambda. I understand you aren't, and that's fine. But it's just your weird opinion determined by what programming languages you've learned.

    Ultimately, it's just syntax and not so important. Semantics are important.

    • IshKebab  1 year ago

      > Why? I'm used to \ meaning lambda.

      1. I know what lambda calculus is, and I didn't even make the connection between \ and lambda. It's pretty tenuous.

      2. Most programmers do not know what lambda calculus is. This is supposed to be a friendly language, not an obscure academic one.

      3. It's not even the same lambda as in lambda calculus, e.g. it takes multiple arguments.

      4. Lambda was a reasonable choice in lambda calculus since it's a very "mathsy" language, and it's pretty much the only symbol in the language. It's a pretty awful choice for a practical programming language though - there's a reason 99% of languages use something like `fn` or `fun` or `function` or `def` instead of lambda to define top-level functions.

      I'm not a huge fan of `|foo|` either to be honest - I don't see why you can't simply use the same syntax for anonymous and named functions - but it is at least a little better.

      If it were up to me I'd go with something like

        fn double(a: list[int]) -> list[int] {
    a.map(fn(i) { i * 2 })
  }

      Same syntax; just allow omitting the name and inferring the types. I can't recall any languages that do that though so maybe there's some tricky reason it can't work?

      14 replies →