Merge pull request #2 from alecmocatta/pattern-and-relative

switch to relative crate; allow patterns as args

Author: alecmocatta

.appveyor.yml

@@ -2,8 +2,12 @@ environment:
   matrix:
   - TARGET: x86_64-pc-windows-msvc
     platform: x64
+  - TARGET: x86_64-pc-windows-gnu
+    platform: x64
   - TARGET: i686-pc-windows-msvc
     platform: x86
+  - TARGET: i686-pc-windows-gnu
+    platform: x86
 
 install:
   - appveyor-retry appveyor DownloadFile https://win.rustup.rs/ -FileName rustup-init.exe

.travis.yml

@@ -50,12 +50,12 @@ script: |
   ( set -o errexit;set -o pipefail; set -o xtrace;set -o nounset;
     cargo +$FMT_VERSION fmt -- --check
     for TARGET in $BUILD $RUN; do (
-      [ \( "$TRAVIS_OS_NAME" = "osx" -o \( "$TRAVIS_OS_NAME" = "linux" -a "${DIST-}" = "precise" \) \) -a \( "$TARGET" = "x86_64-unknown-linux-musl" -o "$TARGET" = "i686-unknown-linux-musl" \) ] && exit 0 # export RUSTFLAGS=-Zlinker-flavor=ld.lld temporarily disable till this is fixed: https://github.com/rust-lang/rust/issues/52501
+      [ \( "$TRAVIS_OS_NAME" = "osx" -o \( "$TRAVIS_OS_NAME" = "linux" -a "${DIST-}" = "precise" \) \) -a \( "$TARGET" = "x86_64-unknown-linux-musl" -o "$TARGET" = "i686-unknown-linux-musl" \) ] && exit 0 # export RUSTFLAGS="-C linker=rust-lld -Z linker-flavor=ld.lld"
       cargo build --verbose --target "$TARGET" --lib --tests
       cargo build --verbose --target "$TARGET" --lib --tests --release
     ); done
     for TARGET in $RUN; do (
-      [ \( "$TRAVIS_OS_NAME" = "osx" -o \( "$TRAVIS_OS_NAME" = "linux" -a "${DIST-}" = "precise" \) \) -a \( "$TARGET" = "x86_64-unknown-linux-musl" -o "$TARGET" = "i686-unknown-linux-musl" \) ] && exit 0 # export RUSTFLAGS=-Zlinker-flavor=ld.lld temporarily disable till this is fixed: https://github.com/rust-lang/rust/issues/52501
+      [ \( "$TRAVIS_OS_NAME" = "osx" -o \( "$TRAVIS_OS_NAME" = "linux" -a "${DIST-}" = "precise" \) \) -a \( "$TARGET" = "x86_64-unknown-linux-musl" -o "$TARGET" = "i686-unknown-linux-musl" \) ] && exit 0 # export RUSTFLAGS="-C linker=rust-lld -Z linker-flavor=ld.lld"
       RUST_BACKTRACE=full cargo test --target "$TARGET"
       RUST_BACKTRACE=full cargo test --target "$TARGET" --release
     ); done

Cargo.toml

@@ -26,6 +26,7 @@ maintenance = { status = "actively-developed" }
 [dependencies]
 serde_derive = "1.0"
 serde = "1.0"
+relative = "0.1"
 
 [dev-dependencies]
 serde_json = "1.0"

README.md

@@ -10,27 +10,36 @@
 
 Serialisable closures.
 
-This library provides macros to wrap closures such that they can serialised and sent between other processes running the same binary.
+This library provides macros to wrap closures such that they can serialised and
+sent between other processes running the same binary.
 
 ```rust
 fn sum_of_squares(input: &[i32]) -> i32 {
 	input.dist_iter()
-		.map(Fn!(|i:&_| *i * *i))
+		.map(Fn!(|&i| i * i))
 		.sum()
 }
 ```
 
-For example, if you have the same binary running on each of a cluster of machines, this library would help you to send closures between them.
+For example, if you have the same binary running on each of a cluster of
+machines, this library would help you to send closures between them.
 
-This library aims to work in as simple and un-magical a way as possible. It currently requires nightly Rust for the `unboxed_closures` and `fn_traits` features (rust issue [#29625](https://github.com/rust-lang/rust/issues/29625)).
+This library aims to work in as simple and un-magical a way as possible. It
+currently requires nightly Rust for the `unboxed_closures` and `fn_traits`
+features (rust issue [#29625](https://github.com/rust-lang/rust/issues/29625)).
 
- * There are three macros, [FnOnce](https://docs.rs/serde_closure/0.1.0/serde_closure/macro.FnOnce.html), [FnMut](https://docs.rs/serde_closure/0.1.0/serde_closure/macro.FnMut.html) and [Fn](https://docs.rs/serde_closure/0.1.0/serde_closure/macro.Fn.html), corresponding to the three types of Rust closure.
- * The *captured variables*, i.e. those variables that are referenced by the closure but are declared outside of it, must be explicitly listed.
- * The closure is coerced to a function pointer, which is serialized as an `isize` relative to a known base address.
- * It is deserialised by adding this isize to the known base address, and transmuting to a function pointer.
- * This is the only necessitation of unsafety, and is reliant upon the function pointer being positioned identically relative to the base in both processes – hence both binaries must be identical.
- * To the best of my knowledge this holds in Rust for a given binary. If somehow the known base and the function pointer are in different objects and are loaded at different relative addresses, then this will fail, very likely as a segfault.
- * A solution in this case would be to compile a statically linked executable – in Rust this currently means adding `--target x86_64-unknown-linux-musl` or similar to the cargo or rustc command line.
+ * There are three macros,
+ [FnOnce](https://docs.rs/serde_closure/0.1.0/serde_closure/macro.FnOnce.html),
+ [FnMut](https://docs.rs/serde_closure/0.1.0/serde_closure/macro.FnMut.html) and
+ [Fn](https://docs.rs/serde_closure/0.1.0/serde_closure/macro.Fn.html),
+ corresponding to the three types of Rust closure.
+ * The *captured variables*, i.e. those variables that are referenced by the
+ closure but are declared outside of it, must be explicitly listed.
+ * There are currently some minor limitations of syntax over normal closure
+ syntax, which are documented below.
+ * The closure is coerced to a function pointer, which is wrapped by
+ [relative::Pointer](https://docs.rs/relative) such that it can safely be sent
+ between processes.
 
 ## Examples of wrapped closures
 **Inferred, non-capturing closure:**
@@ -56,7 +65,9 @@ move |a| num += a
 let mut num = 0;
 FnMut!([num] move |a| *num += a)
 ```
-Note: If any variables are captured then the `move` keyword must be present. As this is a FnMut closure, `num` is a mutable reference, and must be dereferenced to use.
+Note: If any variables are captured then the `move` keyword must be present. As
+this is a FnMut closure, `num` is a mutable reference, and must be dereferenced
+to use.
 
 **Capturing `hello` requiring extra annotation:**
 ```rust
@@ -79,33 +90,41 @@ Note: `hello` needs its type annotated in the closure.
 **Complex closure, capturing `a` and `b`:**
 ```rust
 let (mut a, mut b) = (1usize, String::from("foo"));
-move |c,d:&_,e: &mut _,f:String,g:&String,h:&mut String| {
-	*e += a+c+*d;
+move |c, d: &_, e: &mut _, f: String, g: &String, h: &mut String| {
+	*e += a + c + *d;
 	a += *e;
-	*h += ((b.clone()+f.as_str()+g.as_str())).as_str();
+	*h += (b.clone() + f.as_str() + g.as_str()).as_str();
 	b += h.as_str();
 }
 ```
 ```rust
 let (mut a, mut b) = (1usize, String::from("foo"));
-FnMut!([a,b] move |c:_,d:&_,e:&mut _,f:String,g:&String,h:&mut String| {
+FnMut!([a,b] move |c:_, d: &_, e: &mut _, f: String, g: &String, h: &mut String| {
 	let b: &mut String = b;
-	*e += *a+c+*d;
+	*e += *a + c + *d;
 	*a += *e;
-	*h += ((b.clone()+f.as_str()+g.as_str())).as_str();
+	*h += ((b.clone() + f.as_str() + g.as_str())).as_str();
 	*b += h.as_str();
 })
 ```
 
 ## Cosmetic limitations
-As visible above, there are currently some limitations that often necessitate extra annotation that you might typically expect to be redundant.
- * Type inference doesn't work as well as normal, hence extra type annotations might be needed;
- * The captured variables in FnMut and FnRef closures are references, so need to be dereferenced;
+As visible above, there are currently some limitations that often necessitate
+extra annotation that you might typically expect to be redundant.
+ * Type inference doesn't work as well as normal, hence extra type annotations
+ might be needed;
+ * The captured variables in FnMut and Fn closures are references, so need to be
+ dereferenced;
  * Types cannot be annotated in the list of captured variables;
- * Either none or all of the closure arguments must be annotated; though `_` can be used;
+ * If any of the closure arguments are annotated with types (i.e. `|a:i32|0`)
+ then all must be (though `_` can be used), and patterns can no longer be used
+ (i.e. `|&a:&i32|0` will not work).
  * The `move` keyword must be present if any variables are captured.
 
 ## License
-Licensed under Apache License, Version 2.0, ([LICENSE.txt](LICENSE.txt) or http://www.apache.org/licenses/LICENSE-2.0).
+Licensed under Apache License, Version 2.0, ([LICENSE.txt](LICENSE.txt) or
+http://www.apache.org/licenses/LICENSE-2.0).
 
-Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be licensed as above, without any additional terms or conditions.
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in the work by you, as defined in the Apache-2.0 license, shall be
+licensed as above, without any additional terms or conditions.