Packages

  • package root
    Definition Classes
    root
  • package doobie

    Top-level import, providing aliases for the most commonly used types and modules from doobie-free and doobie-core.

    Top-level import, providing aliases for the most commonly used types and modules from doobie-free and doobie-core. A typical starting set of imports would be something like this.

    import cats.implicits._
import doobie._, doobie.implicits._
    Definition Classes
    root
    See also

    The doobie microsite for much more information.

  • package util

    Collection of modules for typeclasses and other helpful bits.

    Collection of modules for typeclasses and other helpful bits.

    Definition Classes
    doobie
  • object transactor
    Definition Classes
    util
  • Strategy
  • Transactor

sealed abstract class Transactor[M[_]] extends AnyRef

A thin wrapper around a source of database connections, an interpreter, and a strategy for running programs, parameterized over a target monad M and an arbitrary wrapped value A. Given a stream or program in ConnectionIO or a program in Kleisli, a Transactor can discharge the doobie machinery and yield an effectful stream or program in M.

M

a target effect type; typically IO

Self Type
Transactor[M]
Source
transactor.scala
Linear Supertypes
AnyRef, Any
Ordering
  1. Grouped
  2. Alphabetic
  3. By Inheritance
Inherited
  1. Transactor
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. abstract type A

    An arbitrary value that will be handed back to connect *

Abstract Value Members

  1. abstract def connect: (A) ⇒ Resource[M, Connection]

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

  2. abstract def interpret: Interpreter[M]

    A natural transformation for interpreting ConnectionIO *

  3. abstract def kernel: A

    An arbitrary value, meaningful to the instance *

  4. abstract def strategy: Strategy

    A Strategy for running a program on a connection *

Concrete Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  5. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @native() @throws( ... )
  6. def configure[B](f: (A) ⇒ M[B]): M[B]

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

    Construct a program to perform arbitrary configuration on the kernel value (changing the timeout on a connection pool, for example). This can be the basis for constructing a configuration language for a specific kernel type A, whose operations can be added to compatible Transactors via implicit conversion.

  7. def copy(kernel0: A = self.kernel, connect0: (A) ⇒ Resource[M, Connection] = self.connect, interpret0: Interpreter[M] = self.interpret, strategy0: Strategy = self.strategy): Aux[M, A]
    Annotations
    @SuppressWarnings()
  8. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  9. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  10. def exec(implicit ev: Bracket[M, Throwable], D: Defer[M]): ~>[[γ$4$]Kleisli[M, Connection, γ$4$], M]

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

  11. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  12. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  13. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  14. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  15. def mapK[M0[_]](fk: ~>[M, M0])(implicit B: Bracket[M, Throwable], D: Defer[M0], A: Applicative[M0]): Aux[M0, A]
  16. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  17. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  18. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  19. def rawExec(implicit ev: Bracket[M, Throwable]): ~>[[γ$1$]Kleisli[M, Connection, γ$1$], M]

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

    Natural transformation equivalent to exec that does not use the provided Strategy and instead directly binds the Connection provided by connect. This can be useful in cases where transactional handling is unsupported or undesired.

  20. def rawTrans(implicit ev: Bracket[M, Throwable]): ~>[free.connection.ConnectionIO, M]

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

    Natural transformation equivalent to trans that does not use the provided Strategy and instead directly binds the Connection provided by connect. This can be useful in cases where transactional handling is unsupported or undesired.

  21. def rawTransP[T](implicit ev: Monad[M]): ~>[[β$9$]Stream[[A]Free[ConnectionOp, A], β$9$], [β$10$]Stream[M, β$10$]]
  22. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  23. def toString(): String
    Definition Classes
    AnyRef → Any
  24. def trans(implicit ev: Bracket[M, Throwable]): ~>[free.connection.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.

    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. This is the most common way to run a doobie program.

  25. def transP(implicit ev: Monad[M]): ~>[[β$14$]Stream[[A]Free[ConnectionOp, A], β$14$], [β$15$]Stream[M, β$15$]]
  26. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  27. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  28. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @throws( ... )
  29. def yolo(implicit ev1: Sync[M]): Yolo[M]

    Construct a Yolo for REPL experimentation.

Inherited from AnyRef

Inherited from Any

Configuration

Natural Transformations

Ungrouped