如何在通用 function 中構造具體類型？

Question

我需要用什么替換/* type */以便o_f可以等於None 、 Some(a) 、 Some(b)或Some(/* a different function with the same signature */) ？

fn func<T: Copy + Ord>(x: &mut Option<Box<Node<T>>>)
{
    let mut o_f: /* type */ = None;
    let mut result_of_f: Option<bool> = None;
    let mut o_b_n_num = Some(Box::new(Node::new(1)));

    // ...

    if let Some(f) = o_f
    {
        result_of_f = Some(f(x) && f(&mut o_b_n_num));
    }

    // ...
}

Answer 1

你試圖做的事情是不可能的。 您在T上有一個 function 泛型，但在內部您正在嘗試使用具體類型i32 。 Rust 根據調用它們的類型對泛型函數進行單態化。 以這個程序為例：

fn func<F, T>(f: F, t: T)
    where F: Fn(T)
{
    f(t);
}

struct S;
struct R;

fn main() {
    func(|x| {}, S);
    func(|x| {}, R);
}

將被編譯為：

fn func_S(f: impl Fn(S), s: S)
{
    f(s);
}

fn func_R(f: impl Fn(R), r: R)
{
    f(r);
}

struct S;
struct R;

fn main() {
    func_S(|s| {}, S);
    func_R(|r| {}, R);
}

這一切都很好，但如果我們 go 回來並將第一個 function 更改為此（這基本上是你想要做的）：

fn func<F, T>(f: F, t: T)
    where F: Fn(T)
{
    f(t);
    f(1); // concrete type i32, not type T
}

struct S;
struct R;

fn main() {
    func(|x| {}, S);
    func(|x| {}, R);
}

現在它不會編譯，但如果我們想象它可以編譯，那么它會像這樣：

fn func_S(f: impl Fn(S), s: S)
{
    f(s);
    f(1); // error! f expects S not i32
}

fn func_R(f: impl Fn(R), r: R)
{
    f(r);
    f(1); // error! f expects R not i32
}

struct S;
struct R;

fn main() {
    func_S(|s| {}, S);
    func_R(|r| {}, R);
}

你明白這根本沒有意義嗎？ 您正在嘗試將i32傳遞給期望S和R的函數。

現在，您有幾個選擇。 如果您想要一些僅i32的數據結構，那么您不需要使其通用，並且可以僅為i32定義它。 如果您想要一個通用結構，如果缺少某個節點，並且您想用“默認”節點填充它（可能在Node<i32>的情況下，默認節點是Node::new(1) ），那么您可以在Default上綁定T並編寫如下內容：

#[derive(Default)]
struct Node<T: Default>(T);

#[derive(Default)]
struct S;
#[derive(Default)]
struct R;

fn func<F, T>(f: F, t: Option<Node<T>>)
    where T: Default, F: Fn(Node<T>)
{
    f(t.unwrap_or_default());
}

fn main() {
    func(|x| {}, Some(Node(S)));
    func(|x| {}, Some(Node(R)));
    func(|x: Node<i32>| {}, None);
}

現在您的 function 是真正通用的T並處理所有Node<T>的情況，包括Node<i32> 。

也可以看看

• 泛型結構的構造函數中的“預期類型參數”錯誤