The Functoria DSL.
The Functoria DSL allows users to describe how to create portable and flexible applications. It allows to pass application parameters easily using command-line arguments either at configure-time or at runtime.
Users of the Functoria DSL composes their application by defining a list of module implementations, specify the command-line Keys that are required and combine all of them together using applicative operators.
The DSL expression is then compiled into an application builder, which will, once evaluated, produced the final portable and flexible application.
The type for values representing module types.
val typ : 'a -> 'a typtype t is a value representing the module type t.
Construct a functor type from a type and an existing functor type. This corresponds to prepending a parameter to the list of functor parameters. For example:
kv_ro @-> ip @-> kv_ro This describes a functor type that accepts two arguments -- a kv_ro and an ip device -- and returns a kv_ro.
The type for abstract implementations.
val abstract : _ impl -> abstract_implabstract t is t but with its type variable abstracted. Useful for dependencies.
type key = Functoria_key.tThe type for command-line keys. See Functoria_key.t.
type context = Functoria_key.contextThe type for keys' parsing context. See Functoria_key.context.
type 'a value = 'a Functoria_key.valueThe type for values parsed from the command-line. See Functoria_key.value.
if_impl v impl1 impl2 is impl1 if v is resolved to true and impl2 otherwise.
match_impl v cases ~default chooses the implementation amongst cases by matching the v's value. default is chosen if no value matches.
module type KEY = module type of struct include Functoria_key endThe signature for run-time and configure-time command-line keys.
Values of type impl are tied to concrete module implementation with the foreign construct. Module implementations of type job can then be registered into an application builder. The builder is in charge if parsing the command-line arguments and of generating code for the final application. See Functoria_app for details.
val foreign :
?packages:string list ->
?libraries:string list ->
?keys:key list ->
?deps:abstract_impl list ->
string ->
'a typ ->
'a implforeign name typ is the module name, having the module type typ.
packages is set, then the given OPAM packages are installed before compiling the current application.libraries is set, the given OCamlfind libraries are included and linked with the module name.keys is set, use the given keys to parse at configure and runtime the command-line arguments before calling name.connect.deps is set, the given list of abstract implementations is added as data-dependencies: they will be initialized before calling name.connect.For a more flexible definition of libraries and packages, or for a custom configuration step, see the configurable class type and the foreign class.
module Info : sig ... endInformation about the final application.
class type 'ty configurable = object ... endSignature for configurable module implementations. A configurable is a module implementation which contains a runtime state which can be set either at configuration time (by the application builder) or at runtime, using command-line arguments.
val impl : 'a configurable -> 'a implimpl c is the implementation of the configurable c.
class base_configurable : object ... endbase_configurable pre-defining many methods from the configurable class. To be used as follow:
class 'a foreign : ?packages:string list -> ?libraries:string list -> ?keys:key list -> ?deps:
abstract_impl
list -> string -> 'a typ -> 'a configurableThis class can be inherited to define a configurable with an API similar to foreign.
val hash : 'a impl -> inthash is the hash function on implementations. FIXME(samoht) expand on how it works.
module ImplTbl : Hashtbl.S with type key = abstract_implHashtbl of implementations.