To focus the search input from anywhere on the page, press the 'S' key.
in-package search v0.1.0
Not all computations are arrow types. For example:
'a computation = Type_hash.t
However, arrow types computation such as
json_of, etc. are such a standard case that is seems reasonable to share this extra layer of functor for it to build the
module X : sig ... end
module Context : sig ... end
Work in progress representation of a computation. This is mostly used to handle recursive types. While building a computation on a recursive type, one needs to have some computation available for the location where the type appears recursively.
init will be called once on each new type_name met during the traversal of a type. Each time the same type is encountered again,
get_wip_computation will be called. At the end of the traversal of that particular type,
set_final_computation will be called, offering as a way to "close" the wip representation.
'a t can be mutable (and is likely to be in practice).
set_final_computation is performed and return a final computation C for a type_name, C will be memoized and returned for each further occurrences of the same type_name inside the typerep, going further on.
val init : Context.t -> 'a Typename.t -> 'a t
val share : _ Std_internal.Typerep.t -> bool
It might be interesting to inline some computation for a few typerep if they appear several times within a typerep. This parameters will allow one to tweak the sharing between multiple occurences of the same typename.
share = true means no inlining.
Note that not sharing recursive types will lead the
of_typerep function to loop forever. Be careful when setting this.
An example where it is not suitable to share everything for example is typestruct. The typestruct of an int is a simple constructor called
Int, naming it once and using the name to refere to it later within the typestruct does not lead to a shorter typestruct, and is in fact less readable. The benefit of the sharing depends on the computation, its memory and building costs.