Skip to content

Commit

Permalink
Simplify fnbox docs.
Browse files Browse the repository at this point in the history
  • Loading branch information
@qnighy @crlf0710
qnighy authored and crlf0710 committed Apr 4, 2019
1 parent ecc3e89 commit 440e873
Showing 1 changed file with 15 additions and 235 deletions.
250 changes: 15 additions & 235 deletions src/doc/unstable-book/src/library-features/fnbox.md
View file
Expand Up @@ -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.

0 comments on commit 440e873

Please sign in to comment.