闭包：预期 u32 找到类型参数答案

【问题标题】：closures: expected u32 found type parameter闭包：预期 u32 找到类型参数
【发布时间】：2021-03-11 18:21:46
【问题描述】：

问题是我的泛型类型T 只接受来自u32 的参数，在这种情况下，我试图传递一个我存储在U 中的泛型值。

有没有办法将泛型转换为特定类型？我能做些什么来解决这个问题？

#[derive(Debug)]
struct Cacher<T, U> where T: Fn(u32) -> u32 {
    calcular:T,
    valor:Option<U>,
}
impl<T, U> Cacher<T, U> where T: Fn(u32) -> u32 {
    fn nuevo(calcular:T, valor:U) -> Cacher<T, U> {
        Cacher{
            calcular,
            valor:None,
        }
    }
    fn valor(&mut self, arg:U) -> u32 {
        match self.valor {
            Some(v) => v,
            None => {
                let v = (self.calcular)(arg);
                self.valor = Some(arg);
                v
            }
        }
    }
}

fn generar(intensidad:u32){
    let mut resultado = Cacher::nuevo(|num| {
        println!("Trabajando");
        num
    },None);

    let res_a = resultado.valor(Some(4));
}

fn main() {
    generar(3);
}

【问题讨论】：

标签： function generics rust closures traits

【解决方案1】：

要么从你的实现中删除泛型类型参数U，而只使用u32s：

#[derive(Debug)]
struct Cacher<T>
    where T: Fn(u32) -> u32 
{
    calcular: T,
    valor: Option<u32>,
}

impl<T> Cacher<T>
    where T: Fn(u32) -> u32
{
    fn nuevo(calcular: T) -> Cacher<T> {
        Cacher {
            calcular,
            valor: None,
        }
    }

    fn valor(&mut self, arg: u32) -> u32 {
        match self.valor {
            Some(v) => v,
            None => {
                let v = (self.calcular)(arg);
                self.valor = Some(arg);
                v
            }
        }
    }
}

fn main() {
    let mut resultado = Cacher::nuevo(|num| {
        println!("Trabajando");
        num
    });

    // "Trabajando" only printed once
    // hence we know we got a cache hit
    let res_a = resultado.valor(4);
    let res_a = resultado.valor(4);
    

    println!("{:?}", res_a);
}

playground

或者让你的实现完全通用：

#[derive(Debug)]
struct Cacher<T, U>
    where T: Fn(U) -> U, U: Copy
{
    calcular: T,
    valor: Option<U>,
}

impl<T, U> Cacher<T, U>
    where T: Fn(U) -> U, U: Copy
{
    fn nuevo(calcular: T) -> Cacher<T, U> {
        Cacher {
            calcular,
            valor: None,
        }
    }

    fn valor(&mut self, arg: U) -> U {
        match self.valor {
            Some(v) => v,
            None => {
                let v = (self.calcular)(arg);
                self.valor = Some(arg);
                v
            }
        }
    }
}

fn main() {
    let mut resultado = Cacher::nuevo(|num| {
        println!("Trabajando");
        num
    });

    // "Trabajando" only printed once
    // hence we know we got a cache hit
    let res_a = resultado.valor(4);
    let res_a = resultado.valor(4);
    

    println!("{:?}", res_a);
}

playground

上述实现将适用于实现Copy 的任何U，因此包括所有数字原语，例如u8、u16等

【讨论】：