How does `Cow::Owned` implemented the `FnOnce`? - rust

Question

This example works fine.
use std::borrow::Cow;
fn main() {
let a = Some("Hello");
let b: Option<Cow<&'static str>> = a.map(Cow::Owned);
println!("{:?}", b);
}
The Option map requires the param must implement FnOnce(T) -> U:
pub const fn map<U, F>(self, f: F) -> Option<U>
where
F: ~const FnOnce(T) -> U,
F: ~const Destruct,
{
match self {
Some(x) => Some(f(x)),
None => None,
}
}
I want to figure out how Cow::Owned implement the FnOnce. I have searched the source code and found nothing helpful.
Any idea about this?

Answer 1

Every tuple struct or tuple enum variant with public members is also a free-standing function:
pub struct A(pub u8);
// creates essentially
pub fn A_fn(one: u8) {
A(one) // returns the struct
}
Every free-standing fn falls under the Fn category. FnMut and FnOnce are pretty much only ever applicable to closures.
Any closure which is categorized under Fn can be used in a place requiring FnMut or FnOnce. Any closure which is categorized under FnMut can be used in a place requiring FnOnce, but NOT in a place requiring Fn. Any function or closure which is categorized under FnOnce can ONLY be used in a place requiring just FnOnce.
In this way, when you see a Fn bound, it's actually the opposite in terms of restriction. FnOnce is actually the most permissive bound:
: Fn means that only Fn closures can be used there
: FnMut means that only Fn or FnMut closures can be used there
: FnOnce means that Fn, FnMut, or FnOnce closures can be used there
Cow::Owned is a tuple enum variant with only public members, so can be used as if it were fn(B) -> Cow<'_, B>. And since Fn can be used where there's a FnOnce bound, it's accepted.