Documentation

A function that retrieves an entity from a database. The function takes entity id as parameter. If an entity with the given id exists in the database, it is returned as a Just value. If no such entity exists, Nothing is returned. An error is thrown if there are more than one entity with the given id.

This function retrieves all entities of type a from a database. The function takes an HDBC connection as parameter. The type a is determined by the context of the function call.

A function that persists an entity to a database. The function takes an HDBC connection and an entity as parameters. The entity is either inserted or updated, depending on whether it already exists in the database. The required SQL statements are generated dynamically using Haskell generics and reflection

A function that explicitely inserts an entity into a database.

A function that explicitely updates an entity in a database.

set up a table for a given entity type. The table is dropped and recreated.

A function that returns the primary key value of an entity as a SqlValue.

A convenience function: returns the name of the column for a field of a type a.

A convenience function: returns the TypeRep of a field of a type a.

Returns a string representation of a value of type a.

A convenience function: returns an evidence instance of type a. This is useful for type inference where no instance is available.

The resolution cache maps an EntityId to a Dynamic value (representing an Entity). It is used to resolve circular references during loading and storing of Entities.

The EntityId is a tuple of the TypeRep and the primary key value of an Entity. It is used as a key in the resolution cache.

Computes the EntityId of an entity. The EntityId of an entity is a (typeRep, idValue) tuple.

Lookup an entity in the cache, or retrieve it from the database. The Entity is identified by its EntityId, which is a (typeRep, idValue) tuple.

A data type holding meta-data about a type. The Phantom type parameter a ensures type safety for reflective functions that use this type to create type instances (See module RecordtypeReflection).

This function creates a TypeInfo object from the context of a function call. The Phantom Type parameter a is used to convince the compiler that the `TypeInfo a` object really describes type a. See also https://stackoverflow.com/questions/75171829/how-to-obtain-a-data-data-constr-etc-from-a-type-representation

this function is a smart constructor for TypeInfo objects. It takes a value of type a and returns a `TypeInfo a` object. If the type has no named fields, an error is thrown. If the type has more than one constructor, an error is thrown.

type Ctx defines the context in which the persistence operations are executed. It contains a connection to the database and a resolution cache for circular lookups.

Lift a computation from the IO monad. This allows us to run IO computations in any monadic stack, so long as it supports these kinds of operations (i.e. IO is the base monad for the stack).

Example

import Control.Monad.Trans.State -- from the "transformers" library

printState :: Show s => StateT s IO ()
printState = do
  state <- get
  liftIO $ print state

• Couldn't match type ‘IO’ with ‘StateT s IO’
 Expected type: StateT s IO ()
   Actual type: IO ()

> evalStateT printState "hello"
"hello"

> evalStateT printState 3
3

Executes a computation in a modified environment.

Retrieves the monad environment.