Commit 440e873a authored by Masaki Hara's avatar Masaki Hara Committed by CrLF0710

Simplify fnbox docs.

parent ecc3e89d
......@@ -6,247 +6,27 @@ The tracking issue for this feature is [#28796]
------------------------
As an analogy to `&dyn Fn()` and `&mut dyn FnMut()`, you may have expected
`Box<dyn FnOnce()>` to work. But it hadn't until the recent improvement!
`FnBox` had been a **temporary** solution for this until we are able to pass
trait objects by value.
See [`boxed_closure_impls`][boxed_closure_impls] for the newer approach.
[boxed_closure_impls]: library-features/boxed-closure-impls.html
## Usage
If you want to box `FnOnce` closures, you can use `Box<dyn FnBox()>` instead of `Box<dyn FnOnce()>`.
This had been a temporary alternative to the following impls:
```rust
#![feature(fnbox)]
use std::boxed::FnBox;
fn main() {
let resource = "hello".to_owned();
// Create a boxed once-callable closure
let f: Box<dyn FnBox() -> String> = Box::new(|| resource);
// Call it
let s = f();
println!("{}", s);
}
impl<A, F> FnOnce for Box<F> where F: FnOnce<A> + ?Sized {}
impl<A, F> FnMut for Box<F> where F: FnMut<A> + ?Sized {}
impl<A, F> Fn for Box<F> where F: Fn<A> + ?Sized {}
```
## How `Box<dyn FnOnce()>` did not work
**Spoiler**: [`boxed_closure_impls`][boxed_closure_impls] actually implements
`Box<dyn FnOnce()>`! This didn't work because we lacked features like
[`unsized_locals`][unsized_locals] for a long time. Therefore, this section
just explains historical reasons for `FnBox`.
[unsized_locals]: language-features/unsized-locals.html
### First approach: just provide `Box` adapter impl
The first (and natural) attempt for `Box<dyn FnOnce()>` would look like:
```rust,ignore
impl<A, F: FnOnce<A> + ?Sized> FnOnce<A> for Box<F> {
type Output = <F as FnOnce<A>>::Output;
extern "rust-call" fn call_once(self, args: A) -> Self::Output {
<F as FnOnce<A>>::call_once(*self, args)
}
}
```
However, this doesn't work. We have to relax the `Sized` bound for `F` because
we expect trait objects here, but `*self` must be `Sized` because it is passed
as a function argument.
### The second attempt: add `FnOnce::call_box`
One may come up with this workaround: modify `FnOnce`'s definition like this:
```rust,ignore
pub trait FnOnce<Args> {
type Output;
extern "rust-call" fn call_once(self, args: Args) -> Self::Output;
// Add this new method
extern "rust-call" fn call_box(self: Box<Self>, args: Args) -> Self::Output;
}
```
...and then, modify the `impl` like this:
```rust,ignore
impl<A, F: FnOnce<A> + ?Sized> FnOnce<A> for Box<F> {
type Output = <F as FnOnce<A>>::Output;
extern "rust-call" fn call_once(self, args: A) -> Self::Output {
// We can use `call_box` here!
<F as FnOnce<A>>::call_box(self, args)
}
// We'll have to define this in every impl of `FnOnce`.
extern "rust-call" fn call_box(self: Box<Self>, args: A) -> Self::Output {
<F as FnOnce<A>>::call_box(*self, args)
}
}
```
What's wrong with this? The problem here is crates:
- `FnOnce` is in `libcore`, as it shouldn't depend on allocations.
- `Box` is in `liballoc`, as it:s the very allocated pointer.
It is impossible to add `FnOnce::call_box` because it is reverse-dependency.
There's another problem: `call_box` can't have defaults.
`default impl` from the specialization RFC may resolve this problem.
### The third attempt: add `FnBox` that contains `call_box`
`call_box` can't reside in `FnOnce`, but how about defining a new trait in
`liballoc`?
`FnBox` is almost a copy of `FnOnce`, but with `call_box`:
```rust,ignore
pub trait FnBox<Args> {
type Output;
extern "rust-call" fn call_box(self: Box<Self>, args: Args) -> Self::Output;
}
```
For `Sized` types (from which we coerce into `dyn FnBox`), we define
the blanket impl that proxies calls to `FnOnce`:
```rust,ignore
impl<A, F: FnOnce<A>> FnBox<A> for F {
type Output = <F as FnOnce<A>>::Output;
The impls are parallel to these (relatively old) impls:
extern "rust-call" fn call_box(self: Box<Self>, args: A) -> Self::Output {
// Here we assume `F` to be sized.
<F as FnOnce<A>>::call_once(*self, args)
}
}
```
Now it looks like that we can define `FnOnce` for `Box<F>`.
```rust,ignore
impl<A, F: FnBox<A> + ?Sized> FnOnce<A> for Box<F> {
type Output = <F as FnOnce<A>>::Output;
extern "rust-call" fn call_once(self, args: A) -> Self::Output {
<F as FnBox<A>>::call_box(self, args)
}
}
```
## Limitations of `FnBox`
### Interaction with HRTB
Firstly, the actual implementation is different from the one presented above.
Instead of implementing `FnOnce` for `Box<impl FnBox>`, `liballoc` only
implements `FnOnce` for `Box<dyn FnBox>`.
```rust,ignore
impl<'a, A, R> FnOnce<A> for Box<dyn FnBox<A, Output = R> + 'a> {
type Output = R;
extern "rust-call" fn call_once(self, args: A) -> Self::Output {
FnBox::call_box(*self, args)
}
}
// Sendable variant
impl<'a, A, R> FnOnce<A> for Box<dyn FnBox<A, Output = R> + Send + 'a> {
type Output = R;
extern "rust-call" fn call_once(self, args: A) -> Self::Output {
FnBox::call_box(*self, args)
}
}
```
The consequence is that the following example doesn't work:
```rust,compile_fail
#![feature(fnbox)]
use std::boxed::FnBox;
fn main() {
let f: Box<dyn FnBox(&i32)> = Box::new(|x| println!("{}", x));
f(42);
}
```
Note that `dyn FnBox(&i32)` desugars to
`dyn for<'r> FnBox<(&'r i32,), Output = ()>`.
It isn't covered in `dyn FnBox<A, Output = R> + 'a` or
`dyn FnBox<A, Output = R> + Send + 'a` due to HRTB.
### Interaction with `Fn`/`FnMut`
It would be natural to have the following impls:
```rust,ignore
impl<A, F: FnMut<A> + ?Sized> FnMut<A> for Box<F> {
// ...
}
impl<A, F: Fn<A> + ?Sized> Fn<A> for Box<F> {
// ...
}
```
However, we hadn't been able to write these in presense of `FnBox`
(until [`boxed_closure_impls`][boxed_closure_impls] lands).
To have `FnMut<A>` for `Box<F>`, we should have (at least) this impl:
```rust,ignore
// Note here we only impose `F: FnMut<A>`.
// If we can write `F: FnOnce<A>` here, that will resolve all problems.
impl<A, F: FnMut<A> + ?Sized> FnOnce<A> for Box<F> {
// ...
}
```
Unfortunately, the compiler complains that it **overlaps** with our
`dyn FnBox()` impls. At first glance, the overlap must not happen.
The `A` generic parameter does the trick here: due to coherence rules,
a downstream crate may define the following impl:
```rust,ignore
struct MyStruct;
impl<'a> FnMut<MyStruct> for dyn FnBox<MyStruct, Output = ()> + 'a {
// ...
}
```rust
impl<A, F> FnOnce for &mut F where F: FnMut<A> + ?Sized {}
impl<A, F> FnMut for &mut F where F: FnMut<A> + ?Sized {}
impl<A, F> Fn for &mut F where F: Fn<A> + ?Sized {}
impl<A, F> FnOnce for &F where F: Fn<A> + ?Sized {}
impl<A, F> FnMut for &F where F: Fn<A> + ?Sized {}
impl<A, F> Fn for &F where F: Fn<A> + ?Sized {}
```
The trait solver doesn't know that `A` is always a tuple type, so this is
still possible. With this in mind, the compiler emits the overlap error.
## Modification
For compatibility with [`boxed_closure_impls`][boxed_closure_impls],
we now have a slightly modified version of `FnBox`:
Before the introduction of [`unsized_locals`][unsized_locals], we had been unable to provide the former impls. That means, unlike `&dyn Fn()` or `&mut dyn FnMut()` we could not use `Box<dyn FnOnce()>` at that time.
```rust,ignore
// It's now a subtrait of `FnOnce`
pub trait FnBox<Args>: FnOnce<Args> {
// now uses FnOnce::Output
// type Output;
extern "rust-call" fn call_box(self: Box<Self>, args: Args) -> Self::Output;
}
```
## The future of `fnbox`
[unsized_locals]: language-features/unsized-locals.html
`FnBox` has long been considered a temporary solution for `Box<FnOnce>`
problem. Since we have [`boxed_closure_impls`][boxed_closure_impls] now,
it may be deprecated and removed in the future.
`FnBox()` is an alternative approach to `Box<dyn FnBox()>` is delegated to `FnBox::call_box` which doesn't need unsized locals. As we now have `Box<dyn FnOnce()>` working, the `fnbox` feature is going to be removed.
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment