TupleBinder is automatically generated as follows:

trait TupleBinder {

  implicit def tuple1Binder[A](implicit
    a: RowSerializer[A]
  ): Binder[Tuple1[A]] =
    new Binder[Tuple1[A]] {
      def apply(bound: BoundStatement, ver: ProtocolVersion, xs: Tuple1[A]): Result[BoundStatement] =
        (a(bound, 0, xs._1, ver)).map(_ => bound)
    }

  implicit def tuple2Binder[A, B](implicit
    a: RowSerializer[A], b: RowSerializer[B]
  ): Binder[(A, B)] =
    new Binder[(A, B)] {
      def apply(bound: BoundStatement, ver: ProtocolVersion, xs: (A, B)): Result[BoundStatement] =
        (a(bound, 0, xs._1, ver) *> b(bound, 1, xs._2, ver)).map(_ => bound)
    }

  implicit def tuple3Binder[A, B, C](implicit
    a: RowSerializer[A], b: RowSerializer[B], c: RowSerializer[C]
  ): Binder[(A, B, C)] =
    new Binder[(A, B, C)] {
      def apply(bound: BoundStatement, ver: ProtocolVersion, xs: (A, B, C)): Result[BoundStatement] =
        (a(bound, 0, xs._1, ver) *> b(bound, 1, xs._2, ver) *> c(bound, 2, xs._3, ver)).map(_ => bound)
    }

  // ...
}

Even though BoundStatement has been immutable since 4.0, all bind operations are discarded because the passed bound is always returned.

It should provide artifacts for Scala 2.12.

It type conversions are:

• text <=> String
• time uuid <=> UUID
• counter <=> Long

For the implementation of cats-effect module's Task only need Async.async so IO is too strong.

I think that TravisCI has a comparative advantage over Wercker as follows:

• Scala (SBT) native support
• Matrix build for JDK x Scala

Changed default constructor signature of UserType, because updated version to java-driver to 3.2.0.

I want to make to a function with an implicit parameter, rather than Kleisli (or divide implementation?). Because I think that difficult to use with only the Kleisli interface.

We want a solution to test over a real C*. CassandraUnit is a good start point to see. I'm trying to research to determine whether to adopt it or implement an alternative by ourselves.

I noticed you were using Iota and I wanted to give you a heads up for when you update to a more recent version.

frees-io/iota#114 changes the bounds on CopK.Inject. The session code will need to be updated as follows:

    object SessionOps {
-      implicit def sessionOpsForIota[F[_] <: CopK[_, _]](implicit I: CopK.Inject[SessionOp, F]): SessionOps[F] = new SessionOps
+      implicit def sessionOpsForIota[F[A] <: CopK[_, A]](implicit I: CopK.Inject[SessionOp, F]): SessionOps[F] = new SessionOps
    }

Cheers!