CU-cn24gw CU-cn24dh Remove extension and higherkind annotations for Endo and Eval

arrow-core-data/src/main/kotlin/arrow/core/Endo.kt

@@ -1,8 +1,22 @@
 package arrow.core
 
+import arrow.typeclasses.Monoid
+
 /**
  * The monoid of endomorphisms under composition.
  */
 data class Endo<A>(val f: (A) -> A) {
+
   companion object
+
+  fun combine(g: Endo<A>): Endo<A> =
+    Endo(f.compose(g.f))
+}
+
+fun <A> Monoid.Companion.endo(): Monoid<Endo<A>> = object : Monoid<Endo<A>> {
+  override fun empty(): Endo<A> =
+    Endo(::identity)
+
+  override fun Endo<A>.combine(g: Endo<A>): Endo<A> =
+    Endo(f.compose(g.f))
 }

arrow-core-data/src/main/kotlin/arrow/core/Eval.kt

@@ -1,11 +1,17 @@
 package arrow.core
 
+import arrow.typeclasses.Monoid
 import org.codehaus.mojo.animal_sniffer.IgnoreJRERequirement
 
-class ForEval private constructor() { companion object }
+@Deprecated("Kind is deprecated, and will be removed in 0.13.0. Please use one of the provided concrete methods instead")
+class ForEval private constructor() {
+  companion object
+}
+@Deprecated("Kind is deprecated, and will be removed in 0.13.0. Please use one of the provided concrete methods instead")
 typealias EvalOf<A> = arrow.Kind<ForEval, A>
 
 @Suppress("UNCHECKED_CAST", "NOTHING_TO_INLINE")
+@Deprecated("Kind is deprecated, and will be removed in 0.13.0. Please use one of the provided concrete methods instead")
 inline fun <A> EvalOf<A>.fix(): Eval<A> =
   this as Eval<A>
 
@@ -67,6 +73,12 @@ sealed class Eval<out A> : EvalOf<A> {
 
   companion object {
 
+    @JvmName("tailRecMKind")
+    @Deprecated(
+      "Kind is deprecated, and will be removed in 0.13.0. Please use the tailRecM method defined for Eval instead",
+      ReplaceWith("tailRecM(f)"),
+      DeprecationLevel.WARNING
+    )
     fun <A, B> tailRecM(a: A, f: (A) -> EvalOf<Either<A, B>>): Eval<B> =
       f(a).fix().flatMap { eval: Either<A, B> ->
         when (eval) {
@@ -75,6 +87,19 @@ sealed class Eval<out A> : EvalOf<A> {
         }
       }
 
+    fun <A, B> tailRecM(a: A, f: (A) -> Eval<Either<A, B>>): Eval<B> =
+      f(a).flatMap { eval: Either<A, B> ->
+        when (eval) {
+          is Either.Left -> tailRecM(eval.a, f)
+          is Either.Right -> just(eval.b)
+        }
+      }
+
+    @Deprecated(
+      "just is deprecated in favor of now",
+      ReplaceWith("now(a)"),
+      DeprecationLevel.WARNING
+    )
     fun <A> just(a: A): Eval<A> =
       now(a)
 
@@ -242,6 +267,125 @@ sealed class Eval<out A> : EvalOf<A> {
 
       return curr.value() as A
     }
+
+    fun <A, B, C> mapN(
+      a: Eval<A>,
+      b: Eval<B>,
+      map: (A, B) -> C
+    ): Eval<C> =
+      mapN(a, b, Unit, Unit, Unit, Unit, Unit, Unit, Unit) { aa, bb, _, _, _, _, _, _, _ -> map(aa, bb) }
+
+    fun <A, B, C, D> mapN(
+      a: Eval<A>,
+      b: Eval<B>,
+      c: Eval<C>,
+      map: (A, B, C) -> D
+    ): Eval<D> =
+      mapN(a, b, c, Unit, Unit, Unit, Unit, Unit, Unit, Unit) { aa, bb, cc, _, _, _, _, _, _, _ -> map(aa, bb, cc) }
+
+    fun <A, B, C, D, E> mapN(
+      a: Eval<A>,
+      b: Eval<B>,
+      c: Eval<C>,
+      d: Eval<D>,
+      map: (A, B, C, D) -> E
+    ): Eval<E> =
+      mapN(a, b, c, d, Unit, Unit, Unit, Unit, Unit, Unit) { aa, bb, cc, dd, _, _, _, _, _, _ -> map(aa, bb, cc, dd) }
+
+    fun <A, B, C, D, E, F> mapN(
+      a: Eval<A>,
+      b: Eval<B>,
+      c: Eval<C>,
+      d: Eval<D>,
+      e: Eval<E>,
+      map: (A, B, C, D, E) -> F
+    ): Eval<F> =
+      mapN(a, b, c, d, e, Unit, Unit, Unit, Unit, Unit) { aa, bb, cc, dd, ee, _, _, _, _, _ -> map(aa, bb, cc, dd, ee) }
+
+    fun <A, B, C, D, E, F, G> mapN(
+      a: Eval<A>,
+      b: Eval<B>,
+      c: Eval<C>,
+      d: Eval<D>,
+      e: Eval<E>,
+      f: Eval<F>,
+      map: (A, B, C, D, E, F) -> G
+    ): Eval<G> =
+      mapN(a, b, c, d, e, f, Unit, Unit, Unit, Unit) { aa, bb, cc, dd, ee, ff, _, _, _, _ -> map(aa, bb, cc, dd, ee, ff) }
+
+    fun <A, B, C, D, E, F, G, H> mapN(
+      a: Eval<A>,
+      b: Eval<B>,
+      c: Eval<C>,
+      d: Eval<D>,
+      e: Eval<E>,
+      f: Eval<F>,
+      g: Eval<G>,
+      map: (A, B, C, D, E, F, G) -> H
+    ): Eval<H> =
+      mapN(a, b, c, d, e, f, g, Unit, Unit, Unit) { aa, bb, cc, dd, ee, ff, gg, _, _, _ -> map(aa, bb, cc, dd, ee, ff, gg) }
+
+    fun <A, B, C, D, E, F, G, H, I> mapN(
+      a: Eval<A>,
+      b: Eval<B>,
+      c: Eval<C>,
+      d: Eval<D>,
+      e: Eval<E>,
+      f: Eval<F>,
+      g: Eval<G>,
+      h: Eval<H>,
+      map: (A, B, C, D, E, F, G, H) -> I
+    ): Eval<I> =
+      mapN(a, b, c, d, e, f, g, h, Unit, Unit) { aa, bb, cc, dd, ee, ff, gg, hh, _, _ -> map(aa, bb, cc, dd, ee, ff, gg, hh) }
+
+    fun <A, B, C, D, E, F, G, H, I, J> mapN(
+      a: Eval<A>,
+      b: Eval<B>,
+      c: Eval<C>,
+      d: Eval<D>,
+      e: Eval<E>,
+      f: Eval<F>,
+      g: Eval<G>,
+      h: Eval<H>,
+      i: Eval<I>,
+      map: (A, B, C, D, E, F, G, H, I) -> J
+    ): Eval<J> =
+      mapN(a, b, c, d, e, f, g, h, i, Unit) { aa, bb, cc, dd, ee, ff, gg, hh, ii, _ -> map(aa, bb, cc, dd, ee, ff, gg, hh, ii) }
+
+    fun <A, B, C, D, E, F, G, H, I, J, K> mapN(
+      a: Eval<A>,
+      b: Eval<B>,
+      c: Eval<C>,
+      d: Eval<D>,
+      e: Eval<E>,
+      f: Eval<F>,
+      g: Eval<G>,
+      h: Eval<H>,
+      i: Eval<I>,
+      j: Eval<J>,
+      map: (A, B, C, D, E, F, G, H, I, J) -> K
+    ): Eval<K> =
+      a.flatMap { aa ->
+        b.flatMap { bb ->
+          c.flatMap { cc ->
+            d.flatMap { dd ->
+              e.flatMap { ee ->
+                f.flatMap { ff ->
+                  g.flatMap { gg ->
+                    h.flatMap { hh ->
+                      i.flatMap { ii ->
+                        j.map { jj ->
+                          map(aa, bb, cc, dd, ee, ff, gg, hh, ii, jj)
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
   }
 
   abstract fun value(): A
@@ -251,14 +395,21 @@ sealed class Eval<out A> : EvalOf<A> {
   inline fun <B> map(crossinline f: (A) -> B): Eval<B> =
     flatMap { a -> Now(f(a)) }
 
+  @Deprecated("Kind is deprecated, and will be removed in 0.13.0. Please use the ap method defined for Eval instead")
   fun <B> ap(ff: EvalOf<(A) -> B>): Eval<B> =
     ff.fix().flatMap { f -> map(f) }.fix()
 
+  fun <B> ap(ff: Eval<(A) -> B>): Eval<B> =
+    ff.flatMap { f -> map(f) }
+
+  @JvmName("flatMapKind")
+  @Deprecated("Kind is deprecated, and will be removed in 0.13.0. Please use the flatMap method defined for Eval instead")
   @Suppress("PARAMETER_NAME_CHANGED_ON_OVERRIDE", "UNCHECKED_CAST")
   inline fun <B> flatMap(crossinline f: (A) -> EvalOf<B>): Eval<B> =
     when (this) {
       is FlatMap<A> -> object : FlatMap<B>() {
         override fun <S> start(): Eval<S> = (this@Eval).start()
+
         @IgnoreJRERequirement
         override fun <S> run(s: S): Eval<B> =
           object : FlatMap<B>() {
@@ -276,9 +427,42 @@ sealed class Eval<out A> : EvalOf<A> {
       }
     }
 
+  @Suppress("PARAMETER_NAME_CHANGED_ON_OVERRIDE", "UNCHECKED_CAST")
+  fun <B> flatMap(f: (A) -> Eval<B>): Eval<B> =
+    when (this) {
+      is FlatMap<A> -> object : FlatMap<B>() {
+        override fun <S> start(): Eval<S> = (this@Eval).start()
+
+        @IgnoreJRERequirement
+        override fun <S> run(s: S): Eval<B> =
+          object : FlatMap<B>() {
+            override fun <S1> start(): Eval<S1> = (this@Eval).run(s) as Eval<S1>
+            override fun <S1> run(s1: S1): Eval<B> = f(s1 as A)
+          }
+      }
+      is Defer<A> -> object : FlatMap<B>() {
+        override fun <S> start(): Eval<S> = this@Eval.thunk() as Eval<S>
+        override fun <S> run(s: S): Eval<B> = f(s as A)
+      }
+      else -> object : FlatMap<B>() {
+        override fun <S> start(): Eval<S> = this@Eval as Eval<S>
+        override fun <S> run(s: S): Eval<B> = f(s as A)
+      }
+    }
+
+  @JvmName("coflatMapKind")
+  @Deprecated("Kind is deprecated, and will be removed in 0.13.0. Please use the coflatMap method defined for Eval instead")
   inline fun <B> coflatMap(crossinline f: (EvalOf<A>) -> B): Eval<B> =
     Later { f(this) }
 
+  inline fun <B> coflatMap(crossinline f: (Eval<A>) -> B): Eval<B> =
+    Later { f(this) }
+
+  @Deprecated(
+    "extract is deprecated in favor of value",
+    ReplaceWith("value()"),
+    DeprecationLevel.WARNING
+  )
   fun extract(): A = value()
 
   /**
@@ -373,7 +557,27 @@ fun <A, B> Iterator<A>.iterateRight(lb: Eval<B>, f: (A, Eval<B>) -> Eval<B>): Ev
 }
 
 fun <A, B, Z> Eval<A>.zip(fb: Eval<B>, f: (A, B) -> Z): Eval<Z> =
-  flatMap { a: A -> fb.map { b -> f(a, b) } }
+  flatMap { a: A -> fb.map { b: B -> f(a, b) } }
 
 fun <A, B> Eval<A>.zip(fb: Eval<B>): Eval<Pair<A, B>> =
-  flatMap { a: A -> fb.map { b -> Pair(a, b) } }
+  flatMap { a: A -> fb.map { b: B -> Pair(a, b) } }
+
+fun <A> Eval<A>.replicate(n: Int): Eval<List<A>> =
+  if (n <= 0) Eval.just(emptyList())
+  else Eval.mapN(this, replicate(n - 1)) { a: A, xs: List<A> -> listOf(a) + xs }
+
+fun <A> Eval<A>.replicate(n: Int, MA: Monoid<A>): Eval<A> = MA.run {
+  if (n <= 0) Eval.just(MA.empty())
+  else Eval.mapN(this@replicate, replicate(n - 1, MA)) { a: A, xs: A -> MA.run { a + xs } }
+}
+
+fun <A, B> Eval<A>.apEval(ff: Eval<Eval<(A) -> B>>): Eval<Eval<B>> = ff.map { this.ap(it) }
+
+fun <A, B, Z> Eval<A>.map2Eval(fb: Eval<Eval<B>>, f: (Tuple2<A, B>) -> Z): Eval<Eval<Z>> =
+  apEval(fb.map { it.map { b: B -> { a: A -> f(Tuple2(a, b)) } } })
+
+fun <A, B> Eval<A>.apTap(fb: Eval<B>): Eval<A> =
+  flatTap { fb }
+
+fun <A, B> Eval<A>.flatTap(f: (A) -> Eval<B>): Eval<A> =
+  flatMap { a -> f(a).map { a } }

arrow-core-data/src/main/kotlin/arrow/typeclasses/Applicative.kt

@@ -18,11 +18,11 @@ interface Applicative<F> : Apply<F> {
 
   fun <A> Kind<F, A>.replicate(n: Int): Kind<F, List<A>> =
     if (n <= 0) just(emptyList())
-    else mapN(this, replicate(n - 1)) { (a, xs) -> listOf(a) + xs }
+    else mapN(this, replicate(n - 1)) { (a: A, xs: List<A>) -> listOf(a) + xs }
 
   fun <A> Kind<F, A>.replicate(n: Int, MA: Monoid<A>): Kind<F, A> =
     if (n <= 0) just(MA.empty())
-    else mapN(this@replicate, replicate(n - 1, MA)) { (a, xs) -> MA.run { a + xs } }
+    else mapN(this@replicate, replicate(n - 1, MA)) { (a: A, xs: A) -> MA.run { a + xs } }
 }
 
 @Deprecated("Applicative typeclass is deprecated")

arrow-core/src/main/kotlin/arrow/core/extensions/EndoMonoid.kt

@@ -3,10 +3,13 @@ package arrow.core.extensions
 import arrow.core.Endo
 import arrow.core.compose
 import arrow.core.identity
-import arrow.extension
 import arrow.typeclasses.Monoid
 
-@extension
+@Deprecated(
+  "Typeclass instance have been moved to the companion object of the typeclass.",
+  ReplaceWith("Monoid.endo<A>()", "arrow.core.endo", "arrow.typeclasses.Monoid"),
+  DeprecationLevel.WARNING
+)
 interface EndoMonoid<A> : Monoid<Endo<A>> {
   override fun empty(): Endo<A> = Endo(::identity)
   override fun Endo<A>.combine(g: Endo<A>): Endo<A> = Endo(f.compose(g.f))

arrow-core/src/main/kotlin/arrow/core/extensions/endo/monoid/EndoMonoid.kt

@@ -3,13 +3,6 @@ package arrow.core.extensions.endo.monoid
 import arrow.core.Endo
 import arrow.core.Endo.Companion
 import arrow.core.extensions.EndoMonoid
-import kotlin.Any
-import kotlin.Deprecated
-import kotlin.PublishedApi
-import kotlin.Suppress
-import kotlin.collections.Collection
-import kotlin.collections.List
-import kotlin.jvm.JvmName
 
 /**
  * cached extension
@@ -27,14 +20,15 @@ internal val monoid_singleton: EndoMonoid<Any?> = object : EndoMonoid<Any?> {}
 @Deprecated(
   "@extension kinded projected functions are deprecated",
   ReplaceWith(
-  "combineAll()",
-  "arrow.core.combineAll"
+    "if (isEmpty()) Endo(::identity) else reduce { a, b -> a.combine(b) }",
+    "arrow.core.combine"
   ),
   DeprecationLevel.WARNING
 )
-fun <A> Collection<Endo<A>>.combineAll(): Endo<A> = arrow.core.Endo.monoid<A>().run {
-  this@combineAll.combineAll() as arrow.core.Endo<A>
-}
+fun <A> Collection<Endo<A>>.combineAll(): Endo<A> =
+  arrow.core.Endo.monoid<A>().run {
+    this@combineAll.combineAll() as arrow.core.Endo<A>
+  }
 
 @JvmName("combineAll")
 @Suppress(
@@ -46,18 +40,23 @@ fun <A> Collection<Endo<A>>.combineAll(): Endo<A> = arrow.core.Endo.monoid<A>().
 @Deprecated(
   "@extension kinded projected functions are deprecated",
   ReplaceWith(
-  "combineAll(arg0)",
-  "arrow.core.Endo.combineAll"
+    "if (arg0.isEmpty()) Endo(::identity) else arg0.reduce { a, b -> a.combine(b) }",
+    "arrow.core.combine"
   ),
   DeprecationLevel.WARNING
 )
-fun <A> combineAll(arg0: List<Endo<A>>): Endo<A> = arrow.core.Endo
-   .monoid<A>()
-   .combineAll(arg0) as arrow.core.Endo<A>
+fun <A> combineAll(arg0: List<Endo<A>>): Endo<A> =
+  arrow.core.Endo
+    .monoid<A>()
+    .combineAll(arg0) as arrow.core.Endo<A>
 
 @Suppress(
   "UNCHECKED_CAST",
   "NOTHING_TO_INLINE"
 )
+@Deprecated(
+  "Extension projections are deprecated. Use endo on Monoid.",
+  ReplaceWith("Monoid.endo()", "arrow.typeclasses.Monoid", "arrow.core.endo")
+)
 inline fun <A> Companion.monoid(): EndoMonoid<A> = monoid_singleton as
-    arrow.core.extensions.EndoMonoid<A>
+  arrow.core.extensions.EndoMonoid<A>