One of my first impressions of Scala, which I have barely seen, and do not know, is that there is a lot of syntax. Has anything been done to help with that? I don't think syntax matters much, but it's one of the only impressions I have of the language and wanted to ask about it.
See slide 13: https://www.slideshare.net/Odersky/preparing-for-scala-3#13
With scala 3, syntax has been simplified even more, e.g.:
No more braces necessary. Top level declarations. Extension Methods.
Optional braces seems like a weird feature to me. I would prefer consistently. I think a language should either be "bracey" or not. Just pick one!
Eh, that slide isn't really worth looking into. None of the languages there have a uniform way to represent the grammar. If you look at the C# and Scala grammars you'll find that the Scala one is highly compacted, whereas the C# grammar is intentionally not compact. They're encoded in different formats.
I guess my perception is warped :-)
f(...) becomes f.apply(...)
matching calls unapply with some various binding.
Some parenthesis are optional: Some(1,2,3) is Some((1,2,3))
optional . so a + b is a.+(b)
colon changes associativity, so a +: b is b.+:(a)
for expressions become, map, flatMap, filter, withFilter and forEach, according to various rules.
def f[A: B]() adds an implicit parameter of type B[A]
I'm sure there's more but that's the top of my head. Of course it's not actually a long list, but none of that is obvious for a newcomer.
At any rate none of this "sugar" was a problem to anyone I know who learned Scala. There are harder things about it than learning basic syntax.
That problem does lessen with familiarity, but knowing a lot of complexity makes me wary of unknown complexities. It adds an overhead which takes energy that could be better utilised elsewhere.
But Scala's syntax and language features are great when you actually make use of them to accomplish your goals, especially so with Scala 3. The syntax isn't excessive or frivolous or nonintuitive. It's a pretty straightforward encoding of the desired feature set of the language.
If you want to make any object `foo` callable with first-class application syntax, i.e. `foo(bar)`, you add an `apply` method to that `foo`. You don't need to bother extending Function, you don't need to come up with a method name and call that. When you call `foo()`, you don't know if `foo` is a function or an object, and you don't care. You can find out easily with a half decent editor of course, but the point is, you're free to mix objects and functions as you wish, the language does not get in your way.
And for all that it provides, it's a complete non-issue in terms of learning curve. It's a basic language feature that you learn once and are never impeded by thereafter.
There's a compiler warning against this syntax that everyone should really enable.