闭包：预期 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 并仅使用 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 等

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

closures: expected u32 found type parameter

generics

closures

function

traits

rust