Apply typeclass

modules/core/arrow-core-data/src/test/kotlin/arrow/core/TryTest.kt

@@ -1,6 +1,6 @@
 package arrow.core
 
-import arrow.core.extensions.`try`.applicative.map
+import arrow.core.extensions.`try`.apply.map
 import arrow.core.extensions.`try`.eq.eq
 import arrow.core.extensions.`try`.functor.functor
 import arrow.core.extensions.`try`.hash.hash

modules/core/arrow-core-extensions/src/main/kotlin/arrow/core/extensions/const.kt

@@ -5,6 +5,7 @@ import arrow.core.Eval
 import arrow.core.Tuple2
 import arrow.extension
 import arrow.typeclasses.Applicative
+import arrow.typeclasses.Apply
 import arrow.typeclasses.Const
 import arrow.typeclasses.ConstOf
 import arrow.typeclasses.ConstPartialOf
@@ -61,6 +62,17 @@ interface ConstFunctor<A> : Functor<ConstPartialOf<A>> {
     fix().retag()
 }
 
+@extension
+interface ConstApply<A> : Apply<ConstPartialOf<A>> {
+
+  fun MA(): Monoid<A>
+
+  override fun <T, U> ConstOf<A, T>.map(f: (T) -> U): Const<A, U> = fix().retag()
+
+  override fun <T, U> ConstOf<A, T>.ap(ff: ConstOf<A, (T) -> U>): Const<A, U> =
+    constAp(MA(), ff)
+}
+
 @extension
 interface ConstApplicative<A> : Applicative<ConstPartialOf<A>> {
 

modules/core/arrow-core-extensions/src/main/kotlin/arrow/core/extensions/either.kt

@@ -14,6 +14,7 @@ import arrow.core.extensions.either.monad.monad
 import arrow.core.fix
 import arrow.extension
 import arrow.typeclasses.Applicative
+import arrow.typeclasses.Apply
 import arrow.typeclasses.ApplicativeError
 import arrow.typeclasses.Bifunctor
 import arrow.typeclasses.Eq
@@ -80,6 +81,15 @@ interface EitherBifunctor : Bifunctor<ForEither> {
     fix().bimap(fl, fr)
 }
 
+@extension
+interface EitherApply<L> : Apply<EitherPartialOf<L>>, EitherFunctor<L> {
+
+  override fun <A, B> EitherOf<L, A>.map(f: (A) -> B): Either<L, B> = fix().map(f)
+
+  override fun <A, B> EitherOf<L, A>.ap(ff: EitherOf<L, (A) -> B>): Either<L, B> =
+    fix().eitherAp(ff)
+}
+
 @extension
 interface EitherApplicative<L> : Applicative<EitherPartialOf<L>>, EitherFunctor<L> {
 

modules/core/arrow-core-extensions/src/main/kotlin/arrow/core/extensions/eval.kt

@@ -4,11 +4,11 @@ import arrow.core.Either
 import arrow.core.Eval
 import arrow.core.EvalOf
 import arrow.core.ForEval
-import arrow.core.extensions.either.monad.monad
 import arrow.core.extensions.eval.monad.monad
 import arrow.core.fix
 import arrow.extension
 import arrow.typeclasses.Applicative
+import arrow.typeclasses.Apply
 import arrow.typeclasses.Bimonad
 import arrow.typeclasses.Comonad
 import arrow.typeclasses.Functor
@@ -21,6 +21,15 @@ interface EvalFunctor : Functor<ForEval> {
     fix().map(f)
 }
 
+@extension
+interface EvalApply : Apply<ForEval> {
+  override fun <A, B> EvalOf<A>.ap(ff: EvalOf<(A) -> B>): Eval<B> =
+    fix().ap(ff)
+
+  override fun <A, B> EvalOf<A>.map(f: (A) -> B): Eval<B> =
+    fix().map(f)
+}
+
 @extension
 interface EvalApplicative : Applicative<ForEval> {
   override fun <A, B> EvalOf<A>.ap(ff: EvalOf<(A) -> B>): Eval<B> =

modules/core/arrow-core-extensions/src/main/kotlin/arrow/core/extensions/function0.kt

@@ -11,6 +11,7 @@ import arrow.core.fix
 import arrow.core.invoke
 import arrow.extension
 import arrow.typeclasses.Applicative
+import arrow.typeclasses.Apply
 import arrow.typeclasses.Bimonad
 import arrow.typeclasses.Comonad
 import arrow.typeclasses.Functor
@@ -45,6 +46,15 @@ interface Function0Functor : Functor<ForFunction0> {
     fix().map(f)
 }
 
+@extension
+interface Function0Apply : Apply<ForFunction0> {
+  override fun <A, B> Function0Of<A>.ap(ff: Function0Of<(A) -> B>): Function0<B> =
+    fix().ap(ff)
+
+  override fun <A, B> Function0Of<A>.map(f: (A) -> B): Function0<B> =
+    fix().map(f)
+}
+
 @extension
 interface Function0Applicative : Applicative<ForFunction0> {
   override fun <A, B> Function0Of<A>.ap(ff: Function0Of<(A) -> B>): Function0<B> =

modules/core/arrow-core-extensions/src/main/kotlin/arrow/core/extensions/function1.kt

@@ -14,6 +14,7 @@ import arrow.core.fix
 import arrow.core.invoke
 import arrow.extension
 import arrow.typeclasses.Applicative
+import arrow.typeclasses.Apply
 import arrow.typeclasses.Category
 import arrow.typeclasses.Conested
 import arrow.typeclasses.Contravariant
@@ -116,6 +117,16 @@ interface Function1Profunctor : Profunctor<ForFunction1> {
     (fr compose fix().f compose fl).k()
 }
 
+@extension
+interface Function1Apply<I> : Apply<Function1PartialOf<I>>, Function1Functor<I> {
+
+  override fun <A, B> Function1Of<I, A>.map(f: (A) -> B): Function1<I, B> =
+    fix().map(f)
+
+  override fun <A, B> Function1Of<I, A>.ap(ff: Function1Of<I, (A) -> B>): Function1<I, B> =
+    fix().ap(ff)
+}
+
 @extension
 interface Function1Applicative<I> : Applicative<Function1PartialOf<I>>, Function1Functor<I> {
 

modules/core/arrow-core-extensions/src/main/kotlin/arrow/core/extensions/id.kt

@@ -10,24 +10,25 @@ import arrow.core.Id
 import arrow.core.IdOf
 import arrow.core.value
 import arrow.extension
+import arrow.typeclasses.suspended.monad.Fx
+import arrow.core.extensions.traverse as idTraverse
+import arrow.core.extensions.id.monad.monad
+import arrow.core.fix
+import arrow.core.identity
 import arrow.typeclasses.Applicative
-import arrow.typeclasses.Bimonad
-import arrow.typeclasses.Comonad
+import arrow.typeclasses.Apply
 import arrow.typeclasses.Eq
-import arrow.typeclasses.Foldable
 import arrow.typeclasses.Functor
-import arrow.typeclasses.Hash
-import arrow.typeclasses.Monad
 import arrow.typeclasses.Monoid
-import arrow.typeclasses.Selective
 import arrow.typeclasses.Semigroup
 import arrow.typeclasses.Show
+import arrow.typeclasses.Selective
+import arrow.typeclasses.Monad
+import arrow.typeclasses.Comonad
+import arrow.typeclasses.Bimonad
+import arrow.typeclasses.Foldable
 import arrow.typeclasses.Traverse
-import arrow.typeclasses.suspended.monad.Fx
-import arrow.core.extensions.traverse as idTraverse
-import arrow.core.extensions.id.monad.monad
-import arrow.core.fix
-import arrow.core.identity
+import arrow.typeclasses.Hash
 import arrow.core.select as idSelect
 
 @extension
@@ -66,6 +67,15 @@ interface IdFunctor : Functor<ForId> {
     fix().map(f)
 }
 
+@extension
+interface IdApply : Apply<ForId> {
+  override fun <A, B> IdOf<A>.ap(ff: IdOf<(A) -> B>): Id<B> =
+    fix().ap(ff)
+
+  override fun <A, B> IdOf<A>.map(f: (A) -> B): Id<B> =
+    fix().map(f)
+}
+
 @extension
 interface IdApplicative : Applicative<ForId> {
   override fun <A, B> IdOf<A>.ap(ff: IdOf<(A) -> B>): Id<B> =

modules/core/arrow-core-extensions/src/main/kotlin/arrow/core/extensions/option.kt

@@ -12,24 +12,6 @@ import arrow.core.OptionOf
 import arrow.core.Some
 import arrow.core.Tuple2
 import arrow.extension
-import arrow.typeclasses.Applicative
-import arrow.typeclasses.ApplicativeError
-import arrow.typeclasses.Eq
-import arrow.typeclasses.Foldable
-import arrow.typeclasses.Functor
-import arrow.typeclasses.Hash
-import arrow.typeclasses.Monad
-import arrow.typeclasses.MonadError
-import arrow.typeclasses.Monoid
-import arrow.typeclasses.MonoidK
-import arrow.typeclasses.Monoidal
-import arrow.typeclasses.Selective
-import arrow.typeclasses.Semigroup
-import arrow.typeclasses.SemigroupK
-import arrow.typeclasses.Semigroupal
-import arrow.typeclasses.Semiring
-import arrow.typeclasses.Show
-import arrow.typeclasses.Traverse
 import arrow.typeclasses.suspended.monad.Fx
 import arrow.core.extensions.traverse as optionTraverse
 import arrow.core.extensions.option.monad.map
@@ -38,6 +20,25 @@ import arrow.core.fix
 import arrow.core.identity
 import arrow.core.orElse
 import arrow.core.select as optionSelect
+import arrow.typeclasses.Applicative
+import arrow.typeclasses.Apply
+import arrow.typeclasses.Eq
+import arrow.typeclasses.Functor
+import arrow.typeclasses.Monoid
+import arrow.typeclasses.Semigroup
+import arrow.typeclasses.Show
+import arrow.typeclasses.Selective
+import arrow.typeclasses.Monad
+import arrow.typeclasses.Semigroupal
+import arrow.typeclasses.Monoidal
+import arrow.typeclasses.Semiring
+import arrow.typeclasses.ApplicativeError
+import arrow.typeclasses.MonadError
+import arrow.typeclasses.MonoidK
+import arrow.typeclasses.SemigroupK
+import arrow.typeclasses.Foldable
+import arrow.typeclasses.Traverse
+import arrow.typeclasses.Hash
 
 @extension
 interface OptionSemigroup<A> : Semigroup<Option<A>> {
@@ -144,6 +145,15 @@ interface OptionFunctor : Functor<ForOption> {
     fix().map(f)
 }
 
+@extension
+interface OptionApply : Apply<ForOption> {
+  override fun <A, B> OptionOf<A>.ap(ff: OptionOf<(A) -> B>): Option<B> =
+    fix().ap(ff)
+
+  override fun <A, B> OptionOf<A>.map(f: (A) -> B): Option<B> =
+    fix().map(f)
+}
+
 @extension
 interface OptionApplicative : Applicative<ForOption> {
   override fun <A, B> OptionOf<A>.ap(ff: OptionOf<(A) -> B>): Option<B> =

modules/core/arrow-core-extensions/src/main/kotlin/arrow/core/extensions/try.kt

@@ -15,6 +15,7 @@ import arrow.core.fix
 import arrow.core.identity
 import arrow.core.recoverWith
 import arrow.extension
+import arrow.typeclasses.Apply
 import arrow.typeclasses.Applicative
 import arrow.typeclasses.ApplicativeError
 import arrow.typeclasses.Eq
@@ -105,6 +106,15 @@ interface TryFunctor : Functor<ForTry> {
     fix().map(f)
 }
 
+@extension
+interface TryApply : Apply<ForTry> {
+  override fun <A, B> TryOf<A>.ap(ff: TryOf<(A) -> B>): Try<B> =
+    fix().ap(ff)
+
+  override fun <A, B> TryOf<A>.map(f: (A) -> B): Try<B> =
+    fix().map(f)
+}
+
 @extension
 interface TryApplicative : Applicative<ForTry> {
   override fun <A, B> TryOf<A>.ap(ff: TryOf<(A) -> B>): Try<B> =

modules/core/arrow-core-extensions/src/main/kotlin/arrow/core/extensions/tuple.kt

@@ -24,6 +24,7 @@ import arrow.core.identity
 import arrow.core.toT
 import arrow.extension
 import arrow.typeclasses.Applicative
+import arrow.typeclasses.Apply
 import arrow.typeclasses.Bifunctor
 import arrow.typeclasses.Comonad
 import arrow.typeclasses.Eq
@@ -46,6 +47,16 @@ interface Tuple2Functor<F> : Functor<Tuple2PartialOf<F>> {
     fix().map(f)
 }
 
+@extension
+interface Tuple2Apply<F> : Apply<Tuple2PartialOf<F>>, Tuple2Functor<F> {
+
+  override fun <A, B> Tuple2Of<F, A>.map(f: (A) -> B) =
+    fix().map(f)
+
+  override fun <A, B> Tuple2Of<F, A>.ap(ff: Tuple2Of<F, (A) -> B>) =
+    fix().ap(ff.fix())
+}
+
 @extension
 interface Tuple2Applicative<F> : Applicative<Tuple2PartialOf<F>>, Tuple2Functor<F> {
   fun MF(): Monoid<F>

modules/core/arrow-extras-extensions/src/main/kotlin/arrow/data/extensions/andthen.kt

@@ -11,6 +11,7 @@ import arrow.data.fix
 import arrow.data.invoke
 import arrow.extension
 import arrow.typeclasses.Applicative
+import arrow.typeclasses.Apply
 import arrow.typeclasses.Category
 import arrow.typeclasses.Conested
 import arrow.typeclasses.Contravariant
@@ -48,6 +49,15 @@ interface AndThenFunctor<X> : Functor<AndThenPartialOf<X>> {
     fix().map(f)
 }
 
+@extension
+interface AndThenApply<X> : Apply<AndThenPartialOf<X>>, AndThenFunctor<X> {
+  override fun <A, B> AndThenOf<X, A>.ap(ff: AndThenOf<X, (A) -> B>): AndThen<X, B> =
+    fix().ap(ff)
+
+  override fun <A, B> AndThenOf<X, A>.map(f: (A) -> B): AndThen<X, B> =
+    fix().map(f)
+}
+
 @extension
 interface AndThenApplicative<X> : Applicative<AndThenPartialOf<X>>, AndThenFunctor<X> {
   override fun <A> just(a: A): AndThenOf<X, A> =

modules/core/arrow-extras-extensions/src/main/kotlin/arrow/data/extensions/day.kt

@@ -7,6 +7,7 @@ import arrow.data.DayPartialOf
 import arrow.data.fix
 import arrow.extension
 import arrow.typeclasses.Applicative
+import arrow.typeclasses.Apply
 import arrow.typeclasses.Comonad
 import arrow.typeclasses.Functor
 import arrow.undocumented
@@ -36,6 +37,20 @@ interface DayFunctor<F, G> : Functor<DayPartialOf<F, G>> {
     fix().mapLazy(f)
 }
 
+@extension
+@undocumented
+interface DayApply<F, G> : Apply<DayPartialOf<F, G>> {
+  fun AF(): Applicative<F>
+
+  fun AG(): Applicative<G>
+
+  override fun <A, B> DayOf<F, G, A>.map(f: (A) -> B): Day<F, G, B> =
+    fix().mapLazy(f)
+
+  override fun <A, B> Kind<DayPartialOf<F, G>, A>.ap(ff: Kind<DayPartialOf<F, G>, (A) -> B>): Day<F, G, B> =
+    fix().ap(AF(), AG(), ff)
+}
+
 @extension
 @undocumented
 interface DayApplicative<F, G> : Applicative<DayPartialOf<F, G>> {

modules/core/arrow-extras-extensions/src/main/kotlin/arrow/data/extensions/eithert.kt

@@ -23,6 +23,7 @@ import arrow.data.value
 import arrow.extension
 import arrow.typeclasses.Applicative
 import arrow.typeclasses.ApplicativeError
+import arrow.typeclasses.Apply
 import arrow.typeclasses.ComposedTraverse
 import arrow.typeclasses.Contravariant
 import arrow.typeclasses.Decidable
@@ -50,6 +51,21 @@ interface EitherTFunctor<F, L> : Functor<EitherTPartialOf<F, L>> {
     fix().map(FF(), f)
 }
 
+@extension
+@undocumented
+interface EitherTApply<F, L> : Apply<EitherTPartialOf<F, L>>, EitherTFunctor<F, L> {
+
+  fun AF(): Applicative<F>
+
+  override fun FF(): Functor<F> = AF()
+
+  override fun <A, B> EitherTOf<F, L, A>.map(f: (A) -> B): EitherT<F, L, B> =
+    fix().map(AF(), f)
+
+  override fun <A, B> EitherTOf<F, L, A>.ap(ff: EitherTOf<F, L, (A) -> B>): EitherT<F, L, B> =
+    fix().ap(AF(), ff)
+}
+
 @extension
 @undocumented
 interface EitherTApplicative<F, L> : Applicative<EitherTPartialOf<F, L>>, EitherTFunctor<F, L> {