keywords

feel like I honestly have had to use any more than what I commonly user in .NET/C#. In fact, I think C# might honestly be worse. https://github.com/e3b0c442/keywords > `guard let self = self else { return }` I think you can do something like this as Swift 5 or 6: `guard let self else { return }` Don't quote me though (It's also not much better looking, imo).

milliforth packs those behind a word instead). And so far 2 of the words have been found unnecessary / redundant.

nd avoid any complicated feature. While having a full ML style type system with afine types on top, and quite some other type level mechanics up to singleton types? Sure sure, no power in here. :-) > The more powerful feature the more abusable it is, and Scala loves the power at all cost. Everything is "abusable". This is not an argument. But that Scala loves power at all cost is simply not true. The contrary is. Just to cite one of the most influential post in Scala land of all times: https://www.lihaoyi.com/post/StrategicScalaStylePrincipleofL... This, and the BDFL constantly complaining about unnecessary complex code people write speaks for itself. Scala lately even reduced the power of some features just to prevent "abuse". (Which is partly an overreaction; but that's another story). > Why would anyone care? The more flexible/powerful something is the harder it will be to parse by humans and tooling. That's also not true. Scala has a very small and simple syntax (despite all the language features). Scala is on the surface much much simpler and much more regular then Rust! https://github.com/e3b0c442/keywords (You could also compare the language grammars. This would be even more in favor of Scala in this regard). Scala 3 looks even almost like Python! https://docs.scala-lang.org/scala3/book/scala-for-python-dev... > Plus Scala has the big deal breaker. GC and no custom primitive types. What a "deal breaker"? https://github.com/carbon-language/carbon-lang/blob/trunk/do... You've seen this here in the thread? Also: https://docs.scala-lang.org/overviews/core/value-classes.htm... As soon as Valhalla lands in JVM-land this will be full blown value types without any limitations. And in Scala Native you can have of course native structs today. (Only that Scala Native isn't ready for prime time just now). In the long run Scala Native could also run without GC. The Caprese project will bring something that is more powerful than Rust lifetimes. Lifetimes will fall out as a special case of a more general concept. > > Besides that: The Rust people are looking envious. I've read about some ideas that were more or less a direct copy of Scala's implicits. > What do you mean exactly? Implicits get discussed every now and than in Rust land. Even the above Rust internals discussion start with them. Or this here: https://tmandry.gitlab.io/blog/posts/2021-12-21-context-capa... Also I've once read something that looked like a brain storming for future Rust features. They came up with more or less implicits (only that they didn't call them like that, so I can't find this any more, didn't bookmark it). Someone even once proposed directly Scala's implicits for Rust. But this went nowhere as the other people on the forum actually didn't understand them (which was no wonder as the example was quite terrible and the proponent was not really experienced with Scala so couldn't explain it well). People came than to quite wrong conclusions (some of them even mixed implicits in general even the dreaded implicit conversions, which were in fact mostly overused and caused trouble in Scala; but things got redesigned exactly because of that).