I, for one, welcome our new clippy overlords

1 files changed, 22 insertions, 27 deletions

diff --git a/tests/multiple_generics.rs b/tests/multiple_generics.rs
index 2f560dd..c8c76ba 100644
--- a/tests/multiple_generics.rs
+++ b/tests/multiple_generics.rs
@@ -1,11 +1,21 @@
+#![deny(clippy::pedantic)]
+#![deny(clippy::all)]
 //! Tests if multiple generic parameters work, for the case that lifetimes are independent of mapping functions.
-//! For simplicity, it just creates a FreeResult
+//! For simplicity, it just creates a `FreeResult` based on `Result`.
 
 use higher_free_macro::free;
 use higher::{Functor, Bind, Apply};
 
 free!(FreeResult<O,E>, Result<FreeResult<O,E>,E>);
 
+
+//just to appease clippy without disabling the lint....
+macro_rules! assert_nearly_equal {
+    ($a:expr, $b:expr, $c:expr) => {
+        assert!((($a)-($b)).abs() < $c)
+    };
+}
+
 #[test]
 fn test_multiple_generics(){
     let m : FreeResult<_, String> = FreeResult::lift_f(Ok(37u32));
@@ -16,26 +26,16 @@ fn test_multiple_generics(){
     match m {
         FreeResult::Free(b) => {
             match *b {
-                Ok(f) => {
-                    match f {
-                        FreeResult::Free(b) => {
-                            match *b {
-                                Ok(f) => {
-                                    match f{
-                                        FreeResult::Pure(x) => assert_eq!(x, 37*6),
-                                        _ => unreachable!()
-                                    }
-                                }
-                                _ => unreachable!()
-                            }
-                        },
+                Ok(FreeResult::Free(b)) => {
+                    match *b {
+                        Ok(FreeResult::Pure(x)) => assert_eq!(x, 37*6),
                         _ => unreachable!()
                     }
                 }
                 _ => unreachable!()
             }
         }
-        _ => unreachable!()
+        FreeResult::Pure(_) => unreachable!()
     }
 }
 
@@ -46,41 +46,36 @@ fn test_multiple_generics2(){
     match m{
         FreeResult::Free(m) => {
             match &*m {
-                Ok(m) => {
-                    match m{
-                        FreeResult::Free(m) => {
-                            match &**m {
-                                Err(e) => assert_eq!(e, "An early out."),
-                                _ => unreachable!()
-                            }
-                        }
+                Ok(FreeResult::Free(m)) => {
+                    match &**m {
+                        Err(e) => assert_eq!(e, "An early out."),
                         _ => unreachable!()
                     }
                 },
                 _ => unreachable!()
             }
         },
-        _ => unreachable!()
+        FreeResult::Pure(_) => unreachable!()
     }
 }
 
 #[test]
 fn test_multiple_generics3(){
     let m : FreeResult<_, String> = FreeResult::lift_f(Ok(37u32));
-    let f : FreeResult<_, String> = FreeResult::Pure(|x : u32| -> f32 {(x as f32)*0.5f32}).fmap(Into::into);
+    let f : FreeResult<_, String> = FreeResult::Pure(|x : u32| -> f64 {f64::from(x)*0.5f64}).fmap(Into::into);
     let m = m.apply(f);
     match m{
         FreeResult::Free(m) => {
             match &*m{
                 Ok(k) => {
                     match k {
-                        FreeResult::Pure(k) => assert_eq!(18.5f32, *k),
+                        FreeResult::Pure(k) => assert_nearly_equal!(18.5f64, *k, f64::EPSILON),
                         FreeResult::Free(_) => unreachable!(),
                     }
                 }
                 Err(_) => unreachable!(),
             }
         },
-        _ => unreachable!()
+        FreeResult::Pure(_) => unreachable!()
     }
 }
\ No newline at end of file