Change unit variants to use is_ functions

Currently unit variants return an option of the unit type. But this does not
offer any more information or functionality then a predicate function. The is_*
functions are nicer to use lead simpler code.

Author: CeleritasCelery

README.md

@@ -34,7 +34,7 @@ where the result is either a reference for inner items or a tuple containing the
 
 ## Unit case
 
-This will return copy's of the value of the unit variant, as `isize`:
+This will return true if enum's variant matches the expected type
 
 ```rust
 use enum_as_inner::EnumAsInner;
@@ -45,18 +45,12 @@ enum UnitVariants {
     One,
     Two,
 }
-```
-
-These are not references:
 
-```rust
 let unit = UnitVariants::Two;
 
-assert_eq!(unit.as_two().unwrap(), ());
+assert!(unit.is_two());
 ```
 
-Note that for unit enums there is no `into_*()` function generated.
-
 ## Mutliple, unnamed field case
 
 This will return a tuple of the inner types:
@@ -105,4 +99,4 @@ let mut many = ManyVariants::Three{ one: true, two: 1, three: 2 };
 assert_eq!(many.as_three().unwrap(), (&true, &1_u32, &2_i64));
 assert_eq!(many.as_three_mut().unwrap(), (&mut true, &mut 1_u32, &mut 2_i64));
 assert_eq!(many.into_three().unwrap(), (true, 1_u32, 2_i64));
-```
+```

src/lib.rs

@@ -31,7 +31,7 @@
 //!
 //! ## Unit case
 //!
-//! This will return copy's of the value of the unit variant, as `isize`:
+//! This will return true if enum's variant matches the expected type
 //!
 //! ```rust
 //! use enum_as_inner::EnumAsInner;
@@ -45,11 +45,9 @@
 //!
 //! let unit = UnitVariants::Two;
 //!
-//! assert_eq!(unit.as_two().unwrap(), ());
+//! assert!(unit.is_two());
 //! ```
 //!
-//! Note that for unit enums there is no `into_*()` function generated.
-//!
 //! ## Mutliple, unnamed field case
 //!
 //! This will return a tuple of the inner types:
@@ -105,29 +103,13 @@ use syn::DeriveInput;
 fn unit_fields_return(
     name: &syn::Ident,
     variant_name: &syn::Ident,
-    function_name_mut: &Ident,
     function_name: &Ident,
     doc: &str,
 ) -> TokenStream {
     quote!(
-        #[doc = #doc ]
-        pub fn #function_name_mut(&mut self) -> Option<()> {
-            match self {
-                #name::#variant_name => {
-                    Some(())
-                }
-                _ => None
-            }
-        }
-
-        #[doc = #doc ]
-        pub fn #function_name(&self) -> Option<()> {
-            match self {
-                #name::#variant_name => {
-                    Some(())
-                }
-                _ => None
-            }
+        #[doc = #doc]
+        pub fn #function_name(&self) -> bool {
+            matches!(self, #name::#variant_name)
         }
     )
 }
@@ -335,13 +317,21 @@ fn impl_all_as_fns(ast: &DeriveInput) -> TokenStream {
             variant_name,
         );
 
+        let function_name_is = Ident::new(
+            &format!("is_{}", variant_name).to_snake_case(),
+            Span::call_site(),
+        );
+        let doc_is = format!(
+            "Returns true if this is a `{}::{}`, otherwise false",
+            name, variant_name,
+        );
+
         let tokens = match &variant_data.fields {
             syn::Fields::Unit => unit_fields_return(
                 name,
                 variant_name,
-                &function_name_mut_ref,
-                &function_name_ref,
-                &doc_ref,
+                &function_name_is,
+                &doc_is,
             ),
             syn::Fields::Unnamed(unnamed) => unnamed_fields_return(
                 name,

tests/snake_case.rs

@@ -1,6 +1,7 @@
 use enum_as_inner::EnumAsInner;
 
 #[derive(Debug, EnumAsInner)]
+#[allow(clippy::upper_case_acronyms)]
 enum MixedCaseVariants {
     XMLIsNotCool,
     #[allow(non_camel_case_types)]
@@ -14,20 +15,16 @@ enum MixedCaseVariants {
 fn test_xml_unit() {
     let mixed = MixedCaseVariants::XMLIsNotCool;
 
-    assert!(mixed.as_xml_is_not_cool().is_some());
+    assert!(mixed.is_xml_is_not_cool());
     assert!(mixed.as_rust_is_cool_though().is_none());
     assert!(mixed.as_ymca().is_none());
-
-    mixed
-        .as_xml_is_not_cool()
-        .expect("should have been some unit");
 }
 
 #[test]
 fn test_rust_unnamed() {
     let mixed = MixedCaseVariants::Rust_IsCoolThough(42);
 
-    assert!(mixed.as_xml_is_not_cool().is_none());
+    assert!(!mixed.is_xml_is_not_cool());
     assert!(mixed.as_rust_is_cool_though().is_some());
     assert!(mixed.as_ymca().is_none());
 
@@ -39,7 +36,7 @@ fn test_rust_unnamed() {
 fn test_ymca_named() {
     let mixed = MixedCaseVariants::YMCA { named: -32_768 };
 
-    assert!(mixed.as_xml_is_not_cool().is_none());
+    assert!(!mixed.is_xml_is_not_cool());
     assert!(mixed.as_rust_is_cool_though().is_none());
     assert!(mixed.as_ymca().is_some());
 

tests/unit.rs

@@ -9,45 +9,28 @@ enum UnitVariants {
 
 #[test]
 fn test_zero_unit() {
-    let mut unit = UnitVariants::Zero;
+    let unit = UnitVariants::Zero;
 
-    assert!(unit.as_zero().is_some());
-    assert!(unit.as_one().is_none());
-    assert!(unit.as_two().is_none());
-
-    assert!(unit.as_zero_mut().is_some());
-    assert!(unit.as_one_mut().is_none());
-    assert!(unit.as_two_mut().is_none());
-
-    unit.as_zero().expect("expected ");
+    assert!(unit.is_zero());
+    assert!(!unit.is_one());
+    assert!(!unit.is_two());
 }
 
 #[test]
 fn test_one_unit() {
-    let mut unit = UnitVariants::One;
-
-    assert!(unit.as_zero().is_none());
-    assert!(unit.as_one().is_some());
-    assert!(unit.as_two().is_none());
+    let unit = UnitVariants::One;
 
-    assert!(unit.as_zero_mut().is_none());
-    assert!(unit.as_one_mut().is_some());
-    assert!(unit.as_two_mut().is_none());
+    assert!(!unit.is_zero());
+    assert!(unit.is_one());
+    assert!(!unit.is_two());
 
-    unit.as_one().expect("should have been some unit");
 }
 
 #[test]
 fn test_two_unit() {
-    let mut unit = UnitVariants::Two;
-
-    assert!(unit.as_zero().is_none());
-    assert!(unit.as_one().is_none());
-    assert!(unit.as_two().is_some());
-
-    assert!(unit.as_zero_mut().is_none());
-    assert!(unit.as_one_mut().is_none());
-    assert!(unit.as_two_mut().is_some());
+    let unit = UnitVariants::Two;
 
-    unit.as_two().expect("should have been some unit");
+    assert!(!unit.is_zero());
+    assert!(!unit.is_one());
+    assert!(unit.is_two());
 }