yanana / agni Goto Github PK

It should provide artifacts for Scala 2.12.

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.

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

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

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

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!

It type conversions are:

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

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.

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.

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