diff --git a/src/func.rs b/src/func.rs
index 1ec06f1..23be49b 100644
--- a/src/func.rs
+++ b/src/func.rs
@@ -383,7 +383,7 @@ pub trait MonadFailAnyExt: MonadFailAny {
     where
         Self: 'a,
     {
-        <Self as speculative::SpeculativeFail>::speculative(wwa, wwb)
+        <Self as speculative::SpeculativeFail<'a>>::speculative(wwa, wwb)
     }
 }
 
diff --git a/src/func/speculative.rs b/src/func/speculative.rs
index ad59f08..246a4ea 100644
--- a/src/func/speculative.rs
+++ b/src/func/speculative.rs
@@ -5,72 +5,54 @@ type Frwa<'a, A, E0, E1, Fallible> =
 
 type Wwa<'a, A, E0, E1, Fallible> = WrapE<'a, WrapE<'a, A, E0, Fallible>, E1, Fallible>;
 
-pub trait SpeculativeFail: MonadFailAny {
-    fn _speculative_a_wb<'a, A: 'a, B: 'a, E0: 'a, E1: 'a>(
+pub trait SpeculativeFail<'a>: 'a + MonadFailAny {
+    fn _speculative_a_wb<A: 'a, B: 'a, E0: 'a, E1: 'a>(
         a: A,
         wb: WrapE<'a, B, E0, Self>,
-    ) -> WrapE<'a, (A, B), Result<E0, E1>, Self>
-    where
-        Self: 'a,
-    {
+    ) -> WrapE<'a, (A, B), Result<E0, E1>, Self> {
         Self::map_err(<Self::W<E0> as Functor>::fmap(|b| (a, b), wb), Ok)
     }
 
-    fn _speculative_ra_wb<'a, A: 'a, B: 'a, E0: 'a, E1: 'a>(
+    fn _speculative_ra_wb<A: 'a, B: 'a, E0: 'a, E1: 'a>(
         ra: Result<A, E0>,
         wb: WrapE<'a, B, E0, Self>,
-    ) -> WrapE<'a, (A, B), Result<E0, E1>, Self>
-    where
-        Self: 'a,
-    {
+    ) -> WrapE<'a, (A, B), Result<E0, E1>, Self> {
         match ra {
             Ok(a) => Self::_speculative_a_wb(a, wb),
             Err(e0) => Self::fail(Ok(e0)),
         }
     }
 
-    fn _speculative_ra_rwb<'a, A: 'a, B: 'a, E0: 'a, E1: 'a>(
+    fn _speculative_ra_rwb<A: 'a, B: 'a, E0: 'a, E1: 'a>(
         ra: Result<A, E0>,
         rwb: Result<WrapE<'a, B, E0, Self>, E1>,
-    ) -> WrapE<'a, (A, B), Result<E0, E1>, Self>
-    where
-        Self: 'a,
-    {
+    ) -> WrapE<'a, (A, B), Result<E0, E1>, Self> {
         match rwb {
             Ok(wb) => Self::_speculative_ra_wb(ra, wb),
             Err(e1) => Self::fail(Err(e1)),
         }
     }
 
-    fn _speculative_ra_frwb<'a, A: 'a, B: 'a, E0: 'a, E1: 'a>(
+    fn _speculative_ra_frwb<A: 'a, B: 'a, E0: 'a, E1: 'a>(
         ra: Result<A, E0>,
         frwb: Frwa<'a, B, E0, E1, Self>,
-    ) -> WrapE<'a, (A, B), Result<E0, E1>, Self>
-    where
-        Self: 'a,
-    {
+    ) -> WrapE<'a, (A, B), Result<E0, E1>, Self> {
         Self::stuff(<Self::T as Monad>::bind(frwb, |rwb| {
             Self::unstuff(Self::_speculative_ra_rwb(ra, rwb))
         }))
     }
 
-    fn _speculative_fra_wb<'a, A: 'a, B: 'a, E0: 'a>(
+    fn _speculative_fra_wb<A: 'a, B: 'a, E0: 'a>(
         fra: Wrap<'a, Result<A, E0>, Self::T>,
         wb: WrapE<'a, B, E0, Self>,
-    ) -> WrapE<'a, (A, B), E0, Self>
-    where
-        Self: 'a,
-    {
+    ) -> WrapE<'a, (A, B), E0, Self> {
         <Self::W<E0> as ApplicativeTuple>::tuple((Self::stuff(fra), wb))
     }
 
-    fn _speculative_wa_frwb<'a, A: 'a, B: 'a, E0: 'a, E1: 'a>(
+    fn _speculative_wa_frwb<A: 'a, B: 'a, E0: 'a, E1: 'a>(
         wa: WrapE<'a, A, E0, Self>,
         frwb: Frwa<'a, B, E0, E1, Self>,
-    ) -> WrapE<'a, (A, B), Result<E0, E1>, Self>
-    where
-        Self: 'a,
-    {
+    ) -> WrapE<'a, (A, B), Result<E0, E1>, Self> {
         Self::stuff(<<Self as MonadFailAny>::T as Monad>::join(
             <<Self as MonadFailAny>::T as Functor>::fmap(
                 Self::unstuff,
@@ -89,26 +71,20 @@ pub trait SpeculativeFail: MonadFailAny {
         ))
     }
 
-    fn _speculative_frwa_wb<'a, A: 'a, B: 'a, E0: 'a, E1: 'a>(
+    fn _speculative_frwa_wb<A: 'a, B: 'a, E0: 'a, E1: 'a>(
         frwa: Frwa<'a, A, E0, E1, Self>,
         wb: WrapE<'a, B, E0, Self>,
-    ) -> WrapE<'a, (A, B), Result<E0, E1>, Self>
-    where
-        Self: 'a,
-    {
+    ) -> WrapE<'a, (A, B), Result<E0, E1>, Self> {
         <Self::W<Result<E0, E1>> as Functor>::fmap(
             |(b, a)| (a, b),
             Self::_speculative_wa_frwb(wb, frwa),
         )
     }
 
-    fn speculative<'a, A: 'a, B: 'a, E0: 'a, E1: 'a>(
+    fn speculative<A: 'a, B: 'a, E0: 'a, E1: 'a>(
         wwa: Wwa<'a, A, E0, E1, Self>,
         wwb: Wwa<'a, B, E0, E1, Self>,
-    ) -> WrapE<'a, (A, B), Result<E0, E1>, Self>
-    where
-        Self: 'a,
-    {
+    ) -> WrapE<'a, (A, B), Result<E0, E1>, Self> {
         Self::stuff(<Self::T as Monad>::join(<Self::T as Functor>::fmap(
             Self::unstuff,
             Self::T::select_map(
@@ -125,4 +101,4 @@ pub trait SpeculativeFail: MonadFailAny {
     }
 }
 
-impl<Fallible: ?Sized + MonadFailAny> SpeculativeFail for Fallible {}
+impl<'a, Fallible: ?Sized + 'a + MonadFailAny> SpeculativeFail<'a> for Fallible {}