Yeah I don’t mean just terse functional idioms. Any programming technique that blew your mind the first time you came across it would qualify.

This could be done almost trivially using the typestate pattern: zerotomastery.io/blog/rust-typestate-patterns/.

That doesn’t look like a particularly difficult challenge? Like, it’s just an implementation game, move returns a data type that you write yourself

Edit: I suppose there’s life in that kind of ambiguous variation though

😂 Ikr!

My favorite example of haskell arcane wizardry is löb. It’s mentioned in this list but not really done justice imo.

There’s a crate for it too: anymap2

What if I specify the wrong type? let retrieved = storage.get::<SomeOtherType>();?

Is it a runtime error or a compile time error?

What madness caused this

fn union() {
    union union<'union> { union: &'union union<'union>, }
}

That makes complete sense. Ranges implement fmt::Debug, … is a range, in particular the full range (all values) …= isn’t because the upper bound is missing but …=… ranges from the beginning to the… full range. Which doesn’t make sense semantically but you can debug print it so add a couple more nested calls and you get a punch card.

I totally didn’t need the Rust playground to figure that out.

EDIT: Oh, glossed over that: … is only the full range if standing alone, it’s also an infix operator which is why you can add as many as you want (be careful with whitespace, though). … … … … … … … … … … is a valid Rust expression.

This is excellent content

This works with anything that one might call “named tuples”.

So, you can also define a struct like so and it’ll work:

struct Baz(i32);

On the other hand, if you define an enum variant with the normal struct syntax, it does not work:

enum Foo {
    ...
    Qux { something: i32 } //cannot omit braces
}

Yea it’s like when we writeSome(2). It’s not a function call but a variant of the Option enum.

fn foo<T>() {
    let f: fn(T) -> Option<T> = Some;
}

Clippy will warn you if you don’t use this feature.

Oh wow I’ve been looking for something nice like that for ages. Python can do this and it’s really great for silicon verification test stimulus. I’ve also done it in C++ using C++20 coroutines, but they are so complicated and low level I ended up having to use a library to help (libcoro). Felt like a bit of a gap in Rust, but this looks like a great solution!

The string “AAAAA” cannot be said to be greater or less than “AAAAB”, besides the very special case when we order it.

I hate it to break it to you but it’s the same with numbers.

The general theme of your comment is good, but the example is…

The string “AAAAA” cannot be said to be greater or less than “AAAAB”

But in general the name “John” is not considered to be higher/lower than “Mark”

// rust
  eprintln!("{}", "AAAAB" > "AAAAA") // true
  eprintln!("{}", "Mark" > "John") // true

// C
  printf("%d\n", strcmp("AAAAB", "AAAAA")); // 1
  printf("%d\n", strcmp("Mark", "John")); // 1

strcmp() docs:

strcmp() returns an integer indicating the result of the comparison, as follows:

• 0, if the s1 and s2 are equal;

• a negative value if s1 is less than s2;

• a positive value if s1 is greater than s2.

So basically, if C had higher level constructs, it would be identical to Rust here.

So, even if it is cool to manipulate strings by using addition/subtraction, it is still bad language design and very unintuitive.

Rust has impl Add<&str> for String and impl AddAssign<&str> for String. Both append as expected.

But maybe you meant numeric addition specifically.

In that case, yes, Rust doesn’t have that, although it’s an impl<'a> Step for &'a str away from having something similar (it would be (“AAAAA”…).next()).

impl Step for char already exists of course, but shouldn’t if we take your argument to its logical conclusion.

Oh, and C would most definitely have this feature if it could. Numerical manipulation of chars is commonplace there.