free
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
Free algebras for computations over JDBC objects. Note that all modules in this package other than
drivermanagerare generated as part of the build.