clonesure 0.3.0

A helper macro to create closures which will clone its environment.
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

# Clonesure

[![Crates.io](https://img.shields.io/crates/l/clonesure?style=flat-square)](https://crates.io/crates/clonesure)
[![Crates.io](https://img.shields.io/crates/v/clonesure?style=flat-square)](https://crates.io/crates/clonesure)
[![docs.rs](https://img.shields.io/docsrs/clonesure?style=flat-square)](https://docs.rs/clonesure/latest)

A helper macro to create closures which will clone its environment.

## Install

Add the following line to your Cargo.toml file:

```toml
clonesure = "0.3.0"
```

## Getting Started

When define parameters of a closure, use `@var` to clone a variable, use `@mut var` to clone a mutable variable.

**Cloned variables must be in front of closure parameters.**

E.g.:

```rust
cc!(|@a, @mut b, c| a + b + c)
```

will be translated to:

```rust
{
  let a = a.clone();
  let mut b = b.clone();
  move |c| a + b + c
}
```

## Examples

```rust
use clonesure::cc;

fn main() {
  // `cc` will implicitly move its environment
  let s1 = String::from("111");
  let s2 = String::from("222");
  assert_eq!(
    // implicitly move s1 into the closure
    // brackets of the closure's body are optional
    cc!(|| s1)(),
    "111"
  );
  assert_eq!(
    // explicitly move s2 into the closure
    cc!(move || s2)(),
    "222"
  );

  // clone one var
  let s1 = String::from("111");
  assert_eq!(
    // clone s1 into the closure
    cc!(|@s1| s1)(),
    "111"
  );
  assert_eq!(
    s1, // the original s1 is still alive
    "111",
  );

  // clone many vars
  let s1 = String::from("111");
  let s2 = String::from("222");
  assert_eq!(cc!(|@s1, @s2| s1 + &s2)(), "111222");

  // clone var mut
  let s1 = String::from("111");
  let s2 = String::from("222");
  assert_eq!(
    cc!(|@mut s1, @s2| {
      s1 = s1 + &s2;
      s1
    })(),
    "111222"
  );

  // with closure params
  // cloned vars must be in front of closure params
  let s1 = String::from("111");
  let s2 = String::from("222");
  let s3 = String::from("333");
  assert_eq!(
    cc!(|@mut s1, @s2, s3| {
      s1 = s1 + &s2 + s3;
      s1
    })(&s3),
    "111222333"
  );

  // param type, param pattern, return type
  let s1 = String::from("111");
  let s2 = String::from("222");
  let s3 = String::from("333");
  let s4 = 444;
  assert_eq!(
    cc!(|@mut s1, @s2, s3: String, &s4| -> String {
      s1 = s1 + &s2 + &s3;
      format!("{}{}", s1, s4)
    })(s3, &s4),
    "111222333444"
  );
}
```

## [CHANGELOG](https://github.com/DiscreteTom/clonesure/blob/main/CHANGELOG.md)