Merge pull request #9 from LukasKalbertodt/rewrite

Rewrite most of the crate with updated dependencies

Author: KodrAus

Cargo.toml

@@ -1,7 +1,10 @@
 [package]
 name = "auto_impl"
 version = "0.2.0"
-authors = ["Ashley Mannix <[email protected]>"]
+authors = [
+    "Ashley Mannix <[email protected]>",
+    "Lukas Kalbertodt <[email protected]>",
+]
 license = "MIT"
 description = "Automatically implement traits for common smart pointers and closures"
 repository = "https://github.com/KodrAus/auto_impl"
@@ -17,5 +20,6 @@ travis-ci = { repository = "KodrAus/auto_impl" }
 proc-macro = true
 
 [dependencies]
-quote = "~0.3"
-syn = { version = "~0.11", features = ["full"] }
+proc-macro2 = { version = "0.4.6", features = ["nightly"] }
+quote = "0.6.3"
+syn = { version = "0.14.4", features = ["full"] }

compile_test/src/main.rs

@@ -2,7 +2,7 @@
 Try running `cargo expand` on this crate to see the output of `#[auto_impl]`.
 */
 
-#![feature(proc_macro)]
+#![feature(use_extern_macros)]
 
 extern crate auto_impl;
 

examples/greet_closure.rs

@@ -0,0 +1,41 @@
+#![feature(use_extern_macros)]
+
+extern crate auto_impl;
+
+use auto_impl::auto_impl;
+
+
+/// This simple trait can be implemented for `Fn` types, but not for `FnMut` or
+/// `FnOnce` types. The latter two types require a mutable reference to `self`
+/// or a `self` by value to be called, but `greet()` only has an immutable
+/// reference. Try creating an auto-impl for `FnMut`: you should get an error.
+///
+/// This attribute expands to the following impl (not exactly this code, but
+/// equivalent, slightly uglier code):
+///
+/// ```
+/// impl<F: Fn(&str)> Greeter for F {
+///     fn greet(&self, name: &str) {
+///         self(name)
+///     }
+/// }
+/// ```
+#[auto_impl(Fn)]
+trait Greeter {
+    fn greet(&self, name: &str);
+}
+
+
+fn greet_people(greeter: impl Greeter) {
+    greeter.greet("Anna");
+    greeter.greet("Bob");
+}
+
+
+fn main() {
+    // We can simply pass a closure here, since this specific closure
+    // implements `Fn(&str)` and therefore also `Greeter`. Note that we need
+    // explicit type annotations here. This has nothing to do with `auto_impl`,
+    // but is simply a limitation of type inference.
+    greet_people(|name: &str| println!("Hallo {} :)", name));
+}

examples/refs.rs

@@ -0,0 +1,64 @@
+#![feature(use_extern_macros)]
+
+extern crate auto_impl;
+
+use std::fmt::Display;
+
+use auto_impl::auto_impl;
+
+
+/// This trait can be implemented for all reference or pointer types: &, &mut,
+/// Box, Rc and Arc.
+///
+/// This attribute expands to the following impl (not exactly this code, but
+/// equivalent, slightly uglier code):
+///
+/// ```
+/// impl<'a, T: 'a + DisplayCollection> DisplayCollection for &'a T {
+///     type Out = T::Out;
+///     fn display_at(&self, index: usize) -> Option<&Self::Out> {
+///         (**self).display_at(index)
+///     }
+/// }
+///
+/// impl<T: DisplayCollection> DisplayCollection for Box<T> {
+///     type Out = T::Out;
+///     fn display_at(&self, index: usize) -> Option<&Self::Out> {
+///         (**self).display_at(index)
+///     }
+/// }
+/// ```
+#[auto_impl(&, Box)]
+trait DisplayCollection {
+    /// If the length is statically known, this is `Some(len)`.
+    const LEN: Option<usize>;
+    type Out: Display;
+    fn display_at(&self, index: usize) -> Option<&Self::Out>;
+}
+
+impl<T: Display> DisplayCollection for Vec<T> {
+    const LEN: Option<usize> = None;
+    type Out = T;
+    fn display_at(&self, index: usize) -> Option<&Self::Out> {
+        self.get(index)
+    }
+}
+
+fn show_first(c: impl DisplayCollection) {
+    match c.display_at(0) {
+        Some(x) => println!("First: {}", x),
+        None => println!("Nothing :/"),
+    }
+}
+
+
+fn main() {
+    let v = vec!["dog", "cat"];
+    let boxed = Box::new(v.clone());
+
+    show_first(v.clone());      // Vec<&str>    (our manual impl)
+    show_first(&v);             // &Vec<&str>   (auto-impl)
+    show_first(&&v);            // &&Vec<&str>  (works too, of course)
+    show_first(boxed.clone());  // Box<Vec<&str>> (auto-impl)
+    show_first(&boxed);         // &Box<Vec<&str>>
+}