Previous  Up  Next

Module Documented_match_statement

module Documented_match_statement: sig .. end
A t represents a match statement where every case is documented. You can then use it in one way to extract documentation, and in another way as the underlying function.

More specifically, an ('input,'output) t represents a match statement matching things of type input' and producing things of type 'output. It consists of specific_cases and a catchall_case.

The specific_cases are straightforward: {pattern=pattern;documentation=documentation;value=value} represents "| pattern -> value", with documentation explaining what's going on.

The catchall_case can be either `Unused x, representing "| _ -> x" with no documentation, or `Used case, representing "| x -> f x", where f is case.value, and case.documentation explains what's going on with f. This is intended to allow many input values to be handled uniformly without having to document each one individually.

type ('input, 'output) case = {
   pattern :'input list;
   documentation :string;
   value :'output;
} 
type ('input, 'output) t = {
   specific_cases :('input, unit -> 'output) case list;
   catchall_case :[ `Unused of unit -> 'output
| `Used of ([ `Catchall ], 'input -> 'output) case ];
} 
val map : ('input, 'output1) t ->
       f:('output1 -> 'output2) -> ('input, 'output2) t
val map_case : ('input, unit -> 'output1) case ->
       f:('output1 -> 'output2) ->
       ('input, unit -> 'output2) case
val map_cases : ('input, unit -> 'output1) case list ->
       f:('output1 -> 'output2) ->
       ('input, unit -> 'output2) case list
val map_pattern : ('input1, 'output) t ->
       f1:('input1 -> 'input2) ->
       f2:('input2 -> 'input1) -> ('input2, 'output) t
val prepend : specific_cases:('input, unit -> 'output) case list ->
       ('input, 'output) t ->
       ('input, 'output) t
prepend ~specific_cases t matches on specific_cases before moving on to t.

A common situation is representing let f t x = match x with | `A -> ... | `B -> ... | _ ->

which can be done by combining prepend and map: let f' = prepend ~specific_cases:{pattern = `A;...};{pattern = `B;...} (map g' ~f:(fun h t -> ))

val match_ : ('input, 'output) t -> 'input -> 'output
match_ t pulls out the underlying function of t
val documentation : ('input, 'output) t ->
       input_to_string:('input -> string) -> title:string -> string list