1.95 beta regression: "expected a closure that implements the `Fn` trait, but this closure only implements `FnOnce`"

[theemathas]

Regression found by the 1.95 beta crater run.

[INFO] [stdout] error[E0525]: expected a closure that implements the `Fn` trait, but this closure only implements `FnOnce`
[INFO] [stdout]    --> overengineered_hkts/src/hkt/iter.rs:575:40
[INFO] [stdout]     |
[INFO] [stdout] 564 | /             <F as Functor<'t, ReqIn, ConstBool<false>, ReqF1>>::map(
[INFO] [stdout] 565 | |                 {
[INFO] [stdout] 566 | |                     let clone_b = clone_b.clone();
[INFO] [stdout] 567 | |                     move |vec: &Vec<<TInner as Hkt<'t>>::F<'a, B>>| {
[INFO] [stdout] ...   |
[INFO] [stdout] 575 | |                 ReqF1::create_from(&f, |vec: Vec<<TInner as Hkt<'t>>::F<'a, B>>| {
[INFO] [stdout]     | |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this closure implements `FnOnce`, not `Fn`
[INFO] [stdout] ...   |
[INFO] [stdout] 578 | |                 result,
[INFO] [stdout] 579 | |             )
[INFO] [stdout]     | |_____________- the requirement to implement `Fn` derives from here
[INFO] [stdout]     |
[INFO] [stdout] note: required by a bound in `traits::Functor::map`
[INFO] [stdout]    --> overengineered_hkts/src/hkt/traits.rs:310:20
[INFO] [stdout]     |
[INFO] [stdout] 299 |     fn map<'a, A, B, F1Once, F1Mut, F1Fn, F1Clone, F1Copy>(
[INFO] [stdout]     |        --- required by a bound in this associated function
[INFO] [stdout] ...
[INFO] [stdout] 310 |         F1Fn: 'a + Fn(A) -> B,
[INFO] [stdout]     |                    ^^^^^^^^^^ required by this bound in `Functor::map`

https://crater-reports.s3.amazonaws.com/beta-1.95-1/beta-2026-03-05/gh/ArsenalAlex108.overengineered_hkt/log.txt

[theemathas]

Bisection results:

searched toolchains c40c51f9fdfa90b9c91c1601ec1442225c6b5c36 through 67aec36df76a7b67b71a8ee47684467e16f1847e


********************************************************************************
Regression in 75b9d89c68a4a92758349272aa4e35a8eb7a6708
********************************************************************************

Attempting to search unrolled perf builds
ERROR: couldn't find perf build comment

Regressed in #151380. cc @ShoyuVanilla @lcnr

[ShoyuVanilla]

Thanks! I'll try minimizing this!

[derekblackwood61-lang]

Thank you I will check the minimization as well

…

On Fri, Mar 13, 2026, 9:49 AM Shoyu Vanilla (Flint) < ***@***.***> wrote: *ShoyuVanilla* left a comment (rust-lang/rust#153816) <#153816 (comment)> Thanks, I'll try the minimization — Reply to this email directly, view it on GitHub <#153816 (comment)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/B7ZYMZQV2TTMOCUQKBGZSJL4QPKRZAVCNFSM6AAAAACWQYG6AOVHI2DSMVQWIX3LMV43OSLTON2WKQ3PNVWWK3TUHM2DANJTHEZDGNJVHA> . You are receiving this because you are subscribed to this thread.Message ID: ***@***.***>

[theemathas]

I've already been working on a minimization 😅 @ShoyuVanilla

[theemathas]

Partially minimized (121 lines)

Code

extern crate alloc;

pub trait OneOf5Hkt<'t> {
    type OneOf5F<'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a>: 'a
    where
        't: 'a;
    fn create_from<'a, 'b, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T: 'b>(
        _: &Self::OneOf5F<'a, T1, T2, T3, T4, T5>,
        value: T,
    ) -> Self::OneOf5F<'b, T, T, T, T, T>
    where
        't: 'a + 'b;
}

pub trait UnsizedHkt<'t>: 't {
    type UnsizedF<'a, A: 'a>: 'a + ?Sized
    where
        't: 'a;
}

pub trait Hkt<'t>: UnsizedHkt<'t> {
    type F<'a, A: 'a>: 'a
    where
        't: 'a;
}

impl<'t, T: Hkt<'t>> UnsizedHkt<'t> for T {
    type UnsizedF<'a, A: 'a>
        = T::F<'a, A>
    where
        't: 'a;
}

pub trait Functor<'t, ReqF1: OneOf5Hkt<'t>>: Hkt<'t> {
    fn map<'a, A, B, F1Once, F1Mut, F1Fn, F1Clone, F1Copy>(
        clone_a: impl 'a + Fn(&A) + Clone,
        clone_b: impl 'a + Fn(&B) + Clone,
        f: ReqF1::OneOf5F<'a, F1Once, F1Mut, F1Fn, F1Clone, F1Copy>,
        fa: Self::F<'a, A>,
    ) -> Self::F<'a, B>
    where
        A: 'a,
        B: 'a,
        F1Once: 'a + FnOnce(A) -> B,
        F1Mut: 'a + FnMut(A) -> B,
        F1Fn: 'a + Fn(A) -> B,
        F1Clone: 'a + Fn(A) -> B + Clone,
        F1Copy: 'a + Fn(A) -> B + Copy,
        't: 'a;
}

pub struct BoxT<T>(T);

pub struct DynIteratorT<TInner>(TInner);

impl<'t, TInner: Hkt<'t>> UnsizedHkt<'t> for DynIteratorT<TInner> {
    type UnsizedF<'a, A: 'a>
        = dyn 'a + Iterator<Item = TInner::F<'a, A>>
    where
        't: 'a;
}

pub trait Dummy<'t, ReqF1: OneOf5Hkt<'t>> {
    type FF<'a, A: 'a>: 'a
    where
        't: 'a;
    fn traverse<'a, A, B, F, F1Once, F1Mut, F1Fn, F1Clone, F1Copy>(
        clone_a: impl 'a + Fn(&A) + Clone,
        clone_b: impl 'a + Fn(&B) + Clone,
        f: ReqF1::OneOf5F<'a, F1Once, F1Mut, F1Fn, F1Clone, F1Copy>,
        fa: Self::FF<'a, A>,
    ) where
        A: 'a,
        B: 'a,
        F1Once: 'a + FnOnce(A) -> F::F<'a, B>,
        F1Mut: 'a + FnMut(A) -> F::F<'a, B>,
        F1Fn: 'a + Fn(A) -> F::F<'a, B>,
        F1Clone: 'a + Fn(A) -> F::F<'a, B> + Clone,
        F1Copy: 'a + Fn(A) -> F::F<'a, B> + Copy,
        F: Functor<'t, ReqF1>,
        't: 'a;
}

fn conjure<T>() -> T {
    unimplemented!()
}

impl<'t, ReqF1: OneOf5Hkt<'t>, TInner: Functor<'t, ReqF1> + Hkt<'t>> Dummy<'t, ReqF1>
    for BoxT<DynIteratorT<TInner>>
{
    type FF<'a, A: 'a>
        = Box<TInner::UnsizedF<'a, A>>
    where
        't: 'a;
    fn traverse<'a, A, B, F, F1Once, F1Mut, F1Fn, F1Clone, F1Copy>(
        _: impl 'a + Fn(&A) + Clone,
        _: impl 'a + Fn(&B) + Clone,
        f: ReqF1::OneOf5F<'a, F1Once, F1Mut, F1Fn, F1Clone, F1Copy>,
        _: Self::FF<'a, A>,
    ) where
        A: 'a,
        B: 'a,
        F1Once: 'a + FnOnce(A) -> F::F<'a, B>,
        F1Mut: 'a + FnMut(A) -> F::F<'a, B>,
        F1Fn: 'a + Fn(A) -> F::F<'a, B>,
        F1Clone: 'a + Fn(A) -> F::F<'a, B> + Clone,
        F1Copy: 'a + Fn(A) -> F::F<'a, B> + Copy,
        F: Functor<'t, ReqF1>,
        't: 'a,
    {
        let result = conjure::<F::F<'a, Vec<TInner::F<'a, B>>>>();
        <F as Functor<'t, ReqF1>>::map(
            |_: &Vec<<TInner as Hkt<'t>>::F<'a, B>>| conjure(),
            |_| (),
            ReqF1::create_from(&f, |_: Vec<<TInner as Hkt<'t>>::F<'a, B>>| {
                conjure::<Box<dyn Iterator<Item = <TInner as Hkt<'t>>::F<'a, B>>>>()
            }),
            result,
        );
    }
}

[theemathas]

Minimized

pub trait Trait {
    type Assoc<F1, F2>;
    fn create_from<F>(_: F) -> Self::Assoc<F, F>;
}

fn map<T: Trait>(_: T::Assoc<impl FnOnce(), impl Fn()>) {}

pub fn traverse<T: Trait>() {
    map::<T>(T::create_from(|| ()));
}

Error on beta:

error[E0525]: expected a closure that implements the `Fn` trait, but this closure only implements `FnOnce`
 --> src/lib.rs:9:29
  |
9 |     map::<T>(T::create_from(|| ()));
  |     ------------------------^^-----
  |     |                       |
  |     |                       this closure implements `FnOnce`, not `Fn`
  |     the requirement to implement `Fn` derives from here
  |
note: required by a bound in `map`
 --> src/lib.rs:6:50
  |
6 | fn map<T: Trait>(_: T::Assoc<impl FnOnce(), impl Fn()>) {}
  |                                                  ^^^^ required by this bound in `map`

For more information about this error, try `rustc --explain E0525`.