Break with value alternatives

[RustyYato]

On the note of Error type in Result. I see this as exactly the same problem as implementing a trait, say Write, and wanting to provide more meaningful errors. You just can't without some workarounds. Also, I don't think that this is a common issue, so I'm fine with pessimizing it.

@RustyYato

The compiler can reason about inhabitedness so you don't need to.

The compiler already has to do inhabitedness checking, so this should be fine.

Also on the note of inhabitedness, in the past there have been miscompiles when using structs that contain uninhabited types because you could do something like,

Uninhabited types are ZSTs despite partial initialization being allowed in safe code.

So now, all structs treat uninhabited types as normal zero-sized types, and don't inherit inhabited. Also partial initialization is prohibited.

Rust Playground

So type theory, while nice, doesn't completely line up with Rust.

@felix.s

I was referring to people being confused over whether () is a top type (which it obviously isn't). I don't even remember if you participated in that issue's thread, to be honest.

I don't remember that thread at all, so probably not.

@felix.s

Ouch. I mean, yes, it compiles… but you're relying on for being a sugar for loop - match and on the break from the generator implicitly converting the ! return value to the other break 's type. If for were a primitive construct which actually enforces that break agree with the return type of the generator (as a good abstraction should behave), it would not work. I think it's a deficiency of this desugaring that it does.

In case you didn't know, this is how for loop desugars right now,

for $var in $into_iter {
    $code
}

let __iterator = IntoIterator::into_iter($into_iter);

loop {
    match Iterator::next(&mut __iterator) {
        Some($var) => { $code },
        None => break
    }
}

Please show how your method would desugar a for loop, because if it can't then it is more complex then generators

for loops are not primitive constructs in Rust.