I have a case where a function expects a reply callback with a result (e.g. bool for success), but the caller doesn't really care about the result at all, e.g.
```
void Foo(base::OnceCallback<void(bool)> reply_callback);
Bar(base::OnceClosure closure) {
Foo(???) // Needs an adapter from `closure` to `reply_callback` that ignores the result.
}
```
For example:
```
void IgnoreResult(base::OnceClosure callback, bool /*success*/) {
std::move(callback).Run();
}
Bar(base::OnceClosure closure) {
Foo(base::BindOnce(&IgnoreResult, std::move(closure)));
}
```
That all worked pretty well until I realized there's already a base::IgnoreResult, that ignores the "return value".
I would argue that "return" and "result" have different meanings in the callback world. "return" is the sync return value, and "result" is often the async returned result. All the documentation on base::IgnoreResult mentions that it's the return value that's being ignored.
With that, does it make sense to rename base::IgnoreResult to base::IgnoreReturn? If possible, I'd like to add the above IgnoreResult() (and make it templated) to bind.h, but that can be a different discussion.
Best,
Xiaohan