cascade 1.0.1

Dart-like cascade macro for Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

#[macro_use]
extern crate cascade;

#[derive(Clone, Debug)]
struct Person {
    name: String,
    age: u32,
    height: u32,
}

impl Person {
    pub fn blank() -> Person {
        Person {
            name: "".to_string(),
            age: 0,
            height: 0,
        }
    }
}

#[derive(Clone, Debug)]
struct Chain {
    links: Vec<u32>,
}

impl Chain {
    fn blank() -> Chain {
        Chain { links: vec![] }
    }
    fn add(mut self, link: u32) -> Self {
        self.links.push(link);
        self
    }
}

#[allow(unused)]
fn main() {
    // Cascades can be used recursively!
    let people = cascade! {
       Vec::new();
       ..push(cascade! {
           Person::blank();
           ..name = "John Smith".to_string();
           ..height = 72; // 6 feet, or 72 inches tall
           ..age = 34;
       });
       // This is what an expanded cascade looks like.
       ..push({
          let mut __tmp = Person::blank();
          __tmp.name = "Jason Smith".to_string();
          __tmp.height = 64;
          __tmp.age = 34;
          __tmp
       });
    };
    // Any expression works as the first statement of a cascade.
    let other_person = cascade! {
       people[0].clone();
       ..name = "Bob Smith".to_string();
       ..height = 66;
    };
    // You can also use +=, -=, *=, /= for operators
    let another_person = cascade! {
       other_person.clone();
       ..name = "Joan Smith".to_string();
       ..age += 3;
       ..height -= 4;
    };
    // You can put regular statements inside of a cascade macro
    let yet_another_person = cascade! {
       people[0].clone();
       ..name = "James Smith".to_string();
       ..age = 27;
       println!("Cascades in Rust are cool!");
       ..height -= 3;
    };
    // You can bind the initial value of the cascade to an identifier, which reflects the current state of the cascaded value.
    let one_more_person = cascade! {
      let person = people[0].clone();
      println!("'person' was equal to: {:?}", person);
      ..name = "James Smith".to_string();
      ..height = ((person.height as f32) * 0.8) as u32;
      println!("'person' is now equal to: {:?}", person);
    };
    // As of version 0.1.2, you can also chain methods together. Observe:
    let method_chain_example = cascade! {
      let ch = Chain::blank();
      ..add(5).add(6).add(7); // In this case, ch is consumed here. So we have to shadow ch to avoid an error. Obviously, this isn't the most useful way to method-chain.
      let ch = ();
    };

    // You can have nested blocks within the cascade
    let block_example = cascade! {
      Vec::new();
      ..push(1);
      ..push(2);
    };

    let has_more_than_three_elements = cascade! {
        let v = vec![1,2,3];
        ..push(4);
        v.len() > 3
    };

    println!("{}", cascade! {
        vec![1,2,3];
        ..push(4);
        ..into_iter().fold(0, |acc, x| acc + x)
    });

    cascade! {
        let _: Vec<u32> = vec![1,2,3].into_iter().map(|x| x + 1).collect();
        ..push(1);
    };

    option_cascade_test().unwrap().unwrap();
}

// As of version 0.1.3, you can use the ? operator after a .. statement.
fn option_cascade_test() -> Result<Result<(), ()>, ()> {
    let question_mark_operator_example: Result<Result<(), ()>, ()> = cascade! {
      Ok(Ok(()));
      ..unwrap()?;
    };
    return question_mark_operator_example;
}