rust闭包

返回闭包

fn returns_closure() -> Box<dyn Fn(i32) -> i32> {
    Box::new(|x| x + 1)
}

main.rs

use std::thread;
use std::time::Duration;

fn simulated_expensive_calculation(intensity: u32) -> u32 {
    println!("calculating slowly...");
    thread::sleep(Duration::from_secs(2));
    intensity
}

struct Cacher<T>
    where
        T: Fn(u32) -> u32,//指定它是一个闭包Fn
{
    calculation: T,
    value: Option<u32>,
}

impl<T> Cacher<T>
    where
        T: Fn(u32) -> u32,
{
    fn new(t: T) -> Cacher<T>{
        Cacher{
            calculation:t,
            value:None,
        }
    }

    fn value(&mut self,arg: u32) -> u32{
        match self.value {
            Some(v) => v,
            None => {
                let v = (self.calculation)(arg);
                self.value = Some(v);
                v
            }
        }
    }
}

fn generate_workout(intensity: u32, random_number: u32) {
    //let expensive_result = simulated_expensive_calculation(intensity);
    //闭包,这里的u32不指定也可以推断出来
    // let expensive_closure = |num:u32| {
    //     println!("calculating slowly...");
    //     thread::sleep(Duration::from_secs(2));
    //     num
    // };

    //将闭包设置到结构体T中
    let mut expensive_closure = Cacher::new(|num:u32| {
        println!("calculating slowly...");
        thread::sleep(Duration::from_secs(2));
        num
    });
    if intensity < 25 {
        println!("Today, do {} pushups!", expensive_closure.value(intensity));
        println!("Next, do {} situps!", expensive_closure.value(intensity));
    } else {
        if random_number == 3 {
            println!("Take a break today! Remember to stay hydrated!");
        } else {
            println!("Today, run for {} minutes!", expensive_closure.value(intensity));
        }
    }
}

fn main() {
    let simulated_user_specified_value = 10;
    let simulated_random_number = 7;

    generate_workout(simulated_user_specified_value, simulated_random_number);

    let example_closure = |x| x;

    let s = example_closure(String::from("hello"));
    //闭包只能初始化一次类似，上面初始化为String了，下面则会编译失败
    //let n = example_closure(5);

    // let x = 4;
    //
    // fn equal_to_x(z: i32) -> bool {
    //     println!("x:{}",x); //闭包不能使用外部的值
    //     true
    //     //z == x
    // }

    let x = vec![1, 2, 3];

    //let equal_to_x = move |z| z == x;
    let y:Vec<_> = x.iter().map(|x|x+1).collect();
    for i in y {
        print!("{}",i);
    }
    println!();
}

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

    let v1 = c.value(1);
    //这里值还是1，不会变
    let v2 = c.value(2);
    println!("v2:{}",v2);

    assert_eq!(v2, 2);
}

calculating slowly...
Today, do 10 pushups!
Next, do 10 situps!
234

lib.rs

#[test]
fn iterator_demonstration() {
    let v1 = vec![1, 2, 3];

    let mut v1_iter = v1.iter();

    assert_eq!(v1_iter.next(), Some(&1));
    assert_eq!(v1_iter.next(), Some(&2));
    assert_eq!(v1_iter.next(), Some(&3));
    assert_eq!(v1_iter.next(), None);
}

#[test]
fn iterator_sum() {
    let v1 = vec![1, 2, 3];

    let v1_iter = v1.iter();

    let total: i32 = v1_iter.sum();

    assert_eq!(total, 6);
}

#[derive(PartialEq, Debug)]
struct Shoe {
    size: u32,
    style: String,
}

//filter迭代器适配器捕获其环境的闭包
fn shoes_in_size(shoes: Vec<Shoe>, shoe_size: u32) -> Vec<Shoe> {
    shoes.into_iter().filter(|s| s.size == shoe_size).collect()
}

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

    #[test]
    fn filters_by_size() {
        let shoes = vec![
            Shoe {
                size: 10,
                style: String::from("sneaker"),
            },
            Shoe {
                size: 13,
                style: String::from("sandal"),
            },
            Shoe {
                size: 10,
                style: String::from("boot"),
            },
        ];

        let in_my_size = shoes_in_size(shoes, 10);

        assert_eq!(
            in_my_size,
            vec![
                Shoe {
                    size: 10,
                    style: String::from("sneaker")
                },
                Shoe {
                    size: 10,
                    style: String::from("boot")
                },
            ]
        );
    }
}

struct Counter {
    count: u32,
}

impl Counter {
    fn new() -> Counter {
        Counter { count: 0 }
    }
}

impl Iterator for Counter {
    type Item = u32;

    fn next(&mut self) -> Option<Self::Item> {
        if self.count < 5 {
            self.count += 1;
            Some(self.count)
        } else {
            None
        }
    }
}

#[test]
fn calling_next_directly() {
    let mut counter = Counter::new();

    assert_eq!(counter.next(), Some(1));
    assert_eq!(counter.next(), Some(2));
    assert_eq!(counter.next(), Some(3));
    assert_eq!(counter.next(), Some(4));
    assert_eq!(counter.next(), Some(5));
    assert_eq!(counter.next(), None);
}

#[test]
fn using_other_iterator_trait_methods() {
    //1*2
    //2*3
    //3*4
    //4*5
    let sum1: u32 = Counter::new().zip(Counter::new().skip(1)).map(|(a, b)| a * b).sum();
    println!("sum1:{}",sum1);

    //2*3+3*4+5*None
    let sum: u32 = Counter::new()
        .zip(Counter::new().skip(1)) //zip将两个迭代器压缩到一起
        .map(|(a, b)| a * b)
        .filter(|x| x % 3 == 0)
        .sum();
    assert_eq!(18, sum);
}

fn test_lambda(){
    let add = |a:i32,b:i32| -> i32 {a+b};
    println!("{:?}",add(1,2));
}

3

trait Any{
    fn any(&self,f:&(Fn(u32) -> bool)) -> bool;
}

impl Any for Vec<u32> {
    fn any(&self,f:&(Fn(u32) -> bool)) -> bool {
        for &x in self.iter() {
            if f(x) {
                return true;
            }
        }
        false
    }
}

fn test_any(){
    let v = vec![1,2,3];
    let b = v.any(&|x| x==3);
    println!("{:?}",b);
}

v:1 v:0