Hacker News Reader

Comment by rvense | Hacker News Reader

I wrote some Scala just today:

  val list = a +: l :+ b

And I knew I had to put in a comment because that stuff always makes my eyes cross over when I come back to it.

View on HN

Don't know Scala, but I'd assume that `+:` is prepend to list and `:+` is append to list.

You'd be correct.

But they're just method calls, both defined on the class of l. It is a little weird.

I can see the argument for terseness in source, particularly in domains where the terseness in code reflects well-understood shorthand in the actual problem space. But stuff like that makes me itch, to be honest.

The alternative would be something like

  l.prepend(a).append(b)

Horrible. Ghastly. Can't see anybody tolerating a language that looked like that.. /s

What? Mutating a list? DISGUSTING!

It's not mutating, its returning a new list with elements prepended and appended.

It gets even worse. Because Scala has infix syntax for method calls, you can do

    l prepend a append b

Don't know Scala but why wouldn't it be

a.append(l).append(b)

That would only work if a was itself a list..

  もっと練習  ⍝ Practice more  NB. ⍝ is a symbol for comment.
  /* NB. is for comment, too. */
  // Anything inside /* */ is comment, too.
  #  // starts a comment, too.

I don't know Scala and I have no idea of what +: :+ means, which at first is not a good sign (think about onboarding.) Then I remembered that many mainstream languages have the

    a ? b : c

construct which maybe was equally puzzling when it was introduced by CPL in 1963.

Scala can be extended by users with stuff like that.

The fact that C-style ternary is hard to pick up doesn't really excuse this kind of thing in new languages.

They're operators that cons an element on to a list. They're both defined on the List class, but differ in associativity because they start/end in a colon.

"a +: l" calls the +: method on l with a as its argument and returns a list with a added to the start, "l :+ b" calls the :+ method on l with b as its argument and returns a list with b added to the end. "a +: l :+ b" (parsed as "(a +: l) :+ b") therefore returns a copy of l with a added to the start and b added to the end.

This is user definable, you can make operators whichever way you like (and start them with : if you want them to be right associative).

It's very flexible and you do sort of get used to libraries using it, but I'm not entirely sure that getting used to something always means it's good.

(TBH though, I use the ternary operator constantly and think nothing of it.)

Reply on news.ycombinator.com