Add Endo type alias for (A =>A)

[kailuowang]

Endo is necessary when I found that List[A => A]().foldK doesn't work, it has to use an Endo type alias
the main use case is

scala> import cats.implicits._, cats.Endo
scala> val l: List[Endo[Int]] = List(_ * 2, _ + 3)
scala> val f = l.reduceRightK //using `compose` to chain the functions
scala> f(1)
res0: Int = 5

Update: to further clarify, using reduceRightK, the functions inside the list is applied from left to right. If we use the existing foldK the functions inside the list would be applied from right to left which gives a final result of 8.

further Update: reduceRightK is removed. This PR is only about adding Endo

[codecov-io]

Codecov Report

Merging #2076 into master will not change coverage.
The diff coverage is n/a.

@@           Coverage Diff           @@
##           master    #2076   +/-   ##
=======================================
  Coverage   94.66%   94.66%           
=======================================
  Files         318      318           
  Lines        5383     5383           
  Branches      207      207           
=======================================
  Hits         5096     5096           
  Misses        287      287

Impacted Files	Coverage Δ
core/src/main/scala/cats/package.scala	100% <ø> (ø)	⬆️
core/src/main/scala/cats/instances/function.scala	92.3% <ø> (ø)	⬆️
core/src/main/scala/cats/MonoidK.scala	80% <0%> (ø)	⬆️
core/src/main/scala/cats/SemigroupK.scala	100% <0%> (ø)	⬆️

---

Continue to review full report at Codecov.

Legend - Click here to learn more
Δ = absolute <relative> (impact), ø = not affected, ? = missing data
Powered by Codecov. Last update 084b984...828be44. Read the comment docs.

[johnynek]

seems like combineAllK to me.

[kailuowang]

combineAllK is foldK right? This one combines in the opposite direction

[johnynek]

I see. I misunderstood.

I am very -1 on this unless I am mistaken. reduceRight(Option) is right associative, but does not reverse the effective order that we iterate through. This method does by swapping.

I would call this reverseCombineAllK.

Since the MonoidK is associative, the result is the same if you right associate or left associate (though there may be efficiency reasons to pick one). This is something else: it is like making a new Monoid that has the property that combine(a, b) == original.combine(b, a)

This is actually still a monoid, but it behaves differently for non-commutative cases.

@kailuowang can you explain if I am wrong about this being different from reduceRight?

[kailuowang]

You are right it's different from reduceRight(Option). reverseCombineAllK is probably a better name, but you also got to the bottom of it, we don't need it, we just need a different Monoid instance that does the original.combine(b, a). Maybe adding a reverse method to Monoid and MonoidK. But I am not sure are they worthwhile to be added?

What about the Endo type alias?

[ceedubs]

An Endo alias seems reasonable to me. I do also find myself wondering if there a more general solution to this problem. I tried out a couple of things locally but didn't have much luck.

[kailuowang]

merge with 2 sign-off.