Algebra and free monad for primitive operations over a org.postgresql.copy.CopyIn
.
Algebra and free monad for primitive operations over a org.postgresql.copy.CopyManager
.
Algebra and free monad for primitive operations over a org.postgresql.copy.CopyManager
. 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.
CopyManagerIO
is a free monad that must be run via an interpreter, most commonly via
natural transformation of its underlying algebra CopyManagerOp
to another monad via
Free#foldMap
.
The library provides a natural transformation to Kleisli[M, CopyManager, 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: CopyManagerIO[Foo] = ... // A JDBC object val s: CopyManager = ... // Unfolding into a Task val ta: Task[A] = a.transK[Task].run(s)
Algebra and free monad for primitive operations over a org.postgresql.copy.CopyOut
.
Algebra and free monad for primitive operations over a org.postgresql.copy.CopyOut
. 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.
CopyOutIO
is a free monad that must be run via an interpreter, most commonly via
natural transformation of its underlying algebra CopyOutOp
to another monad via
Free#foldMap
.
The library provides a natural transformation to Kleisli[M, CopyOut, 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: CopyOutIO[Foo] = ... // A JDBC object val s: CopyOut = ... // Unfolding into a Task val ta: Task[A] = a.transK[Task].run(s)
Algebra and free monad for primitive operations over a org.postgresql.fastpath.Fastpath
.
Algebra and free monad for primitive operations over a org.postgresql.fastpath.Fastpath
. 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.
FastpathIO
is a free monad that must be run via an interpreter, most commonly via
natural transformation of its underlying algebra FastpathOp
to another monad via
Free#foldMap
.
The library provides a natural transformation to Kleisli[M, Fastpath, 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: FastpathIO[Foo] = ... // A JDBC object val s: Fastpath = ... // Unfolding into a Task val ta: Task[A] = a.transK[Task].run(s)
Algebra and free monad for primitive operations over a org.postgresql.largeobject.LargeObject
.
Algebra and free monad for primitive operations over a org.postgresql.largeobject.LargeObject
. 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.
LargeObjectIO
is a free monad that must be run via an interpreter, most commonly via
natural transformation of its underlying algebra LargeObjectOp
to another monad via
Free#foldMap
.
The library provides a natural transformation to Kleisli[M, LargeObject, 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: LargeObjectIO[Foo] = ... // A JDBC object val s: LargeObject = ... // Unfolding into a Task val ta: Task[A] = a.transK[Task].run(s)
Algebra and free monad for primitive operations over a org.postgresql.largeobject.LargeObjectManager
.
Algebra and free monad for primitive operations over a org.postgresql.largeobject.LargeObjectManager
. 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.
LargeObjectManagerIO
is a free monad that must be run via an interpreter, most commonly via
natural transformation of its underlying algebra LargeObjectManagerOp
to another monad via
Free#foldMap
.
The library provides a natural transformation to Kleisli[M, LargeObjectManager, 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: LargeObjectManagerIO[Foo] = ... // A JDBC object val s: LargeObjectManager = ... // Unfolding into a Task val ta: Task[A] = a.transK[Task].run(s)
Algebra and free monad for primitive operations over a org.postgresql.PGConnection
.
Algebra and free monad for primitive operations over a org.postgresql.PGConnection
. 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.postgres.hi
package.
PGConnectionIO
is a free monad that must be run via an interpreter, most commonly via
natural transformation of its underlying algebra PGConnectionOp
to another monad via
Free#foldMap
.
The library provides a natural transformation to Kleisli[M, PGConnection, 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: PGConnectionIO[Foo] = ... // A JDBC object val s: PGConnection = ... // Unfolding into a Task val ta: Task[A] = a.transK[Task].run(s)
Algebra and free monad for primitive operations over a
org.postgresql.copy.CopyIn
. 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 thedoobie.hi
package.CopyInIO
is a free monad that must be run via an interpreter, most commonly via natural transformation of its underlying algebraCopyInOp
to another monad viaFree#foldMap
.The library provides a natural transformation to
Kleisli[M, CopyIn, A]
for any exception-trapping (Catchable
) and effect-capturing (Capture
) monadM
. Such evidence is provided forTask
,IO
, and stdlibFuture
; andtransK[M]
is provided as syntax.