[INFO] fetching crate rearch 0.10.1... [INFO] checking rearch-0.10.1 against master#506512391b1a75ae450d36c9420978402a91abcc for pr-125384 [INFO] extracting crate rearch 0.10.1 into /workspace/builds/worker-7-tc1/source [INFO] validating manifest of crates.io crate rearch 0.10.1 on toolchain 506512391b1a75ae450d36c9420978402a91abcc [INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+506512391b1a75ae450d36c9420978402a91abcc" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }` [INFO] started tweaking crates.io crate rearch 0.10.1 [INFO] finished tweaking crates.io crate rearch 0.10.1 [INFO] tweaked toml for crates.io crate rearch 0.10.1 written to /workspace/builds/worker-7-tc1/source/Cargo.toml [INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+506512391b1a75ae450d36c9420978402a91abcc" "generate-lockfile" "--manifest-path" "Cargo.toml", kill_on_drop: false }` [INFO] [stderr] Updating crates.io index [INFO] [stderr] Locking 27 packages to latest compatible versions [INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+506512391b1a75ae450d36c9420978402a91abcc" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }` [INFO] [stderr] Downloading crates ... [INFO] [stderr] Downloaded rearch-macros v0.6.0 [INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-7-tc1/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-7-tc1/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:beeedbb442662e57d416641ecc3200b38e573c25b057896194468d05594dd835" "/opt/rustwide/cargo-home/bin/cargo" "+506512391b1a75ae450d36c9420978402a91abcc" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }` [INFO] [stdout] 02717d1c1404908b21a1279644f496344df0d14f2dd06498ac3ffaee17c7c816 [INFO] running `Command { std: "docker" "start" "-a" "02717d1c1404908b21a1279644f496344df0d14f2dd06498ac3ffaee17c7c816", kill_on_drop: false }` [INFO] running `Command { std: "docker" "inspect" "02717d1c1404908b21a1279644f496344df0d14f2dd06498ac3ffaee17c7c816", kill_on_drop: false }` [INFO] running `Command { std: "docker" "rm" "-f" "02717d1c1404908b21a1279644f496344df0d14f2dd06498ac3ffaee17c7c816", kill_on_drop: false }` [INFO] [stdout] 02717d1c1404908b21a1279644f496344df0d14f2dd06498ac3ffaee17c7c816 [INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-7-tc1/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-7-tc1/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=allow" "-e" "RUSTDOCFLAGS=--cap-lints=allow" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:beeedbb442662e57d416641ecc3200b38e573c25b057896194468d05594dd835" "/opt/rustwide/cargo-home/bin/cargo" "+506512391b1a75ae450d36c9420978402a91abcc" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }` [INFO] [stdout] 625806cdfbf1f0cd48d3c54f115b994049452b784a5ce78de77e816d51e84bef [INFO] running `Command { std: "docker" "start" "-a" "625806cdfbf1f0cd48d3c54f115b994049452b784a5ce78de77e816d51e84bef", kill_on_drop: false }` [INFO] [stderr] Compiling proc-macro2 v1.0.84 [INFO] [stderr] Compiling autocfg v1.3.0 [INFO] [stderr] Compiling libc v0.2.155 [INFO] [stderr] Compiling parking_lot_core v0.9.10 [INFO] [stderr] Checking scopeguard v1.2.0 [INFO] [stderr] Compiling paste v1.0.15 [INFO] [stderr] Checking cfg-if v1.0.0 [INFO] [stderr] Compiling lock_api v0.4.12 [INFO] [stderr] Compiling quote v1.0.36 [INFO] [stderr] Compiling syn v2.0.66 [INFO] [stderr] Checking parking_lot v0.12.3 [INFO] [stderr] Compiling rearch-macros v0.6.0 [INFO] [stderr] Checking rearch v0.10.1 (/opt/rustwide/workdir) [INFO] [stderr] Finished `dev` profile [unoptimized + debuginfo] target(s) in 3.96s [INFO] running `Command { std: "docker" "inspect" "625806cdfbf1f0cd48d3c54f115b994049452b784a5ce78de77e816d51e84bef", kill_on_drop: false }` [INFO] running `Command { std: "docker" "rm" "-f" "625806cdfbf1f0cd48d3c54f115b994049452b784a5ce78de77e816d51e84bef", kill_on_drop: false }` [INFO] [stdout] 625806cdfbf1f0cd48d3c54f115b994049452b784a5ce78de77e816d51e84bef [INFO] checking rearch-0.10.1 against try#dae34b759e282c069aa28752564694effd121a63 for pr-125384 [INFO] extracting crate rearch 0.10.1 into /workspace/builds/worker-7-tc2/source [INFO] validating manifest of crates.io crate rearch 0.10.1 on toolchain dae34b759e282c069aa28752564694effd121a63 [INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+dae34b759e282c069aa28752564694effd121a63" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }` [INFO] started tweaking crates.io crate rearch 0.10.1 [INFO] finished tweaking crates.io crate rearch 0.10.1 [INFO] tweaked toml for crates.io crate rearch 0.10.1 written to /workspace/builds/worker-7-tc2/source/Cargo.toml [INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+dae34b759e282c069aa28752564694effd121a63" "generate-lockfile" "--manifest-path" "Cargo.toml", kill_on_drop: false }` [INFO] [stderr] Updating crates.io index [INFO] [stderr] Locking 27 packages to latest compatible versions [INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+dae34b759e282c069aa28752564694effd121a63" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }` [INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-7-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-7-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:beeedbb442662e57d416641ecc3200b38e573c25b057896194468d05594dd835" "/opt/rustwide/cargo-home/bin/cargo" "+dae34b759e282c069aa28752564694effd121a63" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }` [INFO] [stdout] ef49864af354534d490dd036b9f9cf26205b96590ba34afddc60369c1fc047e9 [INFO] running `Command { std: "docker" "start" "-a" "ef49864af354534d490dd036b9f9cf26205b96590ba34afddc60369c1fc047e9", kill_on_drop: false }` [INFO] running `Command { std: "docker" "inspect" "ef49864af354534d490dd036b9f9cf26205b96590ba34afddc60369c1fc047e9", kill_on_drop: false }` [INFO] running `Command { std: "docker" "rm" "-f" "ef49864af354534d490dd036b9f9cf26205b96590ba34afddc60369c1fc047e9", kill_on_drop: false }` [INFO] [stdout] ef49864af354534d490dd036b9f9cf26205b96590ba34afddc60369c1fc047e9 [INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-7-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-7-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=allow" "-e" "RUSTDOCFLAGS=--cap-lints=allow" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:beeedbb442662e57d416641ecc3200b38e573c25b057896194468d05594dd835" "/opt/rustwide/cargo-home/bin/cargo" "+dae34b759e282c069aa28752564694effd121a63" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }` [INFO] [stdout] 053428f0685cf885583524586cd302e474a5f6c7798f047a4356d4a75e2578a5 [INFO] running `Command { std: "docker" "start" "-a" "053428f0685cf885583524586cd302e474a5f6c7798f047a4356d4a75e2578a5", kill_on_drop: false }` [INFO] [stderr] Copying to /tmp/fixit [INFO] [stderr] Running `cargo fix --edition` [INFO] [stderr] Migrating Cargo.toml from 2021 edition to 2024 [INFO] [stderr] Compiling proc-macro2 v1.0.84 [INFO] [stderr] Compiling libc v0.2.155 [INFO] [stderr] Compiling unicode-ident v1.0.12 [INFO] [stderr] Compiling autocfg v1.3.0 [INFO] [stderr] Compiling parking_lot_core v0.9.10 [INFO] [stderr] Checking cfg-if v1.0.0 [INFO] [stderr] Checking smallvec v1.13.2 [INFO] [stderr] Checking scopeguard v1.2.0 [INFO] [stderr] Compiling paste v1.0.15 [INFO] [stderr] Compiling lock_api v0.4.12 [INFO] [stderr] Compiling quote v1.0.36 [INFO] [stderr] Compiling syn v2.0.66 [INFO] [stderr] Checking parking_lot v0.12.3 [INFO] [stderr] Compiling rearch-macros v0.6.0 [INFO] [stderr] Checking rearch v0.10.1 (/tmp/fixit) [INFO] [stderr] Migrating src/lib.rs from 2021 edition to 2024 [INFO] [stderr] Finished `dev` profile [unoptimized + debuginfo] target(s) in 3.69s [INFO] [stderr] Running `cargo check` to verify 2024 [INFO] [stderr] Checking rearch v0.10.1 (/tmp/fixit) [INFO] [stdout] error[E0657]: `impl Trait` cannot capture higher-ranked lifetime from outer `impl Trait` [INFO] [stdout] --> src/lib.rs:514:52 [INFO] [stdout] | [INFO] [stdout] 514 | ) -> impl for<'a> SideEffect = (T, impl CData + Fn(T))> { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^ `impl Trait` implicitly captures all lifetimes in scope [INFO] [stdout] | [INFO] [stdout] note: lifetime declared here [INFO] [stdout] --> src/lib.rs:514:23 [INFO] [stdout] | [INFO] [stdout] 514 | ) -> impl for<'a> SideEffect = (T, impl CData + Fn(T))> { [INFO] [stdout] | ^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0657]: `impl Trait` cannot capture higher-ranked lifetime from outer `impl Trait` [INFO] [stdout] --> src/lib.rs:533:65 [INFO] [stdout] | [INFO] [stdout] 533 | pub fn rebuilder() -> impl for<'a> SideEffect = impl CData + Fn()> { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^ `impl Trait` implicitly captures all lifetimes in scope [INFO] [stdout] | [INFO] [stdout] note: lifetime declared here [INFO] [stdout] --> src/lib.rs:533:40 [INFO] [stdout] | [INFO] [stdout] 533 | pub fn rebuilder() -> impl for<'a> SideEffect = impl CData + Fn()> { [INFO] [stdout] | ^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: lifetime may not live long enough [INFO] [stdout] --> src/lib.rs:520:17 [INFO] [stdout] | [INFO] [stdout] 515 | move |register: SideEffectRegistrar| { [INFO] [stdout] | -------- - return type of closure `(T, {closure@src/lib.rs:517:33: 517:49})` contains a lifetime `'2` [INFO] [stdout] | | [INFO] [stdout] | has type `side_effect_registrar::SideEffectRegistrar<'1>` [INFO] [stdout] ... [INFO] [stdout] 520 | (state.clone(), set_state) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ returning this value requires that `'1` must outlive `'2` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: lifetime may not live long enough [INFO] [stdout] --> src/lib.rs:536:17 [INFO] [stdout] | [INFO] [stdout] 534 | move |register: SideEffectRegistrar| { [INFO] [stdout] | -------- - return type of closure `{closure@src/lib.rs:536:17: 536:24}` contains a lifetime `'2` [INFO] [stdout] | | [INFO] [stdout] | has type `side_effect_registrar::SideEffectRegistrar<'1>` [INFO] [stdout] 535 | let ((), rebuild, _) = register.raw(()); [INFO] [stdout] 536 | move || rebuild(Box::new(|()| {})) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ returning this value requires that `'1` must outlive `'2` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1077:54 [INFO] [stdout] | [INFO] [stdout] 1064 | ) -> ((u8, impl CData + Fn(u8)), (u8, impl CData + Fn(u8))) { [INFO] [stdout] | ------------------- ------------------- [INFO] [stdout] | | | [INFO] [stdout] | | one of the expected opaque types [INFO] [stdout] | | one of the found opaque types [INFO] [stdout] | one of the expected opaque types [INFO] [stdout] | one of the found opaque types [INFO] [stdout] ... [INFO] [stdout] 1077 | let ((_, set_state1), (_, set_state2)) = get.as_ref(two_side_effects_capsule).clone(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `((_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData), (_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData))` [INFO] [stdout] found tuple `((_, impl (Fn(u8)) + CData), (_, impl (Fn(u8)) + CData))` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/capsule_reader.rs:31:22 [INFO] [stdout] | [INFO] [stdout] 31 | pub fn as_ref(&mut self, capsule: C) -> &C::Data { [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1077:54 [INFO] [stdout] | [INFO] [stdout] 1064 | ) -> ((u8, impl CData + Fn(u8)), (u8, impl CData + Fn(u8))) { [INFO] [stdout] | ------------------- ------------------- [INFO] [stdout] | | | [INFO] [stdout] | | one of the expected opaque types [INFO] [stdout] | | one of the found opaque types [INFO] [stdout] | one of the expected opaque types [INFO] [stdout] | one of the found opaque types [INFO] [stdout] ... [INFO] [stdout] 1077 | let ((_, set_state1), (_, set_state2)) = get.as_ref(two_side_effects_capsule).clone(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `((_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData), (_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData))` [INFO] [stdout] found tuple `((_, impl (Fn(u8)) + CData), (_, impl (Fn(u8)) + CData))` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1077:54 [INFO] [stdout] | [INFO] [stdout] 1077 | let ((_, set_state1), (_, set_state2)) = get.as_ref(two_side_effects_capsule).clone(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1077:54 [INFO] [stdout] | [INFO] [stdout] 1077 | let ((_, set_state1), (_, set_state2)) = get.as_ref(two_side_effects_capsule).clone(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1077:54 [INFO] [stdout] | [INFO] [stdout] 1077 | let ((_, set_state1), (_, set_state2)) = get.as_ref(two_side_effects_capsule).clone(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1078:35 [INFO] [stdout] | [INFO] [stdout] 1070 | ) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1078 | let (_, set_state3) = get.as_ref(another_capsule).clone(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/capsule_reader.rs:31:22 [INFO] [stdout] | [INFO] [stdout] 31 | pub fn as_ref(&mut self, capsule: C) -> &C::Data { [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1078:35 [INFO] [stdout] | [INFO] [stdout] 1070 | ) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1078 | let (_, set_state3) = get.as_ref(another_capsule).clone(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1078:35 [INFO] [stdout] | [INFO] [stdout] 1078 | let (_, set_state3) = get.as_ref(another_capsule).clone(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {side_effect_txns::another_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1078:35 [INFO] [stdout] | [INFO] [stdout] 1078 | let (_, set_state3) = get.as_ref(another_capsule).clone(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {side_effect_txns::another_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1078:35 [INFO] [stdout] | [INFO] [stdout] 1078 | let (_, set_state3) = get.as_ref(another_capsule).clone(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {side_effect_txns::another_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0277]: the trait bound `(for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {state_updates::stateful}, for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> u8 {dependent}): read_capsules::CapsulesWithCloneRead` is not satisfied [INFO] [stdout] --> src/lib.rs:604:65 [INFO] [stdout] | [INFO] [stdout] 604 | let ((state, set_state), plus_one) = container.read((stateful, dependent)); [INFO] [stdout] | ---- ^^^^^^^^^^^^^^^^^^^^^ the trait `read_capsules::CapsulesWithCloneRead` is not implemented for `(fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {stateful}, fn(...) -> ... {dependent})` [INFO] [stdout] | | [INFO] [stdout] | required by a bound introduced by this call [INFO] [stdout] | [INFO] [stdout] = help: the following other types implement trait `read_capsules::CapsulesWithCloneRead`: [INFO] [stdout] (A, B) [INFO] [stdout] (A, B, C) [INFO] [stdout] (A, B, C, D) [INFO] [stdout] (A, B, C, D, E) [INFO] [stdout] (A, B, C, D, E, F) [INFO] [stdout] (A, B, C, D, E, F, G) [INFO] [stdout] (A, B, C, D, E, F, G, H) [INFO] [stdout] note: required by a bound in `Container::read` [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ required by this bound in `Container::read` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0277]: the trait bound `(for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {state_updates::stateful}, for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> u8 {dependent}): read_capsules::CapsulesWithCloneRead` is not satisfied [INFO] [stdout] --> src/lib.rs:609:57 [INFO] [stdout] | [INFO] [stdout] 609 | let ((state, _), plus_one) = container.read((stateful, dependent)); [INFO] [stdout] | ---- ^^^^^^^^^^^^^^^^^^^^^ the trait `read_capsules::CapsulesWithCloneRead` is not implemented for `(fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {stateful}, fn(...) -> ... {dependent})` [INFO] [stdout] | | [INFO] [stdout] | required by a bound introduced by this call [INFO] [stdout] | [INFO] [stdout] = help: the following other types implement trait `read_capsules::CapsulesWithCloneRead`: [INFO] [stdout] (A, B) [INFO] [stdout] (A, B, C) [INFO] [stdout] (A, B, C, D) [INFO] [stdout] (A, B, C, D, E) [INFO] [stdout] (A, B, C, D, E, F) [INFO] [stdout] (A, B, C, D, E, F, G) [INFO] [stdout] (A, B, C, D, E, F, G, H) [INFO] [stdout] note: required by a bound in `Container::read` [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ required by this bound in `Container::read` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:580:13 [INFO] [stdout] | [INFO] [stdout] 575 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 580 | get.as_ref(stateful).0 + 1 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/capsule_reader.rs:31:22 [INFO] [stdout] | [INFO] [stdout] 31 | pub fn as_ref(&mut self, capsule: C) -> &C::Data { [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:580:13 [INFO] [stdout] | [INFO] [stdout] 575 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 580 | get.as_ref(stateful).0 + 1 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:580:13 [INFO] [stdout] | [INFO] [stdout] 580 | get.as_ref(stateful).0 + 1 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {state_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:580:13 [INFO] [stdout] | [INFO] [stdout] 580 | get.as_ref(stateful).0 + 1 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {state_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:580:13 [INFO] [stdout] | [INFO] [stdout] 580 | get.as_ref(stateful).0 + 1 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {state_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:587:38 [INFO] [stdout] | [INFO] [stdout] 575 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 587 | let (state, set_state) = container.read(stateful); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:587:38 [INFO] [stdout] | [INFO] [stdout] 587 | let (state, set_state) = container.read(stateful); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {state_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:587:38 [INFO] [stdout] | [INFO] [stdout] 587 | let (state, set_state) = container.read(stateful); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {state_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:587:38 [INFO] [stdout] | [INFO] [stdout] 587 | let (state, set_state) = container.read(stateful); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {state_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:587:38 [INFO] [stdout] | [INFO] [stdout] 575 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 587 | let (state, set_state) = container.read(stateful); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:591:38 [INFO] [stdout] | [INFO] [stdout] 575 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 591 | let (state, set_state) = container.read(stateful); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:591:38 [INFO] [stdout] | [INFO] [stdout] 591 | let (state, set_state) = container.read(stateful); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {state_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:591:38 [INFO] [stdout] | [INFO] [stdout] 591 | let (state, set_state) = container.read(stateful); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {state_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:591:38 [INFO] [stdout] | [INFO] [stdout] 591 | let (state, set_state) = container.read(stateful); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {state_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:591:38 [INFO] [stdout] | [INFO] [stdout] 575 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 591 | let (state, set_state) = container.read(stateful); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:596:30 [INFO] [stdout] | [INFO] [stdout] 575 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 596 | let (state, _) = container.read(stateful); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:596:30 [INFO] [stdout] | [INFO] [stdout] 596 | let (state, _) = container.read(stateful); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {state_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:596:30 [INFO] [stdout] | [INFO] [stdout] 596 | let (state, _) = container.read(stateful); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {state_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:596:30 [INFO] [stdout] | [INFO] [stdout] 596 | let (state, _) = container.read(stateful); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {state_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:596:30 [INFO] [stdout] | [INFO] [stdout] 575 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 596 | let (state, _) = container.read(stateful); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:627:36 [INFO] [stdout] | [INFO] [stdout] 619 | ) -> (u8, u8, impl CData + Fn(u8), impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- ------------------- [INFO] [stdout] | | | [INFO] [stdout] | | one of the expected opaque types [INFO] [stdout] | | one of the found opaque types [INFO] [stdout] | one of the expected opaque types [INFO] [stdout] | one of the found opaque types [INFO] [stdout] ... [INFO] [stdout] 627 | let (s1, s2, set1, set2) = container.read(foo); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, _, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, _, impl (Fn(u8)) + CData, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:627:36 [INFO] [stdout] | [INFO] [stdout] 627 | let (s1, s2, set1, set2) = container.read(foo); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, u8, impl (Fn(u8)) + CData, impl (Fn(u8)) + CData) {foo}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:627:36 [INFO] [stdout] | [INFO] [stdout] 627 | let (s1, s2, set1, set2) = container.read(foo); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, u8, impl (Fn(u8)) + CData, impl (Fn(u8)) + CData) {foo}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:627:36 [INFO] [stdout] | [INFO] [stdout] 627 | let (s1, s2, set1, set2) = container.read(foo); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, u8, impl (Fn(u8)) + CData, impl (Fn(u8)) + CData) {foo}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:627:36 [INFO] [stdout] | [INFO] [stdout] 619 | ) -> (u8, u8, impl CData + Fn(u8), impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- ------------------- [INFO] [stdout] | | | [INFO] [stdout] | | one of the expected opaque types [INFO] [stdout] | | one of the found opaque types [INFO] [stdout] | one of the expected opaque types [INFO] [stdout] | one of the found opaque types [INFO] [stdout] ... [INFO] [stdout] 627 | let (s1, s2, set1, set2) = container.read(foo); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, _, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, _, impl (Fn(u8)) + CData, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:633:30 [INFO] [stdout] | [INFO] [stdout] 619 | ) -> (u8, u8, impl CData + Fn(u8), impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- ------------------- [INFO] [stdout] | | | [INFO] [stdout] | | one of the expected opaque types [INFO] [stdout] | | one of the found opaque types [INFO] [stdout] | one of the expected opaque types [INFO] [stdout] | one of the found opaque types [INFO] [stdout] ... [INFO] [stdout] 633 | let (s1, s2, _, _) = container.read(foo); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, _, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, _, impl (Fn(u8)) + CData, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:633:30 [INFO] [stdout] | [INFO] [stdout] 633 | let (s1, s2, _, _) = container.read(foo); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, u8, impl (Fn(u8)) + CData, impl (Fn(u8)) + CData) {foo}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:633:30 [INFO] [stdout] | [INFO] [stdout] 633 | let (s1, s2, _, _) = container.read(foo); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, u8, impl (Fn(u8)) + CData, impl (Fn(u8)) + CData) {foo}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:633:30 [INFO] [stdout] | [INFO] [stdout] 633 | let (s1, s2, _, _) = container.read(foo); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, u8, impl (Fn(u8)) + CData, impl (Fn(u8)) + CData) {foo}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:633:30 [INFO] [stdout] | [INFO] [stdout] 619 | ) -> (u8, u8, impl CData + Fn(u8), impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- ------------------- [INFO] [stdout] | | | [INFO] [stdout] | | one of the expected opaque types [INFO] [stdout] | | one of the found opaque types [INFO] [stdout] | one of the expected opaque types [INFO] [stdout] | one of the found opaque types [INFO] [stdout] ... [INFO] [stdout] 633 | let (s1, s2, _, _) = container.read(foo); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, _, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, _, impl (Fn(u8)) + CData, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:679:29 [INFO] [stdout] | [INFO] [stdout] 668 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 679 | states.push(reader.as_ref(stateful).0); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/capsule_reader.rs:31:22 [INFO] [stdout] | [INFO] [stdout] 31 | pub fn as_ref(&mut self, capsule: C) -> &C::Data { [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:679:29 [INFO] [stdout] | [INFO] [stdout] 668 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 679 | states.push(reader.as_ref(stateful).0); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:679:29 [INFO] [stdout] | [INFO] [stdout] 679 | states.push(reader.as_ref(stateful).0); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:679:29 [INFO] [stdout] | [INFO] [stdout] 679 | states.push(reader.as_ref(stateful).0); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:679:29 [INFO] [stdout] | [INFO] [stdout] 679 | states.push(reader.as_ref(stateful).0); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:685:9 [INFO] [stdout] | [INFO] [stdout] 668 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 685 | container.read(stateful).1(1); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:685:9 [INFO] [stdout] | [INFO] [stdout] 685 | container.read(stateful).1(1); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:685:9 [INFO] [stdout] | [INFO] [stdout] 685 | container.read(stateful).1(1); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:685:9 [INFO] [stdout] | [INFO] [stdout] 685 | container.read(stateful).1(1); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:685:9 [INFO] [stdout] | [INFO] [stdout] 668 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 685 | container.read(stateful).1(1); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:687:9 [INFO] [stdout] | [INFO] [stdout] 668 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 687 | container.read(stateful).1(2); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:687:9 [INFO] [stdout] | [INFO] [stdout] 687 | container.read(stateful).1(2); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:687:9 [INFO] [stdout] | [INFO] [stdout] 687 | container.read(stateful).1(2); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:687:9 [INFO] [stdout] | [INFO] [stdout] 687 | container.read(stateful).1(2); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:687:9 [INFO] [stdout] | [INFO] [stdout] 668 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 687 | container.read(stateful).1(2); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:688:9 [INFO] [stdout] | [INFO] [stdout] 668 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 688 | container.read(stateful).1(3); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:688:9 [INFO] [stdout] | [INFO] [stdout] 688 | container.read(stateful).1(3); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:688:9 [INFO] [stdout] | [INFO] [stdout] 688 | container.read(stateful).1(3); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:688:9 [INFO] [stdout] | [INFO] [stdout] 688 | container.read(stateful).1(3); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:688:9 [INFO] [stdout] | [INFO] [stdout] 668 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 688 | container.read(stateful).1(3); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:691:9 [INFO] [stdout] | [INFO] [stdout] 668 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 691 | container.read(stateful).1(4); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:691:9 [INFO] [stdout] | [INFO] [stdout] 691 | container.read(stateful).1(4); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:691:9 [INFO] [stdout] | [INFO] [stdout] 691 | container.read(stateful).1(4); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:691:9 [INFO] [stdout] | [INFO] [stdout] 691 | container.read(stateful).1(4); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:691:9 [INFO] [stdout] | [INFO] [stdout] 668 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 691 | container.read(stateful).1(4); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:693:9 [INFO] [stdout] | [INFO] [stdout] 668 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 693 | container.read(stateful).1(5); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:693:9 [INFO] [stdout] | [INFO] [stdout] 693 | container.read(stateful).1(5); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:693:9 [INFO] [stdout] | [INFO] [stdout] 693 | container.read(stateful).1(5); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:693:9 [INFO] [stdout] | [INFO] [stdout] 693 | container.read(stateful).1(5); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:693:9 [INFO] [stdout] | [INFO] [stdout] 668 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 693 | container.read(stateful).1(5); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:695:9 [INFO] [stdout] | [INFO] [stdout] 668 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 695 | container.read(stateful).1(6); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:695:9 [INFO] [stdout] | [INFO] [stdout] 695 | container.read(stateful).1(6); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:695:9 [INFO] [stdout] | [INFO] [stdout] 695 | container.read(stateful).1(6); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:695:9 [INFO] [stdout] | [INFO] [stdout] 695 | container.read(stateful).1(6); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:695:9 [INFO] [stdout] | [INFO] [stdout] 668 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 695 | container.read(stateful).1(6); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:696:9 [INFO] [stdout] | [INFO] [stdout] 668 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 696 | container.read(stateful).1(7); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:696:9 [INFO] [stdout] | [INFO] [stdout] 696 | container.read(stateful).1(7); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:696:9 [INFO] [stdout] | [INFO] [stdout] 696 | container.read(stateful).1(7); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:696:9 [INFO] [stdout] | [INFO] [stdout] 696 | container.read(stateful).1(7); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:696:9 [INFO] [stdout] | [INFO] [stdout] 668 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 696 | container.read(stateful).1(7); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:699:9 [INFO] [stdout] | [INFO] [stdout] 668 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 699 | container.read(stateful).1(8); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:699:9 [INFO] [stdout] | [INFO] [stdout] 699 | container.read(stateful).1(8); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:699:9 [INFO] [stdout] | [INFO] [stdout] 699 | container.read(stateful).1(8); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:699:9 [INFO] [stdout] | [INFO] [stdout] 699 | container.read(stateful).1(8); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::listener_gets_updates::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:699:9 [INFO] [stdout] | [INFO] [stdout] 668 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 699 | container.read(stateful).1(8); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:720:25 [INFO] [stdout] | [INFO] [stdout] 710 | fn rebuildable(CapsuleHandle { register, .. }: CapsuleHandle) -> (impl CData + Fn()) { [INFO] [stdout] | ----------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 720 | let _ = get.as_ref(rebuildable); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected opaque type `impl (for<'a, 'b, 'c> Fn()) + for<'a, 'b, 'c> CData` [INFO] [stdout] found opaque type `impl (Fn()) + CData` [INFO] [stdout] = note: distinct uses of `impl Trait` result in different opaque types [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/capsule_reader.rs:31:22 [INFO] [stdout] | [INFO] [stdout] 31 | pub fn as_ref(&mut self, capsule: C) -> &C::Data { [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:720:25 [INFO] [stdout] | [INFO] [stdout] 710 | fn rebuildable(CapsuleHandle { register, .. }: CapsuleHandle) -> (impl CData + Fn()) { [INFO] [stdout] | ----------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 720 | let _ = get.as_ref(rebuildable); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected opaque type `impl (for<'a, 'b, 'c> Fn()) + for<'a, 'b, 'c> CData` [INFO] [stdout] found opaque type `impl (Fn()) + CData` [INFO] [stdout] = note: distinct uses of `impl Trait` result in different opaque types [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:720:25 [INFO] [stdout] | [INFO] [stdout] 720 | let _ = get.as_ref(rebuildable); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> impl (Fn()) + CData {rebuildable}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:720:25 [INFO] [stdout] | [INFO] [stdout] 720 | let _ = get.as_ref(rebuildable); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> impl (Fn()) + CData {rebuildable}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:720:25 [INFO] [stdout] | [INFO] [stdout] 720 | let _ = get.as_ref(rebuildable); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> impl (Fn()) + CData {rebuildable}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:725:9 [INFO] [stdout] | [INFO] [stdout] 710 | fn rebuildable(CapsuleHandle { register, .. }: CapsuleHandle) -> (impl CData + Fn()) { [INFO] [stdout] | ----------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 725 | container.read(rebuildable)(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected opaque type `impl (for<'a, 'b, 'c> Fn()) + for<'a, 'b, 'c> CData` [INFO] [stdout] found opaque type `impl (Fn()) + CData` [INFO] [stdout] = note: distinct uses of `impl Trait` result in different opaque types [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:725:9 [INFO] [stdout] | [INFO] [stdout] 725 | container.read(rebuildable)(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> impl (Fn()) + CData {rebuildable}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:725:9 [INFO] [stdout] | [INFO] [stdout] 725 | container.read(rebuildable)(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> impl (Fn()) + CData {rebuildable}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:725:9 [INFO] [stdout] | [INFO] [stdout] 725 | container.read(rebuildable)(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> impl (Fn()) + CData {rebuildable}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:725:9 [INFO] [stdout] | [INFO] [stdout] 710 | fn rebuildable(CapsuleHandle { register, .. }: CapsuleHandle) -> (impl CData + Fn()) { [INFO] [stdout] | ----------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 725 | container.read(rebuildable)(); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected opaque type `impl (for<'a, 'b, 'c> Fn()) + for<'a, 'b, 'c> CData` [INFO] [stdout] found opaque type `impl (Fn()) + CData` [INFO] [stdout] = note: distinct uses of `impl Trait` result in different opaque types [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:814:20 [INFO] [stdout] | [INFO] [stdout] 787 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u32, impl CData + Fn(u32)) { [INFO] [stdout] | -------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 814 | assert_eq!(get_build_count(stateful), 1); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u32)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u32)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:761:31 [INFO] [stdout] | [INFO] [stdout] 761 | fn get_build_count(_capsule: C) -> u32 { [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:820:9 [INFO] [stdout] | [INFO] [stdout] 787 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u32, impl CData + Fn(u32)) { [INFO] [stdout] | -------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 820 | container.read(stateful).1(0); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u32)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u32)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:820:9 [INFO] [stdout] | [INFO] [stdout] 820 | container.read(stateful).1(0); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u32, impl (Fn(u32)) + CData) {tests::eq_check_skips_unneeded_rebuilds::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:820:9 [INFO] [stdout] | [INFO] [stdout] 820 | container.read(stateful).1(0); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u32, impl (Fn(u32)) + CData) {tests::eq_check_skips_unneeded_rebuilds::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:820:9 [INFO] [stdout] | [INFO] [stdout] 820 | container.read(stateful).1(0); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u32, impl (Fn(u32)) + CData) {tests::eq_check_skips_unneeded_rebuilds::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:820:9 [INFO] [stdout] | [INFO] [stdout] 787 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u32, impl CData + Fn(u32)) { [INFO] [stdout] | -------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 820 | container.read(stateful).1(0); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u32)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u32)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:821:20 [INFO] [stdout] | [INFO] [stdout] 787 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u32, impl CData + Fn(u32)) { [INFO] [stdout] | -------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 821 | assert_eq!(get_build_count(stateful), 2); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u32)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u32)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:761:31 [INFO] [stdout] | [INFO] [stdout] 761 | fn get_build_count(_capsule: C) -> u32 { [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:829:20 [INFO] [stdout] | [INFO] [stdout] 787 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u32, impl CData + Fn(u32)) { [INFO] [stdout] | -------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 829 | assert_eq!(get_build_count(stateful), 2); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u32)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u32)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:761:31 [INFO] [stdout] | [INFO] [stdout] 761 | fn get_build_count(_capsule: C) -> u32 { [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:835:9 [INFO] [stdout] | [INFO] [stdout] 787 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u32, impl CData + Fn(u32)) { [INFO] [stdout] | -------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 835 | container.read(stateful).1(1); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u32)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u32)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:835:9 [INFO] [stdout] | [INFO] [stdout] 835 | container.read(stateful).1(1); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u32, impl (Fn(u32)) + CData) {tests::eq_check_skips_unneeded_rebuilds::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:835:9 [INFO] [stdout] | [INFO] [stdout] 835 | container.read(stateful).1(1); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u32, impl (Fn(u32)) + CData) {tests::eq_check_skips_unneeded_rebuilds::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:835:9 [INFO] [stdout] | [INFO] [stdout] 835 | container.read(stateful).1(1); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u32, impl (Fn(u32)) + CData) {tests::eq_check_skips_unneeded_rebuilds::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:835:9 [INFO] [stdout] | [INFO] [stdout] 787 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u32, impl CData + Fn(u32)) { [INFO] [stdout] | -------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 835 | container.read(stateful).1(1); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u32)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u32)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:836:20 [INFO] [stdout] | [INFO] [stdout] 787 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u32, impl CData + Fn(u32)) { [INFO] [stdout] | -------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 836 | assert_eq!(get_build_count(stateful), 3); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u32)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u32)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:761:31 [INFO] [stdout] | [INFO] [stdout] 761 | fn get_build_count(_capsule: C) -> u32 { [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:844:20 [INFO] [stdout] | [INFO] [stdout] 787 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u32, impl CData + Fn(u32)) { [INFO] [stdout] | -------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 844 | assert_eq!(get_build_count(stateful), 3); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u32)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u32)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:761:31 [INFO] [stdout] | [INFO] [stdout] 761 | fn get_build_count(_capsule: C) -> u32 { [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:853:9 [INFO] [stdout] | [INFO] [stdout] 787 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u32, impl CData + Fn(u32)) { [INFO] [stdout] | -------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 853 | container.read(stateful).1(2); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u32)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u32)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:853:9 [INFO] [stdout] | [INFO] [stdout] 853 | container.read(stateful).1(2); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u32, impl (Fn(u32)) + CData) {tests::eq_check_skips_unneeded_rebuilds::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:853:9 [INFO] [stdout] | [INFO] [stdout] 853 | container.read(stateful).1(2); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u32, impl (Fn(u32)) + CData) {tests::eq_check_skips_unneeded_rebuilds::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:853:9 [INFO] [stdout] | [INFO] [stdout] 853 | container.read(stateful).1(2); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u32, impl (Fn(u32)) + CData) {tests::eq_check_skips_unneeded_rebuilds::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:853:9 [INFO] [stdout] | [INFO] [stdout] 787 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u32, impl CData + Fn(u32)) { [INFO] [stdout] | -------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 853 | container.read(stateful).1(2); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u32)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u32)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:854:20 [INFO] [stdout] | [INFO] [stdout] 787 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u32, impl CData + Fn(u32)) { [INFO] [stdout] | -------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 854 | assert_eq!(get_build_count(stateful), 4); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u32)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u32)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:761:31 [INFO] [stdout] | [INFO] [stdout] 761 | fn get_build_count(_capsule: C) -> u32 { [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:862:20 [INFO] [stdout] | [INFO] [stdout] 787 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u32, impl CData + Fn(u32)) { [INFO] [stdout] | -------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 862 | assert_eq!(get_build_count(stateful), 4); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u32)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u32)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:761:31 [INFO] [stdout] | [INFO] [stdout] 761 | fn get_build_count(_capsule: C) -> u32 { [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:792:17 [INFO] [stdout] | [INFO] [stdout] 787 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u32, impl CData + Fn(u32)) { [INFO] [stdout] | -------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 792 | _ = get.as_ref(stateful); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u32)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u32)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/capsule_reader.rs:31:22 [INFO] [stdout] | [INFO] [stdout] 31 | pub fn as_ref(&mut self, capsule: C) -> &C::Data { [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:792:17 [INFO] [stdout] | [INFO] [stdout] 787 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u32, impl CData + Fn(u32)) { [INFO] [stdout] | -------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 792 | _ = get.as_ref(stateful); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u32)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u32)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:792:17 [INFO] [stdout] | [INFO] [stdout] 792 | _ = get.as_ref(stateful); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u32, impl (Fn(u32)) + CData) {tests::eq_check_skips_unneeded_rebuilds::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:792:17 [INFO] [stdout] | [INFO] [stdout] 792 | _ = get.as_ref(stateful); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u32, impl (Fn(u32)) + CData) {tests::eq_check_skips_unneeded_rebuilds::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:792:17 [INFO] [stdout] | [INFO] [stdout] 792 | _ = get.as_ref(stateful); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u32, impl (Fn(u32)) + CData) {tests::eq_check_skips_unneeded_rebuilds::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:799:13 [INFO] [stdout] | [INFO] [stdout] 787 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u32, impl CData + Fn(u32)) { [INFO] [stdout] | -------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 799 | get.as_ref(stateful).0 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u32)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u32)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/capsule_reader.rs:31:22 [INFO] [stdout] | [INFO] [stdout] 31 | pub fn as_ref(&mut self, capsule: C) -> &C::Data { [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:799:13 [INFO] [stdout] | [INFO] [stdout] 787 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u32, impl CData + Fn(u32)) { [INFO] [stdout] | -------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 799 | get.as_ref(stateful).0 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u32)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u32)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:799:13 [INFO] [stdout] | [INFO] [stdout] 799 | get.as_ref(stateful).0 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u32, impl (Fn(u32)) + CData) {tests::eq_check_skips_unneeded_rebuilds::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:799:13 [INFO] [stdout] | [INFO] [stdout] 799 | get.as_ref(stateful).0 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u32, impl (Fn(u32)) + CData) {tests::eq_check_skips_unneeded_rebuilds::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:799:13 [INFO] [stdout] | [INFO] [stdout] 799 | get.as_ref(stateful).0 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u32, impl (Fn(u32)) + CData) {tests::eq_check_skips_unneeded_rebuilds::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:965:9 [INFO] [stdout] | [INFO] [stdout] 940 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 965 | container.read(stateful).1(1); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:965:9 [INFO] [stdout] | [INFO] [stdout] 965 | container.read(stateful).1(1); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::dynamic_and_static_capsules::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:965:9 [INFO] [stdout] | [INFO] [stdout] 965 | container.read(stateful).1(1); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::dynamic_and_static_capsules::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:965:9 [INFO] [stdout] | [INFO] [stdout] 965 | container.read(stateful).1(1); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::dynamic_and_static_capsules::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:965:9 [INFO] [stdout] | [INFO] [stdout] 940 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 965 | container.read(stateful).1(1); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:948:26 [INFO] [stdout] | [INFO] [stdout] 940 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 948 | self.0 + get.as_ref(stateful).0 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/capsule_reader.rs:31:22 [INFO] [stdout] | [INFO] [stdout] 31 | pub fn as_ref(&mut self, capsule: C) -> &C::Data { [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:948:26 [INFO] [stdout] | [INFO] [stdout] 940 | fn stateful(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 948 | self.0 + get.as_ref(stateful).0 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:948:26 [INFO] [stdout] | [INFO] [stdout] 948 | self.0 + get.as_ref(stateful).0 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::dynamic_and_static_capsules::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:948:26 [INFO] [stdout] | [INFO] [stdout] 948 | self.0 + get.as_ref(stateful).0 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::dynamic_and_static_capsules::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:948:26 [INFO] [stdout] | [INFO] [stdout] 948 | self.0 + get.as_ref(stateful).0 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {tests::dynamic_and_static_capsules::stateful}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1019:17 [INFO] [stdout] | [INFO] [stdout] 978 | fn stateful_a(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1019 | assert!(txn.try_read(&stateful_a).is_none()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/txn.rs:28:24 [INFO] [stdout] | [INFO] [stdout] 28 | pub fn try_read(&self, capsule: &C) -> Option [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1019:17 [INFO] [stdout] | [INFO] [stdout] 978 | fn stateful_a(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1019 | assert!(txn.try_read(&stateful_a).is_none()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/txn.rs:30:18 [INFO] [stdout] | [INFO] [stdout] 30 | C::Data: Clone, [INFO] [stdout] | ^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1019:17 [INFO] [stdout] | [INFO] [stdout] 978 | fn stateful_a(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1019 | assert!(txn.try_read(&stateful_a).is_none()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1019:17 [INFO] [stdout] | [INFO] [stdout] 1019 | assert!(txn.try_read(&stateful_a).is_none()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {stateful_a}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1019:17 [INFO] [stdout] | [INFO] [stdout] 1019 | assert!(txn.try_read(&stateful_a).is_none()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {stateful_a}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1019:17 [INFO] [stdout] | [INFO] [stdout] 1019 | assert!(txn.try_read(&stateful_a).is_none()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {stateful_a}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1033:17 [INFO] [stdout] | [INFO] [stdout] 978 | fn stateful_a(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1033 | assert!(txn.try_read(&stateful_a).is_some()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/txn.rs:28:24 [INFO] [stdout] | [INFO] [stdout] 28 | pub fn try_read(&self, capsule: &C) -> Option [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1033:17 [INFO] [stdout] | [INFO] [stdout] 978 | fn stateful_a(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1033 | assert!(txn.try_read(&stateful_a).is_some()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/txn.rs:30:18 [INFO] [stdout] | [INFO] [stdout] 30 | C::Data: Clone, [INFO] [stdout] | ^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1033:17 [INFO] [stdout] | [INFO] [stdout] 978 | fn stateful_a(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1033 | assert!(txn.try_read(&stateful_a).is_some()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1033:17 [INFO] [stdout] | [INFO] [stdout] 1033 | assert!(txn.try_read(&stateful_a).is_some()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {stateful_a}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1033:17 [INFO] [stdout] | [INFO] [stdout] 1033 | assert!(txn.try_read(&stateful_a).is_some()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {stateful_a}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1033:17 [INFO] [stdout] | [INFO] [stdout] 1033 | assert!(txn.try_read(&stateful_a).is_some()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {stateful_a}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1044:9 [INFO] [stdout] | [INFO] [stdout] 978 | fn stateful_a(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1044 | container.read(stateful_a).1(10); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1044:9 [INFO] [stdout] | [INFO] [stdout] 1044 | container.read(stateful_a).1(10); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {stateful_a}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1044:9 [INFO] [stdout] | [INFO] [stdout] 1044 | container.read(stateful_a).1(10); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {stateful_a}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1044:9 [INFO] [stdout] | [INFO] [stdout] 1044 | container.read(stateful_a).1(10); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {stateful_a}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1044:9 [INFO] [stdout] | [INFO] [stdout] 978 | fn stateful_a(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1044 | container.read(stateful_a).1(10); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1047:17 [INFO] [stdout] | [INFO] [stdout] 978 | fn stateful_a(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1047 | assert!(txn.try_read(&stateful_a).is_some()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/txn.rs:28:24 [INFO] [stdout] | [INFO] [stdout] 28 | pub fn try_read(&self, capsule: &C) -> Option [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1047:17 [INFO] [stdout] | [INFO] [stdout] 978 | fn stateful_a(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1047 | assert!(txn.try_read(&stateful_a).is_some()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/txn.rs:30:18 [INFO] [stdout] | [INFO] [stdout] 30 | C::Data: Clone, [INFO] [stdout] | ^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1047:17 [INFO] [stdout] | [INFO] [stdout] 978 | fn stateful_a(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1047 | assert!(txn.try_read(&stateful_a).is_some()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1047:17 [INFO] [stdout] | [INFO] [stdout] 1047 | assert!(txn.try_read(&stateful_a).is_some()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {stateful_a}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1047:17 [INFO] [stdout] | [INFO] [stdout] 1047 | assert!(txn.try_read(&stateful_a).is_some()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {stateful_a}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1047:17 [INFO] [stdout] | [INFO] [stdout] 1047 | assert!(txn.try_read(&stateful_a).is_some()); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {stateful_a}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:983:13 [INFO] [stdout] | [INFO] [stdout] 978 | fn stateful_a(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 983 | get.as_ref(stateful_a).0 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/capsule_reader.rs:31:22 [INFO] [stdout] | [INFO] [stdout] 31 | pub fn as_ref(&mut self, capsule: C) -> &C::Data { [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:983:13 [INFO] [stdout] | [INFO] [stdout] 978 | fn stateful_a(CapsuleHandle { register, .. }: CapsuleHandle) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 983 | get.as_ref(stateful_a).0 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:983:13 [INFO] [stdout] | [INFO] [stdout] 983 | get.as_ref(stateful_a).0 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {stateful_a}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:983:13 [INFO] [stdout] | [INFO] [stdout] 983 | get.as_ref(stateful_a).0 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {stateful_a}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:983:13 [INFO] [stdout] | [INFO] [stdout] 983 | get.as_ref(stateful_a).0 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {stateful_a}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1092:17 [INFO] [stdout] | [INFO] [stdout] 1064 | ) -> ((u8, impl CData + Fn(u8)), (u8, impl CData + Fn(u8))) { [INFO] [stdout] | ------------------- ------------------- [INFO] [stdout] | | | [INFO] [stdout] | | one of the expected opaque types [INFO] [stdout] | | one of the found opaque types [INFO] [stdout] | one of the expected opaque types [INFO] [stdout] | one of the found opaque types [INFO] [stdout] ... [INFO] [stdout] 1092 | _ = get.as_ref(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `((_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData), (_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData))` [INFO] [stdout] found tuple `((_, impl (Fn(u8)) + CData), (_, impl (Fn(u8)) + CData))` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/capsule_reader.rs:31:22 [INFO] [stdout] | [INFO] [stdout] 31 | pub fn as_ref(&mut self, capsule: C) -> &C::Data { [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1092:17 [INFO] [stdout] | [INFO] [stdout] 1064 | ) -> ((u8, impl CData + Fn(u8)), (u8, impl CData + Fn(u8))) { [INFO] [stdout] | ------------------- ------------------- [INFO] [stdout] | | | [INFO] [stdout] | | one of the expected opaque types [INFO] [stdout] | | one of the found opaque types [INFO] [stdout] | one of the expected opaque types [INFO] [stdout] | one of the found opaque types [INFO] [stdout] ... [INFO] [stdout] 1092 | _ = get.as_ref(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `((_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData), (_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData))` [INFO] [stdout] found tuple `((_, impl (Fn(u8)) + CData), (_, impl (Fn(u8)) + CData))` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1092:17 [INFO] [stdout] | [INFO] [stdout] 1092 | _ = get.as_ref(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1092:17 [INFO] [stdout] | [INFO] [stdout] 1092 | _ = get.as_ref(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1092:17 [INFO] [stdout] | [INFO] [stdout] 1092 | _ = get.as_ref(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1093:17 [INFO] [stdout] | [INFO] [stdout] 1070 | ) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1093 | _ = get.as_ref(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/capsule_reader.rs:31:22 [INFO] [stdout] | [INFO] [stdout] 31 | pub fn as_ref(&mut self, capsule: C) -> &C::Data { [INFO] [stdout] | ^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1093:17 [INFO] [stdout] | [INFO] [stdout] 1070 | ) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1093 | _ = get.as_ref(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1093:17 [INFO] [stdout] | [INFO] [stdout] 1093 | _ = get.as_ref(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {side_effect_txns::another_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1093:17 [INFO] [stdout] | [INFO] [stdout] 1093 | _ = get.as_ref(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {side_effect_txns::another_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1093:17 [INFO] [stdout] | [INFO] [stdout] 1093 | _ = get.as_ref(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {side_effect_txns::another_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1113:42 [INFO] [stdout] | [INFO] [stdout] 1064 | ) -> ((u8, impl CData + Fn(u8)), (u8, impl CData + Fn(u8))) { [INFO] [stdout] | ------------------- ------------------- [INFO] [stdout] | | | [INFO] [stdout] | | one of the expected opaque types [INFO] [stdout] | | one of the found opaque types [INFO] [stdout] | one of the expected opaque types [INFO] [stdout] | one of the found opaque types [INFO] [stdout] ... [INFO] [stdout] 1113 | let ((s1, ss1), (s2, ss2)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `((_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData), (_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData))` [INFO] [stdout] found tuple `((_, impl (Fn(u8)) + CData), (_, impl (Fn(u8)) + CData))` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1113:42 [INFO] [stdout] | [INFO] [stdout] 1113 | let ((s1, ss1), (s2, ss2)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1113:42 [INFO] [stdout] | [INFO] [stdout] 1113 | let ((s1, ss1), (s2, ss2)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1113:42 [INFO] [stdout] | [INFO] [stdout] 1113 | let ((s1, ss1), (s2, ss2)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1113:42 [INFO] [stdout] | [INFO] [stdout] 1064 | ) -> ((u8, impl CData + Fn(u8)), (u8, impl CData + Fn(u8))) { [INFO] [stdout] | ------------------- ------------------- [INFO] [stdout] | | | [INFO] [stdout] | | one of the expected opaque types [INFO] [stdout] | | one of the found opaque types [INFO] [stdout] | one of the expected opaque types [INFO] [stdout] | one of the found opaque types [INFO] [stdout] ... [INFO] [stdout] 1113 | let ((s1, ss1), (s2, ss2)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `((_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData), (_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData))` [INFO] [stdout] found tuple `((_, impl (Fn(u8)) + CData), (_, impl (Fn(u8)) + CData))` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1123:38 [INFO] [stdout] | [INFO] [stdout] 1064 | ) -> ((u8, impl CData + Fn(u8)), (u8, impl CData + Fn(u8))) { [INFO] [stdout] | ------------------- ------------------- [INFO] [stdout] | | | [INFO] [stdout] | | one of the expected opaque types [INFO] [stdout] | | one of the found opaque types [INFO] [stdout] | one of the expected opaque types [INFO] [stdout] | one of the found opaque types [INFO] [stdout] ... [INFO] [stdout] 1123 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `((_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData), (_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData))` [INFO] [stdout] found tuple `((_, impl (Fn(u8)) + CData), (_, impl (Fn(u8)) + CData))` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1123:38 [INFO] [stdout] | [INFO] [stdout] 1123 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1123:38 [INFO] [stdout] | [INFO] [stdout] 1123 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1123:38 [INFO] [stdout] | [INFO] [stdout] 1123 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1123:38 [INFO] [stdout] | [INFO] [stdout] 1064 | ) -> ((u8, impl CData + Fn(u8)), (u8, impl CData + Fn(u8))) { [INFO] [stdout] | ------------------- ------------------- [INFO] [stdout] | | | [INFO] [stdout] | | one of the expected opaque types [INFO] [stdout] | | one of the found opaque types [INFO] [stdout] | one of the expected opaque types [INFO] [stdout] | one of the found opaque types [INFO] [stdout] ... [INFO] [stdout] 1123 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `((_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData), (_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData))` [INFO] [stdout] found tuple `((_, impl (Fn(u8)) + CData), (_, impl (Fn(u8)) + CData))` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1133:40 [INFO] [stdout] | [INFO] [stdout] 1064 | ) -> ((u8, impl CData + Fn(u8)), (u8, impl CData + Fn(u8))) { [INFO] [stdout] | ------------------- ------------------- [INFO] [stdout] | | | [INFO] [stdout] | | one of the expected opaque types [INFO] [stdout] | | one of the found opaque types [INFO] [stdout] | one of the expected opaque types [INFO] [stdout] | one of the found opaque types [INFO] [stdout] ... [INFO] [stdout] 1133 | let ((s1, ss1), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `((_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData), (_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData))` [INFO] [stdout] found tuple `((_, impl (Fn(u8)) + CData), (_, impl (Fn(u8)) + CData))` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1133:40 [INFO] [stdout] | [INFO] [stdout] 1133 | let ((s1, ss1), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1133:40 [INFO] [stdout] | [INFO] [stdout] 1133 | let ((s1, ss1), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1133:40 [INFO] [stdout] | [INFO] [stdout] 1133 | let ((s1, ss1), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1133:40 [INFO] [stdout] | [INFO] [stdout] 1064 | ) -> ((u8, impl CData + Fn(u8)), (u8, impl CData + Fn(u8))) { [INFO] [stdout] | ------------------- ------------------- [INFO] [stdout] | | | [INFO] [stdout] | | one of the expected opaque types [INFO] [stdout] | | one of the found opaque types [INFO] [stdout] | one of the expected opaque types [INFO] [stdout] | one of the found opaque types [INFO] [stdout] ... [INFO] [stdout] 1133 | let ((s1, ss1), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `((_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData), (_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData))` [INFO] [stdout] found tuple `((_, impl (Fn(u8)) + CData), (_, impl (Fn(u8)) + CData))` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1134:29 [INFO] [stdout] | [INFO] [stdout] 1070 | ) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1134 | let (s3, ss3) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1134:29 [INFO] [stdout] | [INFO] [stdout] 1134 | let (s3, ss3) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {side_effect_txns::another_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1134:29 [INFO] [stdout] | [INFO] [stdout] 1134 | let (s3, ss3) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {side_effect_txns::another_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1134:29 [INFO] [stdout] | [INFO] [stdout] 1134 | let (s3, ss3) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {side_effect_txns::another_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1134:29 [INFO] [stdout] | [INFO] [stdout] 1070 | ) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1134 | let (s3, ss3) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1145:38 [INFO] [stdout] | [INFO] [stdout] 1064 | ) -> ((u8, impl CData + Fn(u8)), (u8, impl CData + Fn(u8))) { [INFO] [stdout] | ------------------- ------------------- [INFO] [stdout] | | | [INFO] [stdout] | | one of the expected opaque types [INFO] [stdout] | | one of the found opaque types [INFO] [stdout] | one of the expected opaque types [INFO] [stdout] | one of the found opaque types [INFO] [stdout] ... [INFO] [stdout] 1145 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `((_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData), (_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData))` [INFO] [stdout] found tuple `((_, impl (Fn(u8)) + CData), (_, impl (Fn(u8)) + CData))` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1145:38 [INFO] [stdout] | [INFO] [stdout] 1145 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1145:38 [INFO] [stdout] | [INFO] [stdout] 1145 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1145:38 [INFO] [stdout] | [INFO] [stdout] 1145 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1145:38 [INFO] [stdout] | [INFO] [stdout] 1064 | ) -> ((u8, impl CData + Fn(u8)), (u8, impl CData + Fn(u8))) { [INFO] [stdout] | ------------------- ------------------- [INFO] [stdout] | | | [INFO] [stdout] | | one of the expected opaque types [INFO] [stdout] | | one of the found opaque types [INFO] [stdout] | one of the expected opaque types [INFO] [stdout] | one of the found opaque types [INFO] [stdout] ... [INFO] [stdout] 1145 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `((_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData), (_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData))` [INFO] [stdout] found tuple `((_, impl (Fn(u8)) + CData), (_, impl (Fn(u8)) + CData))` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1146:27 [INFO] [stdout] | [INFO] [stdout] 1070 | ) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1146 | let (s3, _) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1146:27 [INFO] [stdout] | [INFO] [stdout] 1146 | let (s3, _) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {side_effect_txns::another_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1146:27 [INFO] [stdout] | [INFO] [stdout] 1146 | let (s3, _) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {side_effect_txns::another_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1146:27 [INFO] [stdout] | [INFO] [stdout] 1146 | let (s3, _) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {side_effect_txns::another_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1146:27 [INFO] [stdout] | [INFO] [stdout] 1070 | ) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1146 | let (s3, _) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1157:38 [INFO] [stdout] | [INFO] [stdout] 1064 | ) -> ((u8, impl CData + Fn(u8)), (u8, impl CData + Fn(u8))) { [INFO] [stdout] | ------------------- ------------------- [INFO] [stdout] | | | [INFO] [stdout] | | one of the expected opaque types [INFO] [stdout] | | one of the found opaque types [INFO] [stdout] | one of the expected opaque types [INFO] [stdout] | one of the found opaque types [INFO] [stdout] ... [INFO] [stdout] 1157 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `((_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData), (_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData))` [INFO] [stdout] found tuple `((_, impl (Fn(u8)) + CData), (_, impl (Fn(u8)) + CData))` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1157:38 [INFO] [stdout] | [INFO] [stdout] 1157 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1157:38 [INFO] [stdout] | [INFO] [stdout] 1157 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1157:38 [INFO] [stdout] | [INFO] [stdout] 1157 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1157:38 [INFO] [stdout] | [INFO] [stdout] 1064 | ) -> ((u8, impl CData + Fn(u8)), (u8, impl CData + Fn(u8))) { [INFO] [stdout] | ------------------- ------------------- [INFO] [stdout] | | | [INFO] [stdout] | | one of the expected opaque types [INFO] [stdout] | | one of the found opaque types [INFO] [stdout] | one of the expected opaque types [INFO] [stdout] | one of the found opaque types [INFO] [stdout] ... [INFO] [stdout] 1157 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `((_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData), (_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData))` [INFO] [stdout] found tuple `((_, impl (Fn(u8)) + CData), (_, impl (Fn(u8)) + CData))` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1158:27 [INFO] [stdout] | [INFO] [stdout] 1070 | ) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1158 | let (s3, _) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1158:27 [INFO] [stdout] | [INFO] [stdout] 1158 | let (s3, _) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {side_effect_txns::another_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1158:27 [INFO] [stdout] | [INFO] [stdout] 1158 | let (s3, _) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {side_effect_txns::another_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1158:27 [INFO] [stdout] | [INFO] [stdout] 1158 | let (s3, _) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {side_effect_txns::another_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1158:27 [INFO] [stdout] | [INFO] [stdout] 1070 | ) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1158 | let (s3, _) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1163:13 [INFO] [stdout] | [INFO] [stdout] 1076 | ) -> impl CData + Fn(u8) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1163 | container.read(batch_all_updates_action)(123); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected opaque type `impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData` [INFO] [stdout] found opaque type `impl (Fn(u8)) + CData` [INFO] [stdout] = note: distinct uses of `impl Trait` result in different opaque types [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1163:13 [INFO] [stdout] | [INFO] [stdout] 1163 | container.read(batch_all_updates_action)(123); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> impl (Fn(u8)) + CData {batch_all_updates_action}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1163:13 [INFO] [stdout] | [INFO] [stdout] 1163 | container.read(batch_all_updates_action)(123); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> impl (Fn(u8)) + CData {batch_all_updates_action}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1163:13 [INFO] [stdout] | [INFO] [stdout] 1163 | container.read(batch_all_updates_action)(123); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> impl (Fn(u8)) + CData {batch_all_updates_action}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1163:13 [INFO] [stdout] | [INFO] [stdout] 1076 | ) -> impl CData + Fn(u8) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1163 | container.read(batch_all_updates_action)(123); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected opaque type `impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData` [INFO] [stdout] found opaque type `impl (Fn(u8)) + CData` [INFO] [stdout] = note: distinct uses of `impl Trait` result in different opaque types [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1166:38 [INFO] [stdout] | [INFO] [stdout] 1064 | ) -> ((u8, impl CData + Fn(u8)), (u8, impl CData + Fn(u8))) { [INFO] [stdout] | ------------------- ------------------- [INFO] [stdout] | | | [INFO] [stdout] | | one of the expected opaque types [INFO] [stdout] | | one of the found opaque types [INFO] [stdout] | one of the expected opaque types [INFO] [stdout] | one of the found opaque types [INFO] [stdout] ... [INFO] [stdout] 1166 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `((_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData), (_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData))` [INFO] [stdout] found tuple `((_, impl (Fn(u8)) + CData), (_, impl (Fn(u8)) + CData))` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1166:38 [INFO] [stdout] | [INFO] [stdout] 1166 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1166:38 [INFO] [stdout] | [INFO] [stdout] 1166 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1166:38 [INFO] [stdout] | [INFO] [stdout] 1166 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1166:38 [INFO] [stdout] | [INFO] [stdout] 1064 | ) -> ((u8, impl CData + Fn(u8)), (u8, impl CData + Fn(u8))) { [INFO] [stdout] | ------------------- ------------------- [INFO] [stdout] | | | [INFO] [stdout] | | one of the expected opaque types [INFO] [stdout] | | one of the found opaque types [INFO] [stdout] | one of the expected opaque types [INFO] [stdout] | one of the found opaque types [INFO] [stdout] ... [INFO] [stdout] 1166 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `((_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData), (_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData))` [INFO] [stdout] found tuple `((_, impl (Fn(u8)) + CData), (_, impl (Fn(u8)) + CData))` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1167:27 [INFO] [stdout] | [INFO] [stdout] 1070 | ) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1167 | let (s3, _) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1167:27 [INFO] [stdout] | [INFO] [stdout] 1167 | let (s3, _) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {side_effect_txns::another_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1167:27 [INFO] [stdout] | [INFO] [stdout] 1167 | let (s3, _) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {side_effect_txns::another_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1167:27 [INFO] [stdout] | [INFO] [stdout] 1167 | let (s3, _) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {side_effect_txns::another_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1167:27 [INFO] [stdout] | [INFO] [stdout] 1070 | ) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1167 | let (s3, _) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1187:21 [INFO] [stdout] | [INFO] [stdout] 1076 | ) -> impl CData + Fn(u8) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1187 | container.read(batch_all_updates_action)(123); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected opaque type `impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData` [INFO] [stdout] found opaque type `impl (Fn(u8)) + CData` [INFO] [stdout] = note: distinct uses of `impl Trait` result in different opaque types [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1187:21 [INFO] [stdout] | [INFO] [stdout] 1187 | container.read(batch_all_updates_action)(123); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> impl (Fn(u8)) + CData {batch_all_updates_action}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1187:21 [INFO] [stdout] | [INFO] [stdout] 1187 | container.read(batch_all_updates_action)(123); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> impl (Fn(u8)) + CData {batch_all_updates_action}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1187:21 [INFO] [stdout] | [INFO] [stdout] 1187 | container.read(batch_all_updates_action)(123); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> impl (Fn(u8)) + CData {batch_all_updates_action}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1187:21 [INFO] [stdout] | [INFO] [stdout] 1076 | ) -> impl CData + Fn(u8) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1187 | container.read(batch_all_updates_action)(123); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected opaque type `impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData` [INFO] [stdout] found opaque type `impl (Fn(u8)) + CData` [INFO] [stdout] = note: distinct uses of `impl Trait` result in different opaque types [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1178:40 [INFO] [stdout] | [INFO] [stdout] 1064 | ) -> ((u8, impl CData + Fn(u8)), (u8, impl CData + Fn(u8))) { [INFO] [stdout] | ------------------- ------------------- [INFO] [stdout] | | | [INFO] [stdout] | | one of the expected opaque types [INFO] [stdout] | | one of the found opaque types [INFO] [stdout] | one of the expected opaque types [INFO] [stdout] | one of the found opaque types [INFO] [stdout] ... [INFO] [stdout] 1178 | let ((s1, ss1), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `((_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData), (_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData))` [INFO] [stdout] found tuple `((_, impl (Fn(u8)) + CData), (_, impl (Fn(u8)) + CData))` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1178:40 [INFO] [stdout] | [INFO] [stdout] 1178 | let ((s1, ss1), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1178:40 [INFO] [stdout] | [INFO] [stdout] 1178 | let ((s1, ss1), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1178:40 [INFO] [stdout] | [INFO] [stdout] 1178 | let ((s1, ss1), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1178:40 [INFO] [stdout] | [INFO] [stdout] 1064 | ) -> ((u8, impl CData + Fn(u8)), (u8, impl CData + Fn(u8))) { [INFO] [stdout] | ------------------- ------------------- [INFO] [stdout] | | | [INFO] [stdout] | | one of the expected opaque types [INFO] [stdout] | | one of the found opaque types [INFO] [stdout] | one of the expected opaque types [INFO] [stdout] | one of the found opaque types [INFO] [stdout] ... [INFO] [stdout] 1178 | let ((s1, ss1), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `((_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData), (_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData))` [INFO] [stdout] found tuple `((_, impl (Fn(u8)) + CData), (_, impl (Fn(u8)) + CData))` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1179:29 [INFO] [stdout] | [INFO] [stdout] 1070 | ) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1179 | let (s3, ss3) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1179:29 [INFO] [stdout] | [INFO] [stdout] 1179 | let (s3, ss3) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {side_effect_txns::another_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1179:29 [INFO] [stdout] | [INFO] [stdout] 1179 | let (s3, ss3) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {side_effect_txns::another_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1179:29 [INFO] [stdout] | [INFO] [stdout] 1179 | let (s3, ss3) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {side_effect_txns::another_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1179:29 [INFO] [stdout] | [INFO] [stdout] 1070 | ) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1179 | let (s3, ss3) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1193:38 [INFO] [stdout] | [INFO] [stdout] 1064 | ) -> ((u8, impl CData + Fn(u8)), (u8, impl CData + Fn(u8))) { [INFO] [stdout] | ------------------- ------------------- [INFO] [stdout] | | | [INFO] [stdout] | | one of the expected opaque types [INFO] [stdout] | | one of the found opaque types [INFO] [stdout] | one of the expected opaque types [INFO] [stdout] | one of the found opaque types [INFO] [stdout] ... [INFO] [stdout] 1193 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `((_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData), (_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData))` [INFO] [stdout] found tuple `((_, impl (Fn(u8)) + CData), (_, impl (Fn(u8)) + CData))` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1193:38 [INFO] [stdout] | [INFO] [stdout] 1193 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1193:38 [INFO] [stdout] | [INFO] [stdout] 1193 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1193:38 [INFO] [stdout] | [INFO] [stdout] 1193 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> ((u8, impl (Fn(u8)) + CData), (u8, impl (Fn(u8)) + CData)) {two_side_effects_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1193:38 [INFO] [stdout] | [INFO] [stdout] 1064 | ) -> ((u8, impl CData + Fn(u8)), (u8, impl CData + Fn(u8))) { [INFO] [stdout] | ------------------- ------------------- [INFO] [stdout] | | | [INFO] [stdout] | | one of the expected opaque types [INFO] [stdout] | | one of the found opaque types [INFO] [stdout] | one of the expected opaque types [INFO] [stdout] | one of the found opaque types [INFO] [stdout] ... [INFO] [stdout] 1193 | let ((s1, _), (s2, _)) = container.read(two_side_effects_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `((_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData), (_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData))` [INFO] [stdout] found tuple `((_, impl (Fn(u8)) + CData), (_, impl (Fn(u8)) + CData))` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1194:27 [INFO] [stdout] | [INFO] [stdout] 1070 | ) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1194 | let (s3, _) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] note: the lifetime requirement is introduced here [INFO] [stdout] --> src/lib.rs:156:27 [INFO] [stdout] | [INFO] [stdout] 156 | pub fn read(&self, capsules: Capsules) -> Capsules::Data { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1194:27 [INFO] [stdout] | [INFO] [stdout] 1194 | let (s3, _) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {side_effect_txns::another_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'0, '_, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1194:27 [INFO] [stdout] | [INFO] [stdout] 1194 | let (s3, _) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {side_effect_txns::another_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '0, '_>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: implementation of `FnOnce` is not general enough [INFO] [stdout] --> src/lib.rs:1194:27 [INFO] [stdout] | [INFO] [stdout] 1194 | let (s3, _) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough [INFO] [stdout] | [INFO] [stdout] = note: `for<'a, 'b, 'c> fn(CapsuleHandle<'a, 'b, 'c>) -> (u8, impl (Fn(u8)) + CData) {side_effect_txns::another_capsule}` must implement `FnOnce<(CapsuleHandle<'_, '_, '_>,)>` [INFO] [stdout] = note: ...but it actually implements `FnOnce<(CapsuleHandle<'_, '_, '0>,)>`, for some specific lifetime `'0` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error[E0308]: mismatched types [INFO] [stdout] --> src/lib.rs:1194:27 [INFO] [stdout] | [INFO] [stdout] 1070 | ) -> (u8, impl CData + Fn(u8)) { [INFO] [stdout] | ------------------- [INFO] [stdout] | | [INFO] [stdout] | the expected opaque type [INFO] [stdout] | the found opaque type [INFO] [stdout] ... [INFO] [stdout] 1194 | let (s3, _) = container.read(another_capsule); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other [INFO] [stdout] | [INFO] [stdout] = note: expected tuple `(_, impl (for<'a, 'b, 'c> Fn(u8)) + for<'a, 'b, 'c> CData)` [INFO] [stdout] found tuple `(_, impl (Fn(u8)) + CData)` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: aborting due to 261 previous errors [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] Some errors have detailed explanations: E0277, E0308, E0657. [INFO] [stdout] [INFO] [stdout] For more information about an error, try `rustc --explain E0277`. [INFO] [stdout] [INFO] [stderr] error: could not compile `rearch` (lib test) due to 262 previous errors [INFO] [stderr] error: failed to check after updating to 2024 [INFO] [stderr] [INFO] [stderr] Caused by: [INFO] [stderr] process didn't exit successfully: `cargo check --frozen --all --all-targets --message-format=json` (exit status: 101) [INFO] running `Command { std: "docker" "inspect" "053428f0685cf885583524586cd302e474a5f6c7798f047a4356d4a75e2578a5", kill_on_drop: false }` [INFO] running `Command { std: "docker" "rm" "-f" "053428f0685cf885583524586cd302e474a5f6c7798f047a4356d4a75e2578a5", kill_on_drop: false }` [INFO] [stdout] 053428f0685cf885583524586cd302e474a5f6c7798f047a4356d4a75e2578a5