package travesty

  1. Overview
  2. Docs
Monadically traversable containers

Install

Dune Dependency

Authors

Maintainers

Sources

travesty-v0.5.1.tbz
sha256=6096bfedbab2044c6372c918712bc5e71ffba5a373cdab37398787712c9c83af
sha512=a7a1cd7981af2c16111323cdf72ac6a45a5e58a3701376fdb3d7f3ee15fbf4003e71f94ad882ccea0d308bb229f3ac0b2c9861a231a498c22e44551f1fcf802d

doc/travesty/Travesty/Traversable/index.html

Module Travesty.TraversableSource

Signatures and functors for containers and data structures that can be mapped across with a monadic side-effect.

Modules based on this pattern resembles the Haskell Traversable typeclass, but with two differences:

  • We currently define traversability in terms of monads, not applicative functors (this might change in the future, but monads are generally more well-understood and well-supported in the OCaml/Core ecosystem);
  • as a result, the main 'traverse' function is called map_m.

Signatures

Inner-traversal signatures

These signatures form the inner body of the On_monad functor in the main signatures. They all have names ending with _on_monad, and assume the existence of a monad M.

While they aren't interesting on their own, they do contain (in slightly abstract form) the specific functions needed to build, and provided on building, traversable containers.

The generic signatures

As with Mappable, we define some signatures for traversable structures in an arity-generic way, then specialise them for arity-0 and arity-1 types.

Sourcemodule type Basic_generic_on_monad = sig ... end

Basic_generic_on_monad describes monadic traversal on either an arity-0 or arity-1 type.

Sourcemodule type Generic_on_monad = sig ... end

Generic_on_monad extends Generic to contain various derived operators; we use it to derive the signatures of the various On_monad modules.

Basic signatures
Sourcemodule type Basic0_on_monad = sig ... end

Basic0_on_monad is the inner signature of a monadic traversal over arity-0 types.

Sourcemodule type Basic1_on_monad = sig ... end

Basic1_on_monad is the inner signature of a monadic traversal over arity-1 types.

Expanded signatures
Sourcemodule type S1_on_monad = sig ... end

S1_on_monad extends Generic_on_monad with functionality that only works on arity-1 containers.

Basic signatures

Any traversable type can be turned into a Core container, using the monadic fold to implement all container functionality. The unified signature of a container with monadic traversals is S0 (arity 0) or S1 (arity 1).

To satisfy these signatures for new types, implement Basic0 or Basic1, and use the corresponding MakeN functor.

For types that are _already_ Core containers, or types where custom implementation of the Core signature are desired, implement Basic0_container or Basic1_container, and use the MakeN_container functors.

For modules without a Container implementation
Sourcemodule type Basic0 = sig ... end

Basic0 is the minimal signature that traversable containers of arity 0 must implement to be extensible into S0.

Sourcemodule type Basic1 = sig ... end

Basic1 is the minimal signature that traversable containers of arity 1 must implement to be extensible into.

For modules with a Container implementation
Sourcemodule type Basic0_container = sig ... end

Basic0_container combines Basic0 and the Base container signature, and is used for extending existing containers into S0_container s.

Sourcemodule type Basic1_container = sig ... end

Basic1_container combines Basic1 and the Base container signature, and is used for extending existing containers into S1_container s.

Signatures for traversable containers
Sourcemodule type Generic = sig ... end

Generic is a generic interface for traversable containers, used to build S0 (arity-0) and S1 (arity-1).

Sourcemodule type S0 = sig ... end

S0 is a generic interface for arity-0 traversable containers.

Sourcemodule type S1 = sig ... end

S1 is a generic interface for arity-1 traversable containers. It also includes the extensions from Mappable.

Making traversable containers

Monadic traversal is sufficient to define fold, and, therefore, all of the key functionality for a Base-style container. As such, our signatures and functors subsume those for building containers.

New containers

Sourcemodule Make0 (I : Basic0) : S0 with module Elt = I.Elt and type t = I.t

Make makes an S0 from a Basic0.

Sourcemodule Make1 (I : Basic1) : S1 with type 'a t = 'a I.t

Make makes an S1 from a Basic1.

Extending existing containers with monadic traversals

Sourcemodule Make0_container (I : Basic0_container) : S0 with module Elt = I.Elt and type t = I.t

Make0_container makes an S0 from a Basic0_container.

Sourcemodule Make1_container (I : Basic1_container) : S1 with type 'a t = 'a I.t

Make1_container makes an S1 from a Basic1_container.

Combining and modifying traversable containers

Chaining

Sourcemodule Chain0 (Outer : S0) (Inner : S0 with type t := Outer.Elt.t) : S0 with module Elt = Inner.Elt and type t = Outer.t

Chain0 chains two S0 instances together, traversing each element of the outer instance with the inner instance.

Fixing the element type

Sourcemodule Fix_elt (I : S1) (Elt : Base.Equal.S) : S0 with module Elt = Elt and type t = Elt.t I.t

Fix_elt (I) (Elt) demotes an S1 S to an S0 by fixing the element type to that mentioned in Elt.

Helper functions

Sourcemodule Helpers (M : Base.Monad.S) : sig ... end

Utility functions for building traversals.

OCaml

Innovation. Community. Security.