Add syntax for Bitraverse to allow traversal and sequencing of the left side

core/src/main/scala/cats/syntax/all.scala

@@ -84,3 +84,4 @@ trait AllSyntaxBinCompat4
     with ParallelApplySyntax
     with FoldableSyntaxBinCompat0
     with ReducibleSyntaxBinCompat0
+    with BitraverseSyntaxBinCompat0

core/src/main/scala/cats/syntax/bitraverse.scala

@@ -22,3 +22,24 @@ final class NestedBitraverseOps[F[_, _], G[_], A, B](private val fgagb: F[G[A],
   def bisequence(implicit F: Bitraverse[F], G: Applicative[G]): G[F[A, B]] =
     F.bisequence(fgagb)
 }
+
+trait BitraverseSyntaxBinCompat0 {
+  implicit final def catsSyntaxBitraverseBinCompat0[F[_, _]: Bitraverse, A, B](
+    fab: F[A, B]
+  ): BitraverseOpsBinCompat0[F, A, B] =
+    new BitraverseOpsBinCompat0[F, A, B](fab)
+  implicit final def catsSyntaxLeftNestedBitraverse[F[_, _]: Bitraverse, G[_], A, B](
+    fgab: F[G[A], B]
+  ): LeftNestedBitraverseOps[F, G, A, B] =
+    new LeftNestedBitraverseOps[F, G, A, B](fgab)
+}
+
+final class BitraverseOpsBinCompat0[F[_, _], A, B](val fab: F[A, B]) extends AnyVal {
+  def leftTraverse[G[_], C](f: A => G[C])(implicit F: Bitraverse[F], G: Applicative[G]): G[F[C, B]] =
+    F.bitraverse(fab)(f, G.pure(_))
+}
+
+final class LeftNestedBitraverseOps[F[_, _], G[_], A, B](val fgab: F[G[A], B]) extends AnyVal {
+  def leftSequence(implicit F: Bitraverse[F], G: Applicative[G]): G[F[A, B]] =
+    F.bitraverse(fgab)(identity, G.pure(_))
+}

core/src/main/scala/cats/syntax/package.scala

@@ -11,7 +11,7 @@ package object syntax {
   object bifunctor extends BifunctorSyntax
   object bifoldable extends BifoldableSyntax
   object binested extends BinestedSyntax
-  object bitraverse extends BitraverseSyntax
+  object bitraverse extends BitraverseSyntax with BitraverseSyntaxBinCompat0
   @deprecated("use cats.syntax.semigroupal instead", "1.0.0-RC1")
   object cartesian extends SemigroupalSyntax
   object choice extends ChoiceSyntax

tests/src/test/scala/cats/tests/SyntaxSuite.scala

@@ -307,9 +307,13 @@ object SyntaxSuite
 
     val fab = mock[F[A, B]]
     val gfcd = fab.bitraverse(f, g)
+    val gfcb = fab.leftTraverse(f)
 
     val fgagb = mock[F[G[A], G[B]]]
     val gfab = fgagb.bisequence
+
+    val fgab = mock[F[G[A], B]]
+    val gfab2 = fgab.leftSequence
   }
 
   def testAlternativeMonad[F[_]: Alternative: Monad, G[_]: Foldable, H[_, _]: Bifoldable, A, B]: Unit = {