Transactor

abstract def connect: (A) ⇒ M[Connection]

A program in M that can provide a database connection, given the kernel *

abstract def interpret: Interpreter[M]

A natural transformation for interpreting ConnectionIO *

abstract def kernel: A

An arbitrary value, meaningful to the instance *

abstract def strategy: Strategy

A Strategy for running a program on a connection *

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def configure[B](f: (A) ⇒ B)(implicit ev: Suspendable[M]): M[B]

Construct a program to peform arbitrary configuration on the kernel value (changing the timeout on a connection pool, for example).

def copy(kernel0: A = self.kernel, connect0: (A) ⇒ M[Connection] = self.connect, interpret0: Interpreter[M] = self.interpret, strategy0: Strategy = self.strategy): Aux[M, A]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def exec(implicit ev: Monad[M], ev2: Catchable[M]): ~>[[γ$11$]Kleisli[M, Connection, γ$11$], M]

Natural transformation that provides a connection and binds through a Kleisli program using the given Strategy, yielding an independent program in M.

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def rawExec(implicit ev: Monad[M]): ~>[[γ$8$]Kleisli[M, Connection, γ$8$], M]

Natural transformation equivalent to exec that does not use the provided Strategy and instead directly binds the Connection provided by connect.

def rawTrans(implicit ev: Monad[M]): ~>[ConnectionIO, M]

Natural transformation equivalent to trans that does not use the provided Strategy and instead directly binds the Connection provided by connect.

def rawTransP(implicit ev: Monad[M]): ~>[[β$13$]Stream[[A]Free[ConnectionOp, A], β$13$], [β$14$]Stream[M, β$14$]]

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

def trans(implicit ev: Monad[M]): ~>[ConnectionIO, M]

Natural transformation that provides a connection and binds through a ConnectionIO program interpreted via the given interpreter, using the given Strategy, yielding an independent program in M.

def transP(implicit ev: Monad[M]): ~>[[β$20$]Stream[[A]Free[ConnectionOp, A], β$20$], [β$21$]Stream[M, β$21$]]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def yolo(implicit ev: Monad[M], ev1: Catchable[M], ev2: Suspendable[M]): Yolo[M]

Construct a Yolo for REPL experimentation.