keywords VS rfcs

> I'm not sure here how you differentiate minimalist from restrictive.

The flexibility of the language and its syntax. The more constructs are syntactic, the less minimalistic it is, and Go is a very syntactic language.

> I've always considered Go to be minimalist in terms of available tokens to the programmer: https://github.com/e3b0c442/keywords/blob/main/chart.png

No language on this chart has even a passing resemblance to minimalistic. I don't think anything does when it reaches double digit keywords.

For reference, I believe Smalltalk has 6.

And forth is more complicated because it doesn't really have keywords at all, and barely any syntax, instead it has assembly-coded / runtime-provided words (~functions) and variables. SectorForth (https://github.com/cesarblum/sectorforth/) is down to 8 builtin words, 2 IO words, and 5 variables (milliforth packs those behind a word instead). And so far 2 of the words have been found unnecessary / redundant.

> I like Rust's pragmatism.

Me too.

But Scala is also a very pragmatic language. If you want something academic go for Haskell.

> Allow limited operator overload.

Nitpick: Scala does not have any operators. So it doesn't have operator overloading at all.

Scala simulates operators by infix method syntax.

Instead of writing `1.+(2)` you can just write `1 + 2`. But the later is the same method call as the first one!

> Eschew HKT for a simpler abstractions.

AFAIK HKTs are more or less "just postponed" in Rust, AFAIK.

People would like to add them of course. The discussion goes on forever by now. Some small insight (there is much more when you look for it):

https://github.com/rust-lang/rfcs/issues/324

https://internals.rust-lang.org/t/higher-kinded-types-the-di...

> Don't go in the deep end with type power, nor too much in opposite direction and 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).

Check out: https://github.com/e3b0c442/keywords

In order to actually answer your question in some form: Here’s a list of programming languages ranked by number of keywords.. Looking at this list, consider that PHP used to be considered a beginner friendly language and that Java is often chosen as the first language for new CS students. Your question seems to be difficult to answer!

RFC: Add large language models to Rust

https://github.com/rust-lang/rfcs/pull/3603

Man, SO and family has really gone downhill. That top answer is absolutely terrible. In fact, if you care, you can literally look at the RFC discussion here to see the actual debate: https://github.com/rust-lang/rfcs/pull/582

Basically, `for x in y` is kind of redundant, already sorta-kinda supported by itertools, and there's also a ton of macros that sorta-kinda do it already. It would just be language bloat at this point.

Literally has nothing to do with memory management.

Congrats!

> Similarly, uv does not yet generate a platform-agnostic lockfile. This matches pip-tools, but differs from Poetry and PDM, making uv a better fit for projects built around the pip and pip-tools workflows.

Do you expect to make the higher level workflow independent of requirements.txt / support a platform-agnostic lockfile? Being attached to Rye makes me think "no".

Without being platform agnostic, to me this is dead-on-arrival and unable to meet the "Cargo for Python" aim.

> uv supports alternate resolution strategies. By default, uv follows the standard Python dependency resolution strategy of preferring the latest compatible version of each package. But by passing --resolution=lowest, library authors can test their packages against the lowest-compatible version of their dependencies. (This is similar to Go's Minimal version selection.)

> uv allows for resolutions against arbitrary target Python versions. While pip and pip-tools always resolve against the currently-installed Python version (generating, e.g., a Python 3.12-compatible resolution when running under Python 3.12), uv accepts a --python-version parameter, enabling you to generate, e.g., Python 3.7-compatible resolutions even when running under newer versions.

This is great to see though!

I can understand it being a flag on these lower level, directly invoked dependency resolution operations.

While you aren't onto the higher level operations yet, I think it'd be useful to see if there is any cross-ecosystem learning we can do for my MSRV RFC: https://github.com/rust-lang/rfcs/pull/3537

How are you handling pre-releases in you resolution? Unsure how much of that is specified in PEPs. Its something that Cargo is weak in today but we're slowly improving.

In the early days of Rust there was a debate about whether to support "green threads" and in doing that require runtime support. It was actually implemented and included for a time but it creates problems when trying to do library or embedded code. At the time Go for example chose to go that route, and it was both nice (goroutines are nice to write and well supported) and expensive (effectively requires GC etc). I don't remember the details but there is a Rust RFC from when they removed green threads:

https://github.com/rust-lang/rfcs/blob/0806be4f282144cfcd55b...

I did some more digging. By RFC 899, I believe Alex Crichton meant PR 899 in this repo:

https://github.com/rust-lang/rfcs/pull/899

Still, no real discussion of why unbuffered stderr.

Rust has had a stable SIMD vector API[1] for a long time. But, it's architecture specific. The portable API[2] isn't stable yet, but you probably can't use the portable API for some of the more exotic uses of SIMD anyway. Indeed, that's true in .NET's case too[3].

Rust does all this SIMD too. It just isn't in the standard library. But the regex crate does it. Indeed, this is where .NET got its SIMD approach for multiple substring search from in the first place[4]. ;-)

You're right that Rust's standard library is conservatively vectorized though[5]. The main thing blocking this isn't the lack of SIMD availability. It's more about how the standard library is internally structured, and the fact that things like substring search are not actually defined in `std` directly, but rather, in `core`. There are plans to fix this[6].

[1]: https://doc.rust-lang.org/std/arch/index.html

[2]: https://doc.rust-lang.org/std/simd/index.html

[3]: https://github.com/dotnet/runtime/blob/72fae0073b35a404f03c3...

[4]: https://github.com/dotnet/runtime/pull/88394#issuecomment-16...

[5]: https://github.com/BurntSushi/memchr#why-is-the-standard-lib...

[6]: https://github.com/rust-lang/rfcs/pull/3469