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并未改变

[iamtaojin]

Fn: the closure uses the captured value by reference (&T)
Fn：闭包以引用方式捕获值(&T)
FnMut: the closure uses the captured value by mutable reference (&mut T)
FnMut：闭包以可变引用方式捕获值(%mut T)
FnOnce: the closure uses the captured value by value (T)
FnOnce：闭包直接捕获值(T)

Move closures may still implement Fn or FnMut, even though they capture variables by move. This is because the traits implemented by a closure type are determined by what the closure does with captured values, not how it captures them. The move keyword only specifies the latter.

Move 闭包仍然可以实现 Fn 或 FnMut，即使它们通过 Move 捕获变量。这是因为闭包类型实现的特性是由闭包如何处理捕获的值决定的，而不是由闭包如何捕获这些值决定的。Move 关键字只指定后者。

我是这么理解的：这里使用move传入T，改变了T的所有权，而T是可以被Copy的，根据rust的设计，能copy就不reference，所以这里内部的count是外部传入的值的copy，而不是对外部count的引用，故对内部count修改，没有影响外部的count的值。

在这里，若要修改外部count的值，应许删除move，但在其后的又进行了改用，违反了引用的规则，所以let _reborrow = &count 会报错。
要想使其不报错，要在可变引用结束后再进行不可变引用，也就是两次inc()之后再进行let _reborrow = &count 。

如有不对的，请大佬指正。

[vudsen]

有没有大佬知到我这个为什么错了，一直提示泛型 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`.

[huongyj]

可能是因为，泛型K只出现在约束当中，结构体真正的部分没有用到泛型K

[ThenMorning]

没看懂你想干嘛，加那么多泛型做什么？因为(|x| x + 1)？ 那其实不需要，类型是一样的，除非你想表示 类型变了

[vudsen]

没看懂你想干嘛，加那么多泛型做什么？因为(|x| x + 1)？ 那其实不需要，类型是一样的，除非你想表示 类型变了

其实我想让 arg 也能用泛型，而不是写死了只能用一种类型，比如我 arg 传一个字符串，然后 Cacher 返回一个数字 ，不过我已经知道解决方法了：

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

只能说越往后学就会发现 rust 高级的 API 全是在给自己填坑。。。

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

}

[gastrodia]

第一题

/* Make it work with least amount of changes*/
fn main() {
    let color = String::from("green");

    let print = || println!("`color`: {}", color);

    print();
    print();

    // `color` can be borrowed immutably again, because the closure only holds
    // an immutable reference to `color`. 
    let _reborrow = &color;

    println!("{}",color);
}

---

第二题

/* Make it work 
- Dont use `_reborrow` and `_count_reborrowed`
- Dont modify `assert_eq`
*/
fn main() {
    let mut count = 0;

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

---

第三题

/* Make it work in two ways, none of them is to remove `take(movable)` away from the code
*/
fn main() {
     let movable = Box::new(3);

     let consume = || {
         println!("`movable`: {:?}", movable);
         take(movable);
     };

     consume();
     // consume();
}

fn take<T>(_v: T) {}

---

第四题

fn main() {
    let example_closure = |x| x;

    let s = example_closure(String::from("hello"));

    /* Make it work, only change the following line */
    let n = example_closure(5.to_string());
}

---

第五题

/* Make it work by changing the trait bound, in two ways*/
fn fn_once<F>(func: F)
where
    F: Fn(usize) -> bool,
{
    println!("{}", func(3));
    println!("{}", func(4));
}

fn main() {
    let x = vec![1, 2, 3];
    fn_once(|z|{z == x.len()})
}

---

第六题

fn main() {
    let mut s = String::new();

    let update_string = |str| s.push_str(str);

    exec(update_string);

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

/* Fill in the blank */
fn exec<'a, F: FnMut(&'a str)>(mut f: F)  {
    f("hello")
}

---

第七题

fn apply<F>(f: F) where
    // The closure takes no input and returns nothing.
    F: FnOnce() {

    f();
}

---

第八题

/* Fill in the blank */
fn main() {
    let mut s = String::new();

    let update_string = |str| -> String {s.push_str(str); s };

    exec(update_string);
}

fn exec<'a, F: FnOnce(&'a str) -> String>(mut f: F) {
    f("hello");
}

---

第九题

/* Implement `call_me` to make it work */
fn call_me<F: Fn()>(f: F) {
    f();
}

fn function() {
    println!("I'm a function!");
}

fn main() {
    let closure = || println!("I'm a closure!");

    call_me(closure);
    call_me(function);
}

---

第10题

/* Fill in the blank using two approaches,
 and fix the error */
fn create_fn() -> Box<dyn Fn(i32) -> i32> {
    let num = 5;

    // How does the following closure capture the environment variable `num`
    // &T, &mut T, T ?
    Box::new(move |x| x + num)
}


fn main() {
    let fn_plain = create_fn();
    fn_plain(1);
}

---

第11题

fn main() {}

/* Fill in the blank and fix the error*/
fn factory(x:i32) -> Box<dyn Fn(i32) -> i32> {

    let num = 5;

    if x > 1{
        Box::new(move |x| x + num)
    } else {
        Box::new(move |x| x + num)
    }
}

[FlandreLiao]

done