Added zipWithLongIndex, mapWithLongIndex and traverseWithLongIndexM

[nikololiahim]

Implements #4245.

[armanbilge]

Nice work!! We should also add some laws similar to these.

cats/laws/src/main/scala/cats/laws/TraverseLaws.scala

Lines 115 to 131 in 9839b74

	def mapWithIndexRef[A, B](fa: F[A], f: (A, Int) => B): IsEq[F[B]] = {
	val lhs = F.mapWithIndex(fa)(f)
	val rhs = F.traverse(fa)(a => State((s: Int) => (s + 1, f(a, s)))).runA(0).value
	lhs <-> rhs
	}
	def traverseWithIndexMRef[G[_], A, B](fa: F[A], f: (A, Int) => G[B])(implicit G: Monad[G]): IsEq[G[F[B]]] = {
	val lhs = F.traverseWithIndexM(fa)(f)
	val rhs = F.traverse(fa)(a => StateT((s: Int) => G.map(f(a, s))(b => (s + 1, b)))).runA(0)
	lhs <-> rhs
	}
	def zipWithIndexRef[A, B](fa: F[A], f: ((A, Int)) => B): IsEq[F[B]] = {
	val lhs = F.map(F.zipWithIndex(fa))(f)
	val rhs = F.map(F.mapWithIndex(fa)((a, i) => (a, i)))(f)
	lhs <-> rhs
	}

---

#4246 seems related, so I might as well close it here.

Great, but it is a bit more involved so I think a second PR based on this one would be the way to do it :)

[armanbilge]

The other thing probably worth doing is adding a method like this one:

cats/core/src/main/scala/cats/instances/StaticMethods.scala

Lines 51 to 61 in 9839b74

	def mapWithIndexFromStrictFunctor[F[_], A, B](fa: F[A], f: (A, Int) => B)(implicit ev: Functor[F]): F[B] = {
	var idx = 0
	ev.map(fa) { a =>
	val b = f(a, idx)
	idx += 1
	b
	}
	}

And using it to add a higher-performant override for these instances:
https://github.com/typelevel/cats/search?q=mapWithIndexFromStrictFunctor

[nikololiahim]

@armanbilge tried to address the reviews in c1f9ed6

[johnynek]

Doesn't seem like this should require Monad.

I think I see why this implementation does (I think due to using State).

[armanbilge]

@johnynek the scaladoc for the Int version explains:

  /**
   * Akin to [[traverse]], but also provides the value's index in
   * structure F when calling the function.
   *
   * This performs the traversal in a single pass but requires that
   * effect G is monadic. An applicative traversal can be performed in
   * two passes using [[zipWithIndex]] followed by [[traverse]].
   */

[armanbilge]

Thanks for adding this! The next step is to use it to provide overrides of mapWithLongIndex in all the same places that the Int-version is used.
https://github.com/typelevel/cats/search?q=mapWithIndexFromStrictFunctor

[nikololiahim]

Should be done in 6fe035f. I don't know if I should update the tests too, or these implementations are used automatically somehow.

[armanbilge]

Not entirely sure of the question :) Actually, the behavior of the implementations should be completely identical, and the tests should be verifying that. Nothing "automatic" going on AFAIK :)

[armanbilge]

LGTM! Thanks for picking this up :)