https://github.com/clucompany/enclose
[stable] A convenient macro, for cloning values into a closure.
https://github.com/clucompany/enclose
clucompany enclose enclose-macro macro no-std rust rustlang
Last synced: over 1 year ago
JSON representation
[stable] A convenient macro, for cloning values into a closure.
- Host: GitHub
- URL: https://github.com/clucompany/enclose
- Owner: clucompany
- License: apache-2.0
- Created: 2018-07-20T13:01:43.000Z (almost 8 years ago)
- Default Branch: master
- Last Pushed: 2025-04-03T12:54:57.000Z (over 1 year ago)
- Last Synced: 2025-04-05T13:02:15.107Z (over 1 year ago)
- Topics: clucompany, enclose, enclose-macro, macro, no-std, rust, rustlang
- Language: Rust
- Homepage:
- Size: 79.1 KB
- Stars: 29
- Watchers: 1
- Forks: 1
- Open Issues: 1
-
Metadata Files:
- Readme: README.md
- License: LICENSE_APACHE
- Code of conduct: CODE_OF_CONDUCT.md
Awesome Lists containing this project
README
[enclose]
(A convenient macro, for cloning values into a closure.)
[](https://github.com/clucompany/enclose/actions/workflows/CI.yml)
## Usage
Add this to your Cargo.toml:
```toml
[dependencies]
enclose = "1.2.1"
```
and this to your source code:
```rust
use enclose::enclose;
```
## Example
### EasyUse
Just use it!
```rust
use enclose::enclose;
fn main() {
let clone_data = 0;
let add_data = 100;
my_enclose( enclose!((mut clone_data, add_data) || {
// (mut clone_data, add_data) ->
// let mut clone_data = clone_data.clone();
// let add_data = add_data.clone();
println!("#0 {:?}", clone_data);
clone_data += add_data;
println!("#1 {:?}", clone_data);
assert_eq!(clone_data, 100);
}));
assert_eq!(clone_data, 0);
}
fn my_enclose R, R>(a: F) -> R {
a()
}
```
### MutexUse
Creating closures for a multi-threaded environment, no extra lines!
```rust
use std::sync::Arc;
use std::sync::Mutex;
use std::thread;
use enclose::enclose;
fn main() {
let mutex_data = Arc::new(Mutex::new( 0 ));
let thread = thread::spawn( enclose!((mutex_data => d) move || {
// (mutex_data => d) ->
// let d = mutex_data.clone();
let mut lock = match d.lock() {
Ok(a) => a,
Err(e) => e.into_inner(),
};
*lock += 1;
}));
thread.join().unwrap();
{
let lock = match mutex_data.lock() {
Ok(a) => a,
Err(e) => e.into_inner(),
};
assert_eq!(*lock, 1);
}
}
```
### ArcMutexUse
A more complex example of using an enclose macro in a multi-threaded environment.
```rust
use std::sync::Arc;
use std::sync::Mutex;
use std::sync::RwLock;
use std::thread;
use enclose::enclose;
fn main() {
let data1 = Arc::new(Mutex::new( 0 ));
let data2 = Arc::new(RwLock::new( (0, 2, 3, 4) ));
let count_thread = 5;
let mut waits = Vec::with_capacity(count_thread);
for _a in 0..count_thread {
waits.push({
thread::spawn( enclose!((data1, data2) move || {
// (data1, data2) ->
// let data1 = data1.clone();
// let data2 = data2.clone();
let mut v_lock = match data1.lock() {
Ok(a) => a,
Err(e) => e.into_inner(),
};
*v_lock += 1;
drop( data2 ); // ignore warning
}))
});
}
for a in waits {
a.join().unwrap();
}
{
// Check data1_lock
let data1_lock = match data1.lock() {
Ok(a) => a,
Err(e) => e.into_inner(),
};
assert_eq!(*data1_lock, 5);
}
{
// Check data2_lock
let data2_lock = match data2.write() {
Ok(a) => a,
Err(e) => e.into_inner(),
};
assert_eq!(*data2_lock, (0, 2, 3, 4));
}
}
```
### EasyCopy
Using copy instead of clone.
```rust
use enclose::enclose;
use std::sync::Arc;
fn main() {
let clone_data = Arc::new(0);
let add_data = Arc::new(100);
my_enclose( enclose!((mut *clone_data, *add_data) || {
// (mut *clone_data, *add_data)
// let mut clone_data = *clone_data;
// let add_data = *add_data;
println!("#0 {:?}", clone_data);
clone_data += add_data;
println!("#1 {:?}", clone_data);
assert_eq!(clone_data, 100);
}));
assert_eq!(*clone_data, 0);
}
fn my_enclose R, R>(a: F) -> R {
a()
}
```
## License
This project has a dual license according to (LICENSE-MIT) and (LICENSE-APACHE-2-0).
Copyright (c) 2019-2025 #UlinProject
(Denis Kotlyarov).
### Apache License
Licensed under the Apache License, Version 2.0.
### MIT License
Licensed under the MIT License.