functional-programing/closure

[giscus[bot]]

functional-programing/closure

Learning Rust By Practice, narrowing the gap between beginner and skilled-dev with challenging examples, exercises and projects.

https://zh.practice.rs/functional-programing/closure.html

[Grothendieck42]

https://practice.rs/functional-programing/closure.html

[Grothendieck42]

题目在英文版

[JinPengCN]

答案在哪里

[geeksKK8]

为什么第二题的assertion中count == 0

[FlowLoveV]

fn main() {
    let mut count = 0;
    // 在这里添加move
    let mut inc = move || {
        count += 1;
        println!("`count`: {}", count);
    };

    inc();


    let _reborrow = &count; 

    inc();

    // The closure no longer needs to borrow `&mut count`. Therefore, it is
    // possible to reborrow without an error
    let _count_reborrowed = &mut count; 

    assert_eq!(count, 0);
}

添加move后，实际上将count进行了copy然后转移到inc闭包内，因此inc改变的是其内部count的值，main函数中的count并未改变

[IceOfSummer]

有没有大佬知到我这个为什么错了，一直提示泛型 K 没有被使用：

struct Cacher<K, V, T>
where
    T: Fn(K) -> V,
    K: Clone
{
    query: T,
    value: Option<V>,
}

impl<K, V, T> Cacher<K, V, T>
where
    T: Fn(K) -> V,
    K: Clone
{
    fn new(query: T) -> Cacher<K, V, T> {
        Cacher {
            query,
            value: None,
        }
    }

    // 先查询缓存值 `self.value`，若不存在，则调用 `query` 加载
    fn value(&mut self, arg: K) -> V {
        match self.value {
            Some(v) => v,
            None => {
                let v = (self.query)(arg);
                self.value = Some(v);
                v
            }
        }
    }
}

#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn test_cache() {
        let cache = Cacher::new(|x| x + 1);

        assert_eq!(cache.value(1), 2);
        
    }
}

输出：

   Compiling playground v0.0.1 (/playground)
error[E0392]: parameter `K` is never used
 --> src/lib.rs:1:15
  |
1 | struct Cacher<K, V, T>
  |               ^ unused parameter
  |
  = help: consider removing `K`, referring to it in a field, or using a marker such as `PhantomData`

For more information about this error, try `rustc --explain E0392`.

[vince-1998]

给一个不需要Copy特性的写法
struct Cacher<T, E>
where
T: Fn(E) -> E,
{
query: T,
value: Option,
}

impl<T, E> Cacher<T, E>
where
T: Fn(E) -> E,
{
fn new(query: T) -> Cacher<T, E> {
Cacher { query, value: None }
}

fn value(&mut self, arg: E) -> &E {
    match (self.value) {
        Some(ref v) => v,
        None => {
            let v = (self.query)(arg);
            self.value = Some(v);
            self.value.as_ref().unwrap()
        }
    }
}

}
fn main() {}

#[test]
fn call_with_different_values() {
let mut c = Cacher::new(|a| a);

let v1 = c.value(1);
let v2 = c.value(2);

assert_eq!(*v2, 1);

}