Fixed is a typeclass for representing the fixed point of a Functor. A well-behaved instance of Fixed should not change the shape of the underlying Functor.

In other words, the following should always be true: outf (inf x) == x

Fix is a type for creating an in-memory representation of the fixed point of a Functor.

Stored is a fixed-point combinator of f in Transaction s.

Null is a typeclass for representing data that can be empty as well as the null predicate that can determine if a piece of data is empty.

Null1 is for expressing null types of kind (* -> *).

CataAlg is a catamorphism F-Algebra.

CataMAlg is a monadic catamorphism F-Algebra.

cata applies a CataAlg over a fixed point of a Functor.

cataM is a monadic catamorphism.

AnaAlg is an anamorpism F-Algebra.

AnaMAlg is a monadic anamorpism F-Algebra.

ana applies an AnaAlg over an argument to produce a fixed-point of a Functor.

anaM is a monadic anamorphism.

ParaAlg is a paramorphism F-Algebra.

ParaAlg is a monadic paramorphism F-Algebra.

para applies a ParaAlg over a fixed point of a Functor.

paraM is a monadic paramorphism.

hylo combines ana and cata into a single operation.

hyloM is a monadic hylomorphism.

iso maps from a fixed point of a Functor to a different fixed point of the same Functor. For any two well-behaved instances of Fixed, the shape of the Functor should remain unchanged.

FixedAlg is a typeclass for describing the relationship between a Functor that is used with a Fixed combinator and an algebraic datatype in that Functor other than the one used for fixed-point recursion.

FixedSub is a typeclass for describing the relationship between a FixedAlg Functor f and that same Functor with Alg f switched from v to v'.

FixedFunctor is a typeclass for describing mapping behavior for datatypes used with Fixed combinators.

fmapF, but using a single instance of Fixed.

FixedFoldable is a typeclass for describing folds over datatypes with Fixed combinators.

FixedTraversable is a typeclass for describing traversals over datatypes with Fixed combinators.

traverseF, but using a single instance of Fixed.

A Constraint for data that can be used with a Ref

FixTraverse is a class based on Traverse but taking an argument of kind ((* -> *) -> *) instead of *.

A Root is a datastructure that is an instance of FixTraverse and Binary. This acts as a sort of "header" for the file where the Root may have several Refs under it to different Functors.

A Ptr points to a location in a FixFile and has a phantom type for a Functor f. A Root expects an argument that resembles a Fixed, but we can pass it a Ptr instead. This is not a well-formed Fixed because it can't be unpacked into f (Ptr f).

But, it can be serialized, which allows a Root object that takes this as an argument to be serialized.

A Ref is a reference to a Functor f in the Fixed instance of g.

This is an instance of Root and acts to bridge between the Root and the recursively defined data structure that is (g f).

Lens for accessing the value stored in a Ref

A FixFile is a handle for accessing a file-backed recursive data structure. r is the Root object stored in the FixFile.

Create a FixFile, using Fix f as the initial structure to store at the location described by FilePath.

Create a FixFile, using Fix f as the initial structure to store at the location described by FilePath and using the Handle to the file to be created.

Open a FixFile from the file described by FilePath.

Open a FixFile from the file described by FilePath and using the Handle to the file.

Close a FixFile. This can potentially cause errors on data that is lazily being read from a Transaction.

Get the FilePath of a FixFile.

It's potentially useful to copy the contents of a FixFile to a new location as a backup. The clone function essentially runs vacuum on a FixFile, but writes the output to the specified path.

cloneH is clone but taking a Handle as an argument instead of a FilePath.

Because a FixFile is backed by an append-only file, there is a periodic need to vacuum the file to garbage collect data that is no longer referenced from the root. This task operates on a temporary file that then replaces the file that backs FixFile.

The memory usage of this operation scales with the recursive depth of the structure stored in the file.

A Transaction is an isolated execution of a read or update operation on the root object stored in a FixFile. r is the Root data that is stored by the FixFile. s is a phantom type used to isolate Stored values to the transaction where they are run.

The preferred way to modify the root object of a FixFile is by using alterT. It applies a function that takes the root object as a Stored s f and returns the new desired head of the same type.

The preferred way to read from a FixFile is to use lookupT. It applies a function that takes a Stored s f and returns a value.

Perform a read transaction on a FixFile. This transaction cannot modify the root object stored in the file. The returned value is lazily evaluated, but will always correspond to the root object at the start of the transaction.

Perform a write transaction on a FixFile. This operation differs from the readTransaction in that the root object stored in the file can potentially be updated by this Transaction.

The writeExceptTransaction function behaves like writeTransaction, but applies to a Transaction wrapped in ExceptT. In the event that an exception propagates through the Transaction, the updates are not committed to disk.

This is meant to provide a mechanism for aborting Transactions.

Perform a Transaction on a part of the root object.

Get the root datastructure from the transaction as r Fix.

Get the full datastructure from the transaction as a Fix f.