Corrected declarative_macro.rs documentation.

indexed_valued_enums/src/macros.rs

@@ -158,7 +158,7 @@ macro_rules! create_indexed_valued_enum {
             If you just need a reference to the value, use \
             [",stringify!($enum_name),"::value_ref])] instead, as it doesn't require a read copy)
             <br><br>This always returns [Option::Some], so it's recommended to call\
-            [",stringify!($enum_name),"::value] instead") <br>]
+            [",stringify!($enum_name),"::value] instead")]
             pub const fn value_opt(&self) -> Option<$value_type> {
                 indexed_valued_enums::valued_enum::value_opt_internal(self)
             }
@@ -179,18 +179,17 @@ macro_rules! create_indexed_valued_enum {
             instead, as it performs a read copy \
             <br><br>This always returns [Option::Some], so it's recommended to call\
             [",stringify!($enum_name),"::value] instead")]
-            pub const fn value_opt(&self) -> Option<&'static $value_type> {
+            pub const fn value_ref_opt(&self) -> Option<&'static $value_type> {
                 indexed_valued_enums::valued_enum::value_ref_opt_internal(self)
             }
 
             #[doc = concat!("Gives the value of type [",stringify!($value_type),"] corresponding \
             to this [", stringify!($enum_name),"] 's variant, if you need a copy of the value\
-            but the value doesn't implement Clone, use [",stringify!($value_type),"::value]"
-            instead as it performs a read copy)]
+            but the value doesn't implement Clone, use [",stringify!($enum_name),"::value] \
+            instead as it performs a read copy")]
             pub const fn value_ref(&self) -> &'static $value_type {
                 indexed_valued_enums::valued_enum::value_ref_internal(self)
             }
-
         }
     };
     (process feature $enum_name:ident, $value_type:ty; ValueToVariantDelegators)

indexed_valued_enums/tests/declarative_macro.rs

@@ -20,6 +20,7 @@ struct NumberDescription {
 fn test() {
     assert_eq!(Number::Zero.discriminant(), 0);
     assert_eq!(Number::First.value().description, "First position");
+    assert_eq!(Number::First.value_ref().description, "First position");
     assert_eq!(Number::First.index, 1);
     assert_eq!(Number::Second.clone(), Number::Second);
     assert_eq!(Number::Third, Number::value_to_variant(

indexed_valued_enums/tests/derive_macro.rs

@@ -18,6 +18,7 @@ enum NumberValue {
 fn test_valued() {
     assert_eq!(NumberValue::Zero.discriminant(), 0);
     assert_eq!(NumberValue::First.value(), 1);
+    assert_eq!(NumberValue::First.value_ref(), &1);
     assert_eq!(*NumberValue::First, 1);
     assert_eq!(NumberValue::Second.clone(), NumberValue::Second);
     assert_eq!(NumberValue::Third, NumberValue::value_to_variant(&3));
@@ -45,6 +46,7 @@ enum NumberValueDefaulted {
 fn test_defaulted() {
     assert_eq!(NumberValueDefaulted::Zero.discriminant(), 0);
     assert_eq!(NumberValueDefaulted::First.value(), 1);
+    assert_eq!(NumberValueDefaulted::First.value_ref(), &1);
     assert_eq!(*NumberValueDefaulted::First, 1);
     assert_eq!(NumberValueDefaulted::Second.clone(), NumberValueDefaulted::Second);
     assert_eq!(NumberValueDefaulted::Third, NumberValueDefaulted::value_to_variant(&3));
@@ -77,6 +79,7 @@ enum NumberCustom {
 fn test_custom_type() {
     assert_eq!(NumberCustom::Zero.discriminant(), 0);
     assert_eq!(NumberCustom::First.value().num, 1);
+    assert_eq!(NumberCustom::First.value_ref().num, 1);
     assert_eq!(NumberCustom::Ten.num, 10);
     assert_eq!(NumberCustom::Ten.name, "Ten");
     assert_eq!(NumberCustom::Second.clone().num, NumberCustom::Second.num);