Add field-specific functionality to Into

CHANGELOG.md

@@ -35,6 +35,9 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
   and ignores field type itself.
 - The `Into` derive now uses `#[into(<types>)]` instead of `#[into(types(<types>))]`
   and ignores field type itself.
+- The `Into` derive now generates separate impls for each field with the `#[into(...)]`
+  attribute applied to it.
+  ([#291](https://github.com/JelteF/derive_more/pull/291))
 - Importing a derive macro now also import its corresponding trait.
 - The `Error` derive is updated with changes to the `error_generic_member_access`
   unstable feature for nightly users. ([#200](https://github.com/JelteF/derive_more/pull/200),

impl/doc/into.md

@@ -108,6 +108,86 @@ assert_eq!(5_i128, Mass::<Gram>::new(5).into());
 # }
 ```
 
+The `#[into(...)]` attribute can also be applied to specific fields
+
+```rust
+# use derive_more::Into;
+
+#[derive(Into)]
+struct Data {
+    id: i32,
+    #[into]
+    raw: f64
+}
+
+assert_eq!(42.0, Data { id: 1, raw: 42.0 }.into());
+```
+
+In this case no conversion into a tuple of all fields is generated unless
+an explicit struct attribute is present
+
+```rust
+# use derive_more::Into;
+
+#[derive(Into)]
+#[into]
+struct Data {
+    id: i32,
+    #[into]
+    raw: f64
+}
+
+assert_eq!(42.0, Data { id: 1, raw: 42.0 }.into());
+assert_eq!((1, 42.0), Data { id: 1, raw: 42.0 }.into());
+```
+
+The same `#[into(<types>)]` syntax can be used in field attributes as well
+
+```rust
+# use std::marker::PhantomData;
+# use derive_more::Into;
+# struct Whatever;
+
+#[derive(Into, Clone)]
+#[into(owned, ref((u8, str)), ref_mut)]
+struct Foo {
+   #[into(owned(u64), ref)]
+   a: u8,
+   b: String,
+   #[into(skip)]
+   _c: PhantomData<Whatever>,
+}
+
+let mut foo = Foo { a: 1, b: "string".to_owned(), _c: PhantomData };
+
+assert_eq!((1_u8, "string".to_owned()), foo.clone().into());
+assert_eq!((&1_u8, "string"), <(&u8, &str)>::from(&foo));
+assert_eq!((&mut 1_u8, &mut "string".to_owned()), <(&mut u8, &mut String)>::from(&mut foo));
+assert_eq!(1_u64, foo.clone().into());
+assert_eq!(&1_u8, <&u8>::from(&foo));
+```
+
+Fields that have specific conversions into them can also be skipped
+
+```rust
+# use derive_more::Into;
+
+#[derive(Into)]
+#[into(ref((str, f64)))]
+struct Foo {
+    #[into(ref)]
+    #[into(skip)]
+    a: u8,
+    b: String,
+    c: f64,
+}
+
+let foo = Foo { a: 1, b: "string".to_owned(), c: 3.0 };
+
+assert_eq!(("string", &3.0), (&foo).into());
+assert_eq!(&1_u8, <&u8>::from(&foo));
+```
+