1. Init repo

Cargo.toml

@@ -1,10 +1,11 @@
 [package]
 name = "enclose"
-version = "0.1.2"
+version = "0.1.3"
 authors = ["Денис Котляров <denis2005991@gmail.com>"]
 repository = "https://github.com/clucompany/Enclose.git"
 license = "MIT"
 readme = "README.md"
+edition = "2018"
 
 description = "A convenient macro for cloning values into a closure."
 keywords = ["enclose", "enclose_macro", "macro", "clucompany"]

README.md

@@ -67,7 +67,32 @@ A convenient macro for cloning values into a closure.
 			};
 			assert_eq!(*v_lock, 5);
 	}
-
+
+# Use 3
+
+	use std::sync::Arc;
+	use std::sync::Mutex;
+	use std::thread;
+
+	let v = Arc::new(Mutex::new( 0 ));
+	let thread = thread::spawn( enc!((v => MY_LOCKER) move || {
+		let mut v_lock = match MY_LOCKER.lock() {
+			Ok(a) => a,
+			Err(e) => e.into_inner(),
+		};
+		*v_lock += 1;
+	}));
+
+	thread.join().unwrap();
+	{
+		let v_lock = match v.lock() {
+			Ok(a) => a,
+			Err(e) => e.into_inner(),
+		};
+		assert_eq!(*v_lock, 1);
+	}
+
+
 # License
 
 Copyright 2018 #UlinProject Денис Котляров

examples/easy.rs

@@ -0,0 +1,30 @@
+
+
+use std::sync::Arc;
+use std::sync::Mutex;
+use std::thread;
+
+use enclose::enc;
+use enclose::enclose;
+
+
+fn main() {
+     let v = Arc::new(Mutex::new( 0 ));
+	let thread = thread::spawn( enc!((v) move || {
+		let mut v_lock = match v.lock() {
+			Ok(a) => a,
+			Err(e) => e.into_inner(),
+		};
+		*v_lock += 1;
+	}));
+
+	thread.join().unwrap();
+	{
+		let v_lock = match v.lock() {
+			Ok(a) => a,
+			Err(e) => e.into_inner(),
+		};
+		assert_eq!(*v_lock, 1);
+	}
+}
+

examples/easy2.rs

@@ -0,0 +1,27 @@
+
+use std::sync::Arc;
+use std::sync::Mutex;
+use std::thread;
+
+use enclose::enc;
+use enclose::enclose;
+
+fn main() {
+     let v = Arc::new(Mutex::new( 0 ));
+	let thread = thread::spawn( enc!((v => MY_LOCKER) move || {
+          let mut v_lock = match MY_LOCKER.lock() {
+               Ok(a) => a,
+               Err(e) => e.into_inner(),
+          };
+          *v_lock += 1;
+     }));
+
+	thread.join().unwrap();
+	{
+		let v_lock = match v.lock() {
+			Ok(a) => a,
+			Err(e) => e.into_inner(),
+		};
+		assert_eq!(*v_lock, 1);
+	}
+}

examples/easy3.rs

@@ -0,0 +1,43 @@
+
+
+use std::sync::Arc;
+use std::sync::Mutex;
+use std::sync::RwLock;
+use std::thread;
+
+use enclose::enc;
+use enclose::enclose;
+
+fn main() {
+
+     let v = Arc::new(Mutex::new( 0 ));
+	let v2 = Arc::new(RwLock::new( (0, 2, 3, 4) ));
+
+	let count_thread = 5;
+	let mut wait_all = Vec::with_capacity(count_thread);
+
+	for _a in 0..count_thread {
+		wait_all.push({
+			thread::spawn( enc!((v, v2) move || {
+				let mut v_lock = match v.lock() {
+					Ok(a) => a,
+					Err(e) => e.into_inner(),
+				};
+				*v_lock += 1;
+
+				drop( v2 ); //ignore warning
+			}))
+		});
+	}
+	for a in wait_all {
+		a.join().unwrap();
+	}
+	{	
+		//Test result
+		let v_lock = match v.lock() {
+			Ok(a) => a,
+			Err(e) => e.into_inner(),
+		};
+		assert_eq!(*v_lock, 5);
+	}
+}

src/lib.rs

@@ -85,6 +85,32 @@ for a in wait_all {
 }
 ```
 
+# Use 3
+
+```
+use std::sync::Arc;
+use std::sync::Mutex;
+use std::thread;
+
+let v = Arc::new(Mutex::new( 0 ));
+let thread = thread::spawn( enc!((v => MY_LOCKER) move || {
+     let mut v_lock = match MY_LOCKER.lock() {
+          Ok(a) => a,
+          Err(e) => e.into_inner(),
+     };
+     *v_lock += 1;
+ }));
+
+thread.join().unwrap();
+{
+	let v_lock = match v.lock() {
+		Ok(a) => a,
+		Err(e) => e.into_inner(),
+	};
+	assert_eq!(*v_lock, 1);
+}
+```
+
 */
 
 ///Macro for cloning values to close.