Package

doobie

free

Permalink

package free

Free algebras for computations over JDBC objects. Note that all modules in this package other than drivermanager are generated as part of the build.

Source
package.scala
Linear Supertypes
AnyRef, Any
Ordering
  1. Grouped
  2. Alphabetic
  3. By inheritance
Inherited
  1. free
  2. AnyRef
  3. Any
  1. Hide All
  2. Show all
Visibility
  1. Public
  2. All

Value Members

  1. object blob

    Permalink

    Algebra and free monad for primitive operations over a java.sql.Blob.

    Algebra and free monad for primitive operations over a java.sql.Blob. This is a low-level API that exposes lifecycle-managed JDBC objects directly and is intended mainly for library developers. End users will prefer a safer, higher-level API such as that provided in the doobie.hi package.

    BlobIO is a free monad that must be run via an interpreter, most commonly via natural transformation of its underlying algebra BlobOp to another monad via Free.runFC.

    The library provides a natural transformation to Kleisli[M, Blob, A] for any exception-trapping (Catchable) and effect-capturing (Capture) monad M. Such evidence is provided for Task, IO, and stdlib Future; and transK[M] is provided as syntax.

    // An action to run
    val a: BlobIO[Foo] = ...
    
    // A JDBC object
    val s: Blob = ...
    
    // Unfolding into a Task
    val ta: Task[A] = a.transK[Task].run(s)
  2. object callablestatement

    Permalink

    Algebra and free monad for primitive operations over a java.sql.CallableStatement.

    Algebra and free monad for primitive operations over a java.sql.CallableStatement. This is a low-level API that exposes lifecycle-managed JDBC objects directly and is intended mainly for library developers. End users will prefer a safer, higher-level API such as that provided in the doobie.hi package.

    CallableStatementIO is a free monad that must be run via an interpreter, most commonly via natural transformation of its underlying algebra CallableStatementOp to another monad via Free.runFC.

    The library provides a natural transformation to Kleisli[M, CallableStatement, A] for any exception-trapping (Catchable) and effect-capturing (Capture) monad M. Such evidence is provided for Task, IO, and stdlib Future; and transK[M] is provided as syntax.

    // An action to run
    val a: CallableStatementIO[Foo] = ...
    
    // A JDBC object
    val s: CallableStatement = ...
    
    // Unfolding into a Task
    val ta: Task[A] = a.transK[Task].run(s)
  3. object clob

    Permalink

    Algebra and free monad for primitive operations over a java.sql.Clob.

    Algebra and free monad for primitive operations over a java.sql.Clob. This is a low-level API that exposes lifecycle-managed JDBC objects directly and is intended mainly for library developers. End users will prefer a safer, higher-level API such as that provided in the doobie.hi package.

    ClobIO is a free monad that must be run via an interpreter, most commonly via natural transformation of its underlying algebra ClobOp to another monad via Free.runFC.

    The library provides a natural transformation to Kleisli[M, Clob, A] for any exception-trapping (Catchable) and effect-capturing (Capture) monad M. Such evidence is provided for Task, IO, and stdlib Future; and transK[M] is provided as syntax.

    // An action to run
    val a: ClobIO[Foo] = ...
    
    // A JDBC object
    val s: Clob = ...
    
    // Unfolding into a Task
    val ta: Task[A] = a.transK[Task].run(s)
  4. object connection

    Permalink

    Algebra and free monad for primitive operations over a java.sql.Connection.

    Algebra and free monad for primitive operations over a java.sql.Connection. This is a low-level API that exposes lifecycle-managed JDBC objects directly and is intended mainly for library developers. End users will prefer a safer, higher-level API such as that provided in the doobie.hi package.

    ConnectionIO is a free monad that must be run via an interpreter, most commonly via natural transformation of its underlying algebra ConnectionOp to another monad via Free.runFC.

    The library provides a natural transformation to Kleisli[M, Connection, A] for any exception-trapping (Catchable) and effect-capturing (Capture) monad M. Such evidence is provided for Task, IO, and stdlib Future; and transK[M] is provided as syntax.

    // An action to run
    val a: ConnectionIO[Foo] = ...
    
    // A JDBC object
    val s: Connection = ...
    
    // Unfolding into a Task
    val ta: Task[A] = a.transK[Task].run(s)
  5. object databasemetadata

    Permalink

    Algebra and free monad for primitive operations over a java.sql.DatabaseMetaData.

    Algebra and free monad for primitive operations over a java.sql.DatabaseMetaData. This is a low-level API that exposes lifecycle-managed JDBC objects directly and is intended mainly for library developers. End users will prefer a safer, higher-level API such as that provided in the doobie.hi package.

    DatabaseMetaDataIO is a free monad that must be run via an interpreter, most commonly via natural transformation of its underlying algebra DatabaseMetaDataOp to another monad via Free.runFC.

    The library provides a natural transformation to Kleisli[M, DatabaseMetaData, A] for any exception-trapping (Catchable) and effect-capturing (Capture) monad M. Such evidence is provided for Task, IO, and stdlib Future; and transK[M] is provided as syntax.

    // An action to run
    val a: DatabaseMetaDataIO[Foo] = ...
    
    // A JDBC object
    val s: DatabaseMetaData = ...
    
    // Unfolding into a Task
    val ta: Task[A] = a.transK[Task].run(s)
  6. object driver

    Permalink

    Algebra and free monad for primitive operations over a java.sql.Driver.

    Algebra and free monad for primitive operations over a java.sql.Driver. This is a low-level API that exposes lifecycle-managed JDBC objects directly and is intended mainly for library developers. End users will prefer a safer, higher-level API such as that provided in the doobie.hi package.

    DriverIO is a free monad that must be run via an interpreter, most commonly via natural transformation of its underlying algebra DriverOp to another monad via Free.runFC.

    The library provides a natural transformation to Kleisli[M, Driver, A] for any exception-trapping (Catchable) and effect-capturing (Capture) monad M. Such evidence is provided for Task, IO, and stdlib Future; and transK[M] is provided as syntax.

    // An action to run
    val a: DriverIO[Foo] = ...
    
    // A JDBC object
    val s: Driver = ...
    
    // Unfolding into a Task
    val ta: Task[A] = a.transK[Task].run(s)
  7. object drivermanager

    Permalink
  8. object nclob

    Permalink

    Algebra and free monad for primitive operations over a java.sql.NClob.

    Algebra and free monad for primitive operations over a java.sql.NClob. This is a low-level API that exposes lifecycle-managed JDBC objects directly and is intended mainly for library developers. End users will prefer a safer, higher-level API such as that provided in the doobie.hi package.

    NClobIO is a free monad that must be run via an interpreter, most commonly via natural transformation of its underlying algebra NClobOp to another monad via Free.runFC.

    The library provides a natural transformation to Kleisli[M, NClob, A] for any exception-trapping (Catchable) and effect-capturing (Capture) monad M. Such evidence is provided for Task, IO, and stdlib Future; and transK[M] is provided as syntax.

    // An action to run
    val a: NClobIO[Foo] = ...
    
    // A JDBC object
    val s: NClob = ...
    
    // Unfolding into a Task
    val ta: Task[A] = a.transK[Task].run(s)
  9. object preparedstatement

    Permalink

    Algebra and free monad for primitive operations over a java.sql.PreparedStatement.

    Algebra and free monad for primitive operations over a java.sql.PreparedStatement. This is a low-level API that exposes lifecycle-managed JDBC objects directly and is intended mainly for library developers. End users will prefer a safer, higher-level API such as that provided in the doobie.hi package.

    PreparedStatementIO is a free monad that must be run via an interpreter, most commonly via natural transformation of its underlying algebra PreparedStatementOp to another monad via Free.runFC.

    The library provides a natural transformation to Kleisli[M, PreparedStatement, A] for any exception-trapping (Catchable) and effect-capturing (Capture) monad M. Such evidence is provided for Task, IO, and stdlib Future; and transK[M] is provided as syntax.

    // An action to run
    val a: PreparedStatementIO[Foo] = ...
    
    // A JDBC object
    val s: PreparedStatement = ...
    
    // Unfolding into a Task
    val ta: Task[A] = a.transK[Task].run(s)
  10. object ref

    Permalink

    Algebra and free monad for primitive operations over a java.sql.Ref.

    Algebra and free monad for primitive operations over a java.sql.Ref. This is a low-level API that exposes lifecycle-managed JDBC objects directly and is intended mainly for library developers. End users will prefer a safer, higher-level API such as that provided in the doobie.hi package.

    RefIO is a free monad that must be run via an interpreter, most commonly via natural transformation of its underlying algebra RefOp to another monad via Free.runFC.

    The library provides a natural transformation to Kleisli[M, Ref, A] for any exception-trapping (Catchable) and effect-capturing (Capture) monad M. Such evidence is provided for Task, IO, and stdlib Future; and transK[M] is provided as syntax.

    // An action to run
    val a: RefIO[Foo] = ...
    
    // A JDBC object
    val s: Ref = ...
    
    // Unfolding into a Task
    val ta: Task[A] = a.transK[Task].run(s)
  11. object resultset

    Permalink

    Algebra and free monad for primitive operations over a java.sql.ResultSet.

    Algebra and free monad for primitive operations over a java.sql.ResultSet. This is a low-level API that exposes lifecycle-managed JDBC objects directly and is intended mainly for library developers. End users will prefer a safer, higher-level API such as that provided in the doobie.hi package.

    ResultSetIO is a free monad that must be run via an interpreter, most commonly via natural transformation of its underlying algebra ResultSetOp to another monad via Free.runFC.

    The library provides a natural transformation to Kleisli[M, ResultSet, A] for any exception-trapping (Catchable) and effect-capturing (Capture) monad M. Such evidence is provided for Task, IO, and stdlib Future; and transK[M] is provided as syntax.

    // An action to run
    val a: ResultSetIO[Foo] = ...
    
    // A JDBC object
    val s: ResultSet = ...
    
    // Unfolding into a Task
    val ta: Task[A] = a.transK[Task].run(s)
  12. object sqldata

    Permalink

    Algebra and free monad for primitive operations over a java.sql.SQLData.

    Algebra and free monad for primitive operations over a java.sql.SQLData. This is a low-level API that exposes lifecycle-managed JDBC objects directly and is intended mainly for library developers. End users will prefer a safer, higher-level API such as that provided in the doobie.hi package.

    SQLDataIO is a free monad that must be run via an interpreter, most commonly via natural transformation of its underlying algebra SQLDataOp to another monad via Free.runFC.

    The library provides a natural transformation to Kleisli[M, SQLData, A] for any exception-trapping (Catchable) and effect-capturing (Capture) monad M. Such evidence is provided for Task, IO, and stdlib Future; and transK[M] is provided as syntax.

    // An action to run
    val a: SQLDataIO[Foo] = ...
    
    // A JDBC object
    val s: SQLData = ...
    
    // Unfolding into a Task
    val ta: Task[A] = a.transK[Task].run(s)
  13. object sqlinput

    Permalink

    Algebra and free monad for primitive operations over a java.sql.SQLInput.

    Algebra and free monad for primitive operations over a java.sql.SQLInput. This is a low-level API that exposes lifecycle-managed JDBC objects directly and is intended mainly for library developers. End users will prefer a safer, higher-level API such as that provided in the doobie.hi package.

    SQLInputIO is a free monad that must be run via an interpreter, most commonly via natural transformation of its underlying algebra SQLInputOp to another monad via Free.runFC.

    The library provides a natural transformation to Kleisli[M, SQLInput, A] for any exception-trapping (Catchable) and effect-capturing (Capture) monad M. Such evidence is provided for Task, IO, and stdlib Future; and transK[M] is provided as syntax.

    // An action to run
    val a: SQLInputIO[Foo] = ...
    
    // A JDBC object
    val s: SQLInput = ...
    
    // Unfolding into a Task
    val ta: Task[A] = a.transK[Task].run(s)
  14. object sqloutput

    Permalink

    Algebra and free monad for primitive operations over a java.sql.SQLOutput.

    Algebra and free monad for primitive operations over a java.sql.SQLOutput. This is a low-level API that exposes lifecycle-managed JDBC objects directly and is intended mainly for library developers. End users will prefer a safer, higher-level API such as that provided in the doobie.hi package.

    SQLOutputIO is a free monad that must be run via an interpreter, most commonly via natural transformation of its underlying algebra SQLOutputOp to another monad via Free.runFC.

    The library provides a natural transformation to Kleisli[M, SQLOutput, A] for any exception-trapping (Catchable) and effect-capturing (Capture) monad M. Such evidence is provided for Task, IO, and stdlib Future; and transK[M] is provided as syntax.

    // An action to run
    val a: SQLOutputIO[Foo] = ...
    
    // A JDBC object
    val s: SQLOutput = ...
    
    // Unfolding into a Task
    val ta: Task[A] = a.transK[Task].run(s)
  15. object statement

    Permalink

    Algebra and free monad for primitive operations over a java.sql.Statement.

    Algebra and free monad for primitive operations over a java.sql.Statement. This is a low-level API that exposes lifecycle-managed JDBC objects directly and is intended mainly for library developers. End users will prefer a safer, higher-level API such as that provided in the doobie.hi package.

    StatementIO is a free monad that must be run via an interpreter, most commonly via natural transformation of its underlying algebra StatementOp to another monad via Free.runFC.

    The library provides a natural transformation to Kleisli[M, Statement, A] for any exception-trapping (Catchable) and effect-capturing (Capture) monad M. Such evidence is provided for Task, IO, and stdlib Future; and transK[M] is provided as syntax.

    // An action to run
    val a: StatementIO[Foo] = ...
    
    // A JDBC object
    val s: Statement = ...
    
    // Unfolding into a Task
    val ta: Task[A] = a.transK[Task].run(s)

Inherited from AnyRef

Inherited from Any

Modules

Ungrouped