Merge pull request #11 from popzxc/new-things

Add a bunch of new macros

Author: popzxc

CHANGELOG.md

@@ -2,6 +2,9 @@
 
 ## [[Unreleased]]
 
+- `try_match` and `unwrap_match` macros to get a certain variant from an enum.
+- `return_ok` and `return_some` macros for early return of successful calculation.
+
 ## 0.2.1 (09.07.2020)
 
 - `VecExt::remove_item` method was added (#9).

src/duration.rs

@@ -302,8 +302,8 @@ mod tests {
             .add_days(1);
 
         let expected_duration = Duration::new(
-            1 * SECS_IN_DAY + 1 * SECS_IN_HOUR + 1 * SECS_IN_MIN + 1,
-            1 * 1_000_000 + 1 * 1_000 + 1,
+            SECS_IN_DAY + SECS_IN_HOUR + SECS_IN_MIN + 1,
+            1_000_000 + 1_000 + 1,
         );
 
         assert_eq!(duration, expected_duration);

src/macros.rs

@@ -43,7 +43,7 @@ macro_rules! compile_warning {
 /// As the internal implementation is based on the [`std::any::type_name`], this macro derives
 /// all the limitations of this function.
 ///
-/// # Examples
+/// ## Examples
 ///
 /// ```rust
 /// mod bar {
@@ -70,3 +70,162 @@ macro_rules! function_name {
         &name[..name.len() - 3]
     }};
 }
+
+/// Attempts to get variant from the enum variable.
+///
+/// ## Examples
+///
+/// ```rust
+/// # use stdext::try_match;
+///
+/// #[derive(Debug, PartialEq)]
+/// enum Foo {
+///     Left(u16),
+///     Right(&'static str),
+/// }
+///
+/// assert_eq!(try_match!(Foo::Left(18), Foo::Left), Ok(18));
+/// assert_eq!(
+///     try_match!(Foo::Right("nope"), Foo::Left),
+///     Err(Foo::Right("nope"))
+/// );
+/// ```
+#[macro_export]
+macro_rules! try_match {
+    ($var:expr, $variant:path) => {
+        if let $variant(x) = $var {
+            Ok(x)
+        } else {
+            Err($var)
+        }
+    };
+}
+
+/// Similar to [`try_match`] but additionally unwraps the result.
+///
+/// ## Panics
+///
+/// Panics if expression didn't match the provided path.
+///
+/// ## Examples
+///
+/// ```rust
+/// # use stdext::unwrap_match;
+///
+/// #[derive(Debug, PartialEq)]
+/// enum Foo {
+///     Left(u16),
+///     Right(&'static str),
+/// }
+///
+/// assert_eq!(unwrap_match!(Foo::Left(18), Foo::Left), 18);
+/// ```
+///
+/// The following example will panic:
+///
+/// ```should_panic
+/// # use stdext::unwrap_match;
+/// # #[derive(Debug, PartialEq)]
+/// # enum Foo {
+/// #     Left(u16),
+/// #     Right(&'static str),
+/// # }
+/// assert_eq!(unwrap_match!(Foo::Right("nope"), Foo::Left), 18);
+/// ```
+#[macro_export]
+macro_rules! unwrap_match {
+    ($var:expr, $variant:path) => {
+        $crate::try_match!($var, $variant).unwrap()
+    };
+}
+
+/// Checks whether supplied [`Result`] variable is `Ok`
+/// and if so, returns it.
+///
+/// If variant is an `Err`, macro evaluates to the contents of the `Err`
+/// variant.
+///
+/// This macro supports two forms:
+/// - `return_ok!(Ok(42));` - will return `Ok(42)`.
+/// - `return_ok!(inner Ok(42));` - will return just `42`.
+///
+/// ## Examples
+///
+/// ```rust
+/// # use stdext::return_ok;
+///
+/// fn choose_one(left: Result<u8, ()>, right: Result<u8, ()>) -> Result<u8, ()> {
+///     return_ok!(left);
+///     return_ok!(right);
+///     Err(())
+/// }
+///
+/// fn choose_one_inner(left: Result<u8, ()>, right: Result<u8, ()>) -> u8 {
+///     return_ok!(inner left);
+///     return_ok!(inner right);
+///     panic!("Both variables are bad")
+/// }
+///
+/// assert_eq!(choose_one(Err(()), Ok(10)), Ok(10));
+/// assert_eq!(choose_one_inner(Ok(1), Err(())), 1);
+/// ```
+#[macro_export]
+macro_rules! return_ok {
+    ($var:expr) => {
+        match $var {
+            Ok(val) => return Ok(val),
+            Err(err) => err,
+        }
+    };
+    (inner $var:expr) => {
+        match $var {
+            Ok(val) => return val,
+            Err(err) => err,
+        }
+    };
+}
+
+/// Checks whether supplied [`Option`] variable is `Some`
+/// and if so, returns it.
+///
+/// If variant is an `None`, nothing happens.
+///
+/// This macro supports two forms:
+/// - `return_some!(Some(42));` - will return `Some(42)`.
+/// - `return_some!(inner Some(42));` - will return just `42`.
+///
+/// ## Examples
+///
+/// ```rust
+/// # use stdext::return_some;
+///
+/// fn choose_one(left: Option<u8>, right: Option<u8>) -> Option<u8> {
+///     return_some!(left);
+///     return_some!(right);
+///     None
+/// }
+///
+/// fn choose_one_inner(left: Option<u8>, right: Option<u8>) -> u8 {
+///     return_some!(inner left);
+///     return_some!(inner right);
+///     panic!("Both variables are bad")
+/// }
+///
+/// assert_eq!(choose_one(None, Some(10)), Some(10));
+/// assert_eq!(choose_one_inner(Some(1), None), 1);
+/// ```
+#[macro_export]
+macro_rules! return_some {
+    ($var:expr) => {
+        match $var {
+            Some(val) => return Some(val),
+            None => {}
+        }
+    };
+    (inner $var:expr) => {
+        match $var {
+            Some(val) => return val,
+            None => {}
+        }
+    };
+}

src/option.rs

@@ -107,7 +107,7 @@ mod tests {
     fn combine_with() {
         fn f(l: i32, r: i32) -> i32 {
             l + r
-        };
+        }
 
         // Test vector of (left, right, expected) values.
         let test_vector = vec![

src/result.rs

@@ -95,7 +95,7 @@ mod tests {
     fn combine_with() {
         fn f(l: i32, r: i32) -> i32 {
             l + r
-        };
+        }
 
         // Test vector of (left, right, expected) values.
         let test_vector = vec![