闭包:期望u32找到类型参数

Question

问题是，我的泛型类型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);
}

Answer 1

要么从实现中删除泛型类型参数U，并且只使用u32的：

#[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);
}

游乐场

或者使您的实现完全-泛型：

#[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);
}

游乐场

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