free

Value Members

object copyin extends CopyInIOInstances

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.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 the doobie.hi package.
CopyInIO is a free monad that must be run via an interpreter, most commonly via natural transformation of its underlying algebra CopyInOp to another monad via Free#foldMap.
The library provides a natural transformation to Kleisli[M, CopyIn, 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: CopyInIO[Foo] = ...

// A JDBC object
val s: CopyIn = ...

// Unfolding into a Task
val ta: Task[A] = a.transK[Task].run(s)
```
object copymanager extends CopyManagerIOInstances

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)
```
object copyout extends CopyOutIOInstances

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)
```
object fastpath extends FastpathIOInstances

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)
```
object largeobject extends LargeObjectIOInstances

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)
```
object largeobjectmanager extends LargeObjectManagerIOInstances

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)
```
object pgconnection extends PGConnectionIOInstances

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)
```

package free

Value Members

object copyin extends CopyInIOInstances

object copymanager extends CopyManagerIOInstances

object copyout extends CopyOutIOInstances

object fastpath extends FastpathIOInstances

object largeobject extends LargeObjectIOInstances

object largeobjectmanager extends LargeObjectManagerIOInstances

object pgconnection extends PGConnectionIOInstances

Modules