404

[giscus[bot]]

404

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

https://zh.practice.rs/std/String.html

[qiutongxue]

404 了

[sunface]

我本来以为你是 404 黑色幽默，结果发现原来是 /std/String 这个链接缺失了 🤣

[tjw123hh]

functional-programing/cloure.html这个缺了

[tjw123hh]

另外不应该是programming吗（）

[tjw123hh]

https://github.com/sunface/rust-by-practice/blob/master/zh-CN/src/functional-programing/closure.md

[ZaneXo]

这个会解决吗？

[0xZoomEye]

404

[fyrestone]

404了，初学rust尝试写了个：

struct Cacher<T, F>
where
    T: Fn(F) -> F,
    F: Copy,
{
    query: T,
    value: Option<F>,
}

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

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

fn main() {
    let mut c = Cacher::new(|x| x);
    println!("{}", c.value(32));
    let mut c = Cacher::new(|x| x);
    println!("{}", c.value("abc"));
}

[liudosen]

自定义的结构体，必须实现copy才能用你这个缓存，而且是个严重的bug。如果我需要修改value的值，修改了也没有办法影响到Cacher里的value，因为你返回出来的是copy的。

[liudosen]

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,
}
}

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

}

fn main() {
let function = |a| -> String { a };

let mut cach= Cacher::new(function);

if let Some(a) = cach.value(String::from("a")) {
    println!("{}", a)
}

}

[xiyuan-code]

小弟我也来现个丑

struct Cacher<F, S> where F: Fn(S) -> S {
    query: F,
    value: Option<S>,
}

impl<F, S> Cacher<F, S> where F: Fn(S) -> S {
    fn new(query: F) -> Cacher<F, S> {
        Cacher {
            query,
            value: None,
        }
    }
    // 先查询缓存值 `self.value`，若不存在，则调用 `query` 加载
    fn value<'a>(mut self, arg: S) -> S where S: 'a {
        match self.value {
            Some(v) => v,
            None => {
                let v = (self.query)(arg);
                // self.value = Some(v);
                v
            }
        }
    }
}

fn main() {
    let mut cache = Cacher::new(|a| a);
    println!("{}", cache.value("data"));

    let mut cache = Cacher::new(|a| a);
    println!("{}", cache.value(333));
}

[xiyuan-code]

我这个没有保存值，还是用@fyrestone 楼主的比较合适

[tjw123hh]

利用Clone trait：

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

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

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

fn main() {
    let mut cacher = Cacher::new(
        |string: String| -> String {
            string
        }
    );
    println!("{}", cacher.value(String::from("test")));
    println!("{}", cacher.value(String::from("unused")))
}

[liuweijiao]

struct Cacher<T, E: Copy>
where
T: Fn(E) -> E,
{
query: T,
value: Option,
}

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

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

}

[Edison-Yeah]

初学者，只能自己琢磨了

#[test]
fn case_cache() {

    let closure_one= | x | x+1;
    let closure_two = | mut x: String | {
        x.push_str("123");
        x
    };

    assert_eq!(closure_one(1), 2);
    assert_eq!(closure_two(String::from("12")), String::from("12123"));

    let mut cacher_a = Cacher{query: closure_one, value: Some(5)};
    let mut cacher_b = Cacher{query: closure_two, value: Some(String::from("12"))};

    let result_a = cacher_a.call(10);
    let result_b = cacher_b.call(String::from("111"));

    assert_eq!(*result_a, 5);
    assert_eq!(*result_b, "12");
}

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

impl<T,B> Cacher<T, B>
where
T: Fn(B) -> B {
    pub fn call(&mut self, arg: B) -> &B {
        // 这里的self是一个可变引用
        // 使用模式匹配
        match self.value {
            // 不捕捉值，只匹配Some()
            Some(_) => self.value.as_ref().unwrap(), // self.value.as_ref()将Option<B>转成了Option<&B>，然后断言
            // 匹配None
            None => {
                let result = (self.query)(arg); // 这里query是个闭包，所有使用时加了()变成 (self.query)
                self.value = Some(result);
                self.value.as_ref().unwrap() // 返回的是value的引用
            }
        }
    }
}

[River-Shi]

404有修复吗

[gegekeru]

等待修复中