ApplicativeSelect lift lifetime

src/func.rs

@@ -162,7 +162,7 @@ pub trait ApplicativeTuple: Functor {
 ///
 /// <https://hackage.haskell.org/package/base-4.18.0.0/docs/Control-Applicative.html>
 pub trait Applicative<'a>:
-    'a + Pure + ApplicativeSeq + ApplicativeLA2 + ApplicativeTuple + ApplicativeSelect
+    Pure + ApplicativeSeq + ApplicativeLA2 + ApplicativeTuple + ApplicativeSelect<'a>
 {
     /// Equivalent of Haskell's `*>`/`>>`.
     fn discard_first<A: 'a, B: 'a>(fa: Self::F<'a, A>, fb: Self::F<'a, B>) -> Self::F<'a, B> {

src/func/applicative_select.rs

@@ -7,19 +7,16 @@ pub enum Selected<'a, A: 'a, B: 'a, T: ?Sized + 'a + WeakFunctor> {
 
 pub type SelectedWrapped<'a, A, B, T> = Wrap<'a, Selected<'a, A, B, T>, T>;
 
-pub trait ApplicativeSelect: Functor {
-    fn select<'a, A: 'a, B: 'a>(
+pub trait ApplicativeSelect<'a>: 'a + Functor {
+    fn select<A: 'a, B: 'a>(
         fa: Self::F<'a, A>,
         fb: Self::F<'a, B>,
-    ) -> SelectedWrapped<'a, A, B, Self>
-    where
-        Self: 'a,
-    {
+    ) -> SelectedWrapped<'a, A, B, Self> {
         Self::fmap(|a| Selected::A(a, fb), fa)
     }
 }
 
-pub trait ApplicativeSelectExt<'a>: 'a + ApplicativeSelect {
+pub trait ApplicativeSelectExt<'a>: ApplicativeSelect<'a> {
     fn select_map<A: 'a, B: 'a, C: 'a>(
         f: impl 'a + FnOnce(Selected<'a, A, B, Self>) -> C,
         fa: Self::F<'a, A>,
@@ -29,4 +26,4 @@ pub trait ApplicativeSelectExt<'a>: 'a + ApplicativeSelect {
     }
 }
 
-impl<'a, T: 'a + ApplicativeSelect> ApplicativeSelectExt<'a> for T {}
+impl<'a, T: ApplicativeSelect<'a>> ApplicativeSelectExt<'a> for T {}

src/func/instances/composition.rs

@@ -72,14 +72,13 @@ impl<U: ApplicativeTuple, V: ApplicativeTuple> ApplicativeTuple for CompositionI
     }
 }
 
-impl<U: ApplicativeSelect, V: Functor> ApplicativeSelect for CompositionInstance<U, V> {
-    fn select<'a, A: 'a, B: 'a>(
+impl<'a, U: ApplicativeSelect<'a>, V: 'a + Functor> ApplicativeSelect<'a>
+    for CompositionInstance<U, V>
+{
+    fn select<A: 'a, B: 'a>(
         fa: Self::F<'a, A>,
         fb: Self::F<'a, B>,
-    ) -> SelectedWrapped<'a, A, B, Self>
-    where
-        Self: 'a,
-    {
+    ) -> SelectedWrapped<'a, A, B, Self> {
         U::fmap(
             |selected| match selected {
                 Selected::A(ua, fb) => V::fmap(|a| Selected::A(a, fb), ua),

src/func/instances/effect.rs

@@ -110,7 +110,7 @@ impl<E: Effect> ApplicativeTuple for EffectInstance<E> {
     }
 }
 
-impl<E: Effect> ApplicativeSelect for EffectInstance<E> {}
+impl<'a, E: 'a + Effect> ApplicativeSelect<'a> for EffectInstance<E> {}
 
 impl<'a, E: 'a + Effect> Applicative<'a> for EffectInstance<E> {
     fn discard_first<A: 'a, B: 'a>(fa: Self::F<'a, A>, fb: Self::F<'a, B>) -> Self::F<'a, B> {

src/func/instances/future.rs

@@ -72,14 +72,11 @@ impl ApplicativeTuple for FutureInstance {
     }
 }
 
-impl ApplicativeSelect for FutureInstance {
-    fn select<'a, A: 'a, B: 'a>(
+impl<'a> ApplicativeSelect<'a> for FutureInstance {
+    fn select<A: 'a, B: 'a>(
         fa: Self::F<'a, A>,
         fb: Self::F<'a, B>,
-    ) -> SelectedWrapped<'a, A, B, Self>
-    where
-        Self: 'a,
-    {
+    ) -> SelectedWrapped<'a, A, B, Self> {
         Box::pin(async {
             match select(fa, fb).await {
                 Either::Left((a, fb)) => Selected::A(a, fb),

src/func/instances/lazy.rs

@@ -68,7 +68,7 @@ impl ApplicativeTuple for LazyInstance {
     }
 }
 
-impl ApplicativeSelect for LazyInstance {}
+impl<'a> ApplicativeSelect<'a> for LazyInstance {}
 
 impl<'a> Applicative<'a> for LazyInstance {
     fn discard_first<A: 'a, B: 'a>(fa: Self::F<'a, A>, fb: Self::F<'a, B>) -> Self::F<'a, B> {

src/func/instances/option.rs

@@ -72,7 +72,7 @@ impl ApplicativeTuple for OptionInstance {
     }
 }
 
-impl ApplicativeSelect for OptionInstance {}
+impl<'a> ApplicativeSelect<'a> for OptionInstance {}
 
 impl<'a> Applicative<'a> for OptionInstance {
     fn discard_first<A: 'a, B: 'a>(fa: Self::F<'a, A>, fb: Self::F<'a, B>) -> Self::F<'a, B> {

src/func/instances/overload.rs

@@ -84,7 +84,23 @@ impl<T: ApplicativeTuple, O: DeriveApplicative> ApplicativeTuple for OverloadIns
     }
 }
 
-impl<T: ApplicativeTuple, O: DeriveApplicative> ApplicativeSelect for OverloadInstance<T, O> {}
+impl<'a, T: ApplicativeSelect<'a>, O: 'a + DeriveApplicative> ApplicativeSelect<'a>
+    for OverloadInstance<T, O>
+{
+    fn select<A: 'a, B: 'a>(
+        fa: Self::F<'a, A>,
+        fb: Self::F<'a, B>,
+    ) -> SelectedWrapped<'a, A, B, Self> {
+        T::select_map(
+            |selected| match selected {
+                Selected::A(a, fb) => Selected::A(a, fb),
+                Selected::B(fa, b) => Selected::B(fa, b),
+            },
+            fa,
+            fb,
+        )
+    }
+}
 
 impl<'a, T: Applicative<'a>, O: 'a + DeriveApplicative> Applicative<'a> for OverloadInstance<T, O> {
     fn discard_first<A: 'a, B: 'a>(fa: Self::F<'a, A>, fb: Self::F<'a, B>) -> Self::F<'a, B> {

src/func/instances/result.rs

@@ -84,7 +84,7 @@ impl<E> ApplicativeTuple for ResultInstance<E> {
     }
 }
 
-impl<E> ApplicativeSelect for ResultInstance<E> {}
+impl<'a, E: 'a> ApplicativeSelect<'a> for ResultInstance<E> {}
 
 impl<'a, E: 'a> Applicative<'a> for ResultInstance<E> {
     fn discard_first<A: 'a, B: 'a>(fa: Self::F<'a, A>, fb: Self::F<'a, B>) -> Self::F<'a, B> {

src/func/instances/solo.rs

@@ -60,7 +60,7 @@ impl ApplicativeTuple for SoloInstance {
     }
 }
 
-impl ApplicativeSelect for SoloInstance {}
+impl<'a> ApplicativeSelect<'a> for SoloInstance {}
 
 impl<'a> Applicative<'a> for SoloInstance {
     fn discard_first<A: 'a, B: 'a>(fa: Self::F<'a, A>, fb: Self::F<'a, B>) -> Self::F<'a, B> {

src/func/instances/stackless.rs

@@ -187,7 +187,7 @@ impl ApplicativeTuple for StacklessInstance {
     }
 }
 
-impl ApplicativeSelect for StacklessInstance {}
+impl<'a> ApplicativeSelect<'a> for StacklessInstance {}
 
 impl<'a> Applicative<'a> for StacklessInstance {
     fn discard_first<A: 'a, B: 'a>(fa: Self::F<'a, A>, fb: Self::F<'a, B>) -> Self::F<'a, B> {

src/func/instances/tryfuture.rs

@@ -82,14 +82,11 @@ impl<E> ApplicativeTuple for TryFutureInstance<E> {
     }
 }
 
-impl<E> ApplicativeSelect for TryFutureInstance<E> {
-    fn select<'a, A: 'a, B: 'a>(
+impl<'a, E: 'a> ApplicativeSelect<'a> for TryFutureInstance<E> {
+    fn select<A: 'a, B: 'a>(
         fa: Self::F<'a, A>,
         fb: Self::F<'a, B>,
-    ) -> SelectedWrapped<'a, A, B, Self>
-    where
-        Self: 'a,
-    {
+    ) -> SelectedWrapped<'a, A, B, Self> {
         Box::pin(async {
             match try_select(fa, fb).await {
                 Ok(Either::Left((a, fb))) => Ok(Selected::A(a, fb)),