Additional methods for Bitraverse

[asoltysik]

What do you think about adding any/all of the following functions to Bitraverse? IMHO leftTraverse and leftSequence would be most useful.

def leftTraverse[G[_]: Applicative, A, B, C](fab: F[A, B])(f: A => G[C]): G[F[C, B]] =
  bitraverse(fab)(f, Applicative[G].pure _)

def leftSequence[G[_]: Applicative, A, B](fab: F[G[A], B]): G[F[A, B]] = 
  leftTraverse(fab)(identity)

def biflatTraverse[G[_]: Applicative, A, B, C, D](fab: F[A, B])(f: A => G[F[C]], g: B => G[F[D]])(implicit F: FlatMap[F]): G[F[C, D]] = 
  Applicative[G].bimap(traverse(fab)(f, g))(F.flatten, F.flatten)

def leftFlatTraverse[G[_]: Applicative, A, B, C](fab: F[A, B])(f: A => G[F[C]])(implicit F: FlatMap[F]): G[F[C, B]] = 
  biflatTraverse(fab)(f, identity)

The code above is only a draft, might not compile.

[sideeffffect]

Has biflatTraverse ever been delivered? I'm only able to google this issue and https://gitter.im/typelevel/cats?at=5c78f72f65ffa019ea6b6ae4
Are TypeLevel maintainers open for contribution of biflatTraverse?

[LukaJCB]

Yeah seems like a good addition to me 👍

[sideeffffect]

I've looked into it briefly and biflatTraverse doesn't seem to be trivially implementable. Just as flatTraverse needs FlatMap[F]

def flatTraverse[G[_], A, B](fa: F[A])(f: A => G[F[B]])(implicit G: Applicative[G], F: FlatMap[F]): G[F[B]]

we would need a totally new BiFlatMap[F] for biflatTraverse to flatten F[F[C, D], F[C, D]] to mere F[C, D].

def biflatTraverse[G[_], A, B, C, D](
    fa: F[A, B]
  )(f: A => G[F[C, D]], g: B => G[F[C, D]])(implicit G: Applicative[G], F: BiflatMap[F]): G[F[C, D]] =
    G.map(bitraverse(fa)(f, g))(F.biflatten)
...

trait BiflatMap[F[_, _]] extends Bifunctor[F] {
  def biflatten[A, B](ffa: F[F[A, B], F[A, B]]): F[A, B]
}

Would you accept a PR with BiflatMap? Seems a bit ad hoc to me, I'm not sure how many usages it would have...