module Atd_ast: sig .. end
Abstract syntax tree (AST) representing ATD data
type Lexing.position * Lexing.position 
A location in the source code.
exception Atd_error of string
Exception raised by functions of the atd library and indicating
        errors.
type annot_section list 
An annotation, consisting of a sequence of sections.
        
Atd_annot provides utilities for handling annotations.
type string * (loc * annot_field list) 
represents a single annotation within edgy brackets.
        
<"foo" bar baz="123"> in ATD syntax translates to:
("foo", (loc1, [ ("bar", (loc2, None));
                 ("baz", (loc3, Some "123")) ] ))
type string * (loc * string option) 
An annotation field, 
        i.e. a key with an optional value within an annotation.
type module_head * module_body 
Contents of an ATD file.
type loc * annot 
The head of an ATD file is just a list of annotations.
type module_item list 
The body of an ATD file is a list of type definitions.
        Type definitions are implicitely mutually
        recursive. They can be sorted based on dependencies
        using 
Atd_util.tsort.
type [ `Type of type_def ] 
There is currently only one kind of module items,
          that is single type definitions.
type loc * (string * type_param * annot) *
       type_expr 
A type definition.
type string list 
List of type variables without the tick.
type [ `List of loc * type_expr * annot
       | `Name of loc * type_inst * annot
       | `Option of loc * type_expr * annot
       | `Record of loc * field list * annot
       | `Shared of loc * type_expr * annot
       | `Sum of loc * variant list * annot
       | `Tuple of loc * cell list * annot
       | `Tvar of loc * string ] 
A type expression is one of the following:
- `Sum: a sum type (within square brackets)
- `Record: a record type (within curly braces)
- `Tuple: a tuple (within parentheses)
- `List: a list type written- listwith its parameter
         e.g.- int list
- `Option: an option type written- optionwith its parameter 
         e.g.- string option
- `Shared: values for which sharing must be preserved. Such
         type expressions may not be parametrized. Values may only
         be shared if the source location of the type expression is the same.
- `Name: a type name other than- listor- option, including
         the predefined types- unit,- bool,- int,- float,- stringand- abstract.
- `Tvar: a type variable identifier without the tick
type loc * string * type_expr list 
A type name and its arguments
type [ `Inherit of loc * type_expr
       | `Variant of
           loc * (string * annot) * type_expr option ] 
A single variant or an 
inherit statement.
         
`Inherit statements can be expanded into variants 
         using 
Atd_inherit
         or at loading time using the 
inherit_variant option
         offered by the 
Atd_util functions.
type loc * type_expr * annot 
Tuple cell. Note that annotations placed before the type
        expression are supported and represented here,
        such as the third cell in
        (float * float * <ocaml default="0.0"> float).
type [ `Optional | `Required | `With_default ] 
Different kinds of record fields based on the 
- `Required: required field, e.g.- id : string
- `Optional: optional field without a default value, e.g.- ?name : string option.  The ATD type of the field
         value must be an option type.
- `With_default: optional field with a default value, e.g.- ~websites : string list. The default value may be implicit
         or specified explicitely using annotations.
         Each target language that cannot omit fields
         may have to specify the default in its own syntax.
         Sample ATD file:
type level = [ Beginner | Advanced | Expert ]
type user = {
  id : string;
  ?name : string option;
    (* Field may be omitted when no value is set, if permitted 
       by the target language. *)
  ~websites : string list;
    (* Implicit default: empty list.
       Field may be omitted if the field value is
       equal to the default value and the 
       target language permits it. *)
  ~level <ocaml default="`Beginner"> : level;
    (* Explicit default for `ocaml'.
       For instance there is no `json' annotation because
       the default for undefined `JSON' fields would be to omit them. *)
}
type [ `Field of
           loc * (string * field_kind * annot) *
           type_expr
       | `Inherit of loc * type_expr ] 
A single record field or an 
inherit statement.
         
`Inherit statements can be expanded into fields using 
Atd_inherit
         or at loading time using the 
inherit_fields option
         offered by the 
Atd_util functions.
val loc_of_type_expr : type_expr -> loc
Extract the source location of any type expression.
val set_type_expr_loc : loc -> type_expr -> type_expr
Replace the location of the given expression.
      This is a shallow substitution. Sub-expressions are not affected.
val string_of_loc : loc -> string
Convert a location into a human-readable string
      such as File "foo.atd", line 123, characters 40-45.
val error : string -> 'a
error s is a shorthand for raise (Atd_error s).
val error_at : loc -> string -> 'a
error_at loc s raises Atd_error s' where s'
      is the location followed by s.
val dummy_loc : loc
Dummy value for predefined constructs that are
     not associated with a useful source location.
     Should not show up in error messages.
val annot_of_type_expr : type_expr -> annot
Return the annotations associated with a type expression.
     Note that there can be annotations in a variety of places,
     not just after type expressions.
val map_annot : (annot -> annot) -> type_expr -> type_expr
Replacement of the annotations associated with a type
     expression.
     This is a shallow transformation as sub-expressions are not affected.
val fold : (type_expr -> 'a -> 'a) -> type_expr -> 'a -> 'a
Iteration and accumulation over each type_expr node
     within a given type_expr.
 : ?ignorable:string list -> type_expr -> string list
Extract all the type names occurring in a type expression 
     under `Name, without duplicates.
ignorable : specifies a list of type names to exclude from the result
val is_parametrized : type_expr -> bool
Test whether a type expression contains type variables (`Tvar).