2024 edition regression: cannot write blanket implementation for closures that return the Never type

[alice-i-cecile]

As laid out in the guide for the Never type fallback, closures which panic are now inferred to return !, rather than ().

In Bevy, we encountered this surprising breaking change in the form of bevyengine/bevy#18778. While individual users can work around this by writing |my closure | -> () and explicitly specifying a return type or by using an ordinary function, we cannot work around this breakage ourselves by writing another blanket implementation because the Never type (!) is not available on stable Rust.

[alice-i-cecile]

We might be able to abuse the fact that Never is exposed via stable trait impls to work around this, ala https://play.rust-lang.org/?version=stable&mode=debug&edition=2024&gist=77fbd787405712a153404ca23d5d0263. I'm not sure that that's something the Rust team would appreciate a major crate relying on though.

EDIT: It's not clear that a workaround of this form will work for us, but we'd be happy to be proven wrong!

[Jules-Bertholet]

We might be able to abuse the fact that Never is exposed via stable trait impls to work around this, ala https://play.rust-lang.org/?version=stable&mode=debug&edition=2024&gist=77fbd787405712a153404ca23d5d0263.

No, that is not the never type. That is core::convert::Infallible, which is planned to become an alias of the never type in the future, but currently is not. The workaround you are looking for is:

mod fn_ret {
    pub trait FnRet {
        type Output;
    }

    impl<R> FnRet for fn() -> R {
        type Output = R;
    }
}

pub type Never = <fn() -> ! as fn_ret::FnRet>::Output;

(The never-say-never crate, with nearly 1.5 million downloads, uses this trick.)

[alice-i-cecile]

That workaround should work for us! Would you like me to leave this issue open or close it?

[lcnr]

To my knowledge the never type is currently only really unstable to avoid people relying on Infallible and ! being different types.

So as long as you don't implement IntoSystem<Infallible> and IntoSystem<!> this should be fine. cc @WaffleLapkin

[lcnr]

I think keeping this open as fine in case other people encounter this issue as well

[WaffleLapkin]

So, on the regression side -- I think this is entirely expected. The reason this worked before is incidental, there is nothing in the code that should force the closure to return () rather than !. On older editions you get a future compatibility warning, so that also works as expected.

For the workaround, I think @lcnr's assesment is correct -- the only thing stopping never type from being stabilized is our desire to make Infallible = ! which is blocked on a breaking change we plan to rollout sometime later (the same change as in the edition). So as long as your code works with Infallible being an alias for !, and you don't expose ! to the users in a way where their code can break once Infallible becomes !, you should be fine.

That being said you are still opting out of stability guarantees, so should is just that -- should.