7 files changed, 27 insertions, 38 deletions
diff --git a/src/failable/ops/and.rs b/src/failable/ops/and.rs
index f0a1584..f8d4636 100644
--- a/src/failable/ops/and.rs
+++ b/src/failable/ops/and.rs
@@ -10,23 +10,22 @@
 //! shouldn't be necessary.
 //!
 
-use failable::filter::FailableFilter;
+use crate::failable::filter::FailableFilter;
 
 #[must_use = "filters are lazy and do nothing unless consumed"]
 #[derive(Clone)]
 pub struct FailableAnd<T, U>(T, U);
 
 impl<T, U> FailableAnd<T, U> {
-
     pub fn new(a: T, b: U) -> FailableAnd<T, U> {
         FailableAnd(a, b)
     }
-
 }
 
 impl<N, T, U, E> FailableFilter<N> for FailableAnd<T, U>
-    where T: FailableFilter<N, Error = E>,
-          U: FailableFilter<N, Error = E>
+where
+    T: FailableFilter<N, Error = E>,
+    U: FailableFilter<N, Error = E>,
 {
     type Error = E;
 
@@ -34,4 +33,3 @@ impl<N, T, U, E> FailableFilter<N> for FailableAnd<T, U>
         Ok(self.0.filter(e)? && self.1.filter(e)?)
     }
 }
-
diff --git a/src/failable/ops/bool.rs b/src/failable/ops/bool.rs
index ad68f63..e0186f1 100644
--- a/src/failable/ops/bool.rs
+++ b/src/failable/ops/bool.rs
@@ -10,26 +10,22 @@
 //! shouldn't be necessary.
 //!
 
-use failable::filter::FailableFilter;
+use crate::failable::filter::FailableFilter;
 
 #[must_use = "filters are lazy and do nothing unless consumed"]
 #[derive(Clone)]
 pub struct FailableBool(bool);
 
 impl FailableBool {
-
     pub fn new(b: bool) -> FailableBool {
         FailableBool(b)
     }
-
 }
 
 impl From<bool> for FailableBool {
-
     fn from(b: bool) -> FailableBool {
         FailableBool::new(b)
     }
-
 }
 
 impl<N> FailableFilter<N> for FailableBool {
@@ -39,4 +35,3 @@ impl<N> FailableFilter<N> for FailableBool {
         Ok(self.0)
     }
 }
-
diff --git a/src/failable/ops/map.rs b/src/failable/ops/map.rs
index 8dd3cc5..5b28c03 100644
--- a/src/failable/ops/map.rs
+++ b/src/failable/ops/map.rs
@@ -9,10 +9,10 @@
 //! Will be automatically included when including `filter::Filter`, so importing this module
 //! shouldn't be necessary.
 //!
-use std::marker::PhantomData;
 use std::borrow::Borrow;
+use std::marker::PhantomData;
 
-use failable::filter::FailableFilter;
+use crate::failable::filter::FailableFilter;
 
 #[must_use = "filters are lazy and do nothing unless consumed"]
 #[derive(Clone)]
@@ -25,9 +25,10 @@ impl<F, M, FT, B> FailableMapInput<F, M, FT, B> {
 }
 
 impl<FT, F, T, B, M> FailableFilter<T> for FailableMapInput<F, M, FT, B>
-    where F: FailableFilter<FT>,
-          B: Borrow<FT> + Sized,
-          M: Fn(&T) -> B
+where
+    F: FailableFilter<FT>,
+    B: Borrow<FT> + Sized,
+    M: Fn(&T) -> B,
 {
     type Error = F::Error;
 
@@ -47,8 +48,9 @@ impl<F, M, E> FailableMapErr<F, M, E> {
 }
 
 impl<E, F, T, M> FailableFilter<T> for FailableMapErr<F, M, E>
-    where F: FailableFilter<T>,
-          M: Fn(F::Error) -> E
+where
+    F: FailableFilter<T>,
+    M: Fn(F::Error) -> E,
 {
     type Error = E;
 
diff --git a/src/failable/ops/mod.rs b/src/failable/ops/mod.rs
index 618c0e8..c8c2c28 100644
--- a/src/failable/ops/mod.rs
+++ b/src/failable/ops/mod.rs
@@ -6,7 +6,7 @@
 
 pub mod and;
 pub mod bool;
+pub mod map;
 pub mod not;
-pub mod xor;
 pub mod or;
-pub mod map;
+pub mod xor;
diff --git a/src/failable/ops/not.rs b/src/failable/ops/not.rs
index bc55230..3297605 100644
--- a/src/failable/ops/not.rs
+++ b/src/failable/ops/not.rs
@@ -10,22 +10,21 @@
 //! shouldn't be necessary.
 //!
 
-use failable::filter::FailableFilter;
+use crate::failable::filter::FailableFilter;
 
 #[must_use = "filters are lazy and do nothing unless consumed"]
 #[derive(Clone)]
 pub struct FailableNot<T>(T);
 
 impl<T> FailableNot<T> {
-
     pub fn new(a: T) -> FailableNot<T> {
         FailableNot(a)
     }
-
 }
 
 impl<N, T> FailableFilter<N> for FailableNot<T>
-    where T: FailableFilter<N>
+where
+    T: FailableFilter<N>,
 {
     type Error = T::Error;
 
diff --git a/src/failable/ops/or.rs b/src/failable/ops/or.rs
index 9cebc75..6927af9 100644
--- a/src/failable/ops/or.rs
+++ b/src/failable/ops/or.rs
@@ -10,23 +10,22 @@
 //! shouldn't be necessary.
 //!
 
-use failable::filter::FailableFilter;
+use crate::failable::filter::FailableFilter;
 
 #[must_use = "filters are lazy and do nothing unless consumed"]
 #[derive(Clone)]
 pub struct FailableOr<T, U>(T, U);
 
 impl<T, U> FailableOr<T, U> {
-
     pub fn new(a: T, b: U) -> FailableOr<T, U> {
         FailableOr(a, b)
     }
-
 }
 
 impl<N, T, U, E> FailableFilter<N> for FailableOr<T, U>
-    where T: FailableFilter<N, Error = E>,
-          U: FailableFilter<N, Error = E>
+where
+    T: FailableFilter<N, Error = E>,
+    U: FailableFilter<N, Error = E>,
 {
     type Error = E;
 
@@ -34,4 +33,3 @@ impl<N, T, U, E> FailableFilter<N> for FailableOr<T, U>
         Ok(self.0.filter(e)? || self.1.filter(e)?)
     }
 }
-
diff --git a/src/failable/ops/xor.rs b/src/failable/ops/xor.rs
index d8a83bb..8b8dbbd 100644
--- a/src/failable/ops/xor.rs
+++ b/src/failable/ops/xor.rs
@@ -10,23 +10,22 @@
 //! shouldn't be necessary.
 //!
 
-use failable::filter::FailableFilter;
+use crate::failable::filter::FailableFilter;
 
 #[must_use = "filters are lazy and do nothing unless consumed"]
 #[derive(Clone)]
 pub struct FailableXOr<T, U>(T, U);
 
 impl<T, U> FailableXOr<T, U> {
-
     pub fn new(a: T, b: U) -> FailableXOr<T, U> {
         FailableXOr(a, b)
     }
-
 }
 
 impl<N, T, U, E> FailableFilter<N> for FailableXOr<T, U>
-    where T: FailableFilter<N, Error = E>,
-          U: FailableFilter<N, Error = E>
+where
+    T: FailableFilter<N, Error = E>,
+    U: FailableFilter<N, Error = E>,
 {
     type Error = E;
 
@@ -34,5 +33,3 @@ impl<N, T, U, E> FailableFilter<N> for FailableXOr<T, U>
         Ok(self.0.filter(e)? ^ self.1.filter(e)?)
     }
 }
-
-