Module Sexplib.Sexp_grammarSource

accepts any sexp; string is a type name for human readability

accepts the atoms "true" or "false", modulo capitalization

accepts any single-character atom

accepts any atom matching ocaml integer syntax, regardless of bit width

accepts any atom matching ocaml float syntax

accepts any atom

accepts an option, both None vs Some _ and () vs (_).

accepts a list

accepts clauses keyed by a leading or sole atom

accepts a sexp if any of the listed grammars accepts it

annotates a grammar with a client-specific key/value pair

Name of a type variable, e.g. Tyvar "a" for 'a. Only meaningful when the body of the innermost enclosing defn defines a corresponding type variable.

Type constructor applied to arguments, and its definition.

For example, writing Tycon ("tree", [ Integer ], defns) represents int tree, for whatever tree is defined as in defns. The following defines tree as a binary tree with the parameter type stored at the leaves.

  let defns =
    [ { tycon = "tree"
      ; tyvars = [ "a" ]
      ; grammar =
          Variant
            { name_kind = Capitalized
            ; clauses =
                [ { name = "Node"
                  ; args = Cons (Recursive ("node", [ Tyvar "a" ]), Empty)
                  }
                ; { name = "Leaf"
                  ; args = Cons (Recursive ("leaf", [ Tyvar "a" ]), Empty)
                  }
                ]
            }
      }
    ; { tycon = "node"
      ; tyvars = [ "a" ]
      ; grammar = List (Many (Recursive "tree", [ Tyvar "a" ]))
      }
    ; { tycon = "leaf"; tyvars = [ "a" ]; grammar = [ Tyvar "a" ] }
    ]
  ;;

To illustrate the meaning of Tycon with respect to defns, and to demonstrate one way to access them, it is equivalent to expand the definition of "tree" one level and move the defns to enclosed recursive references:

  Tycon ("tree", [ Integer ], defns)
  --> Variant
        { name_kind = Capitalized
        ; clauses =
            [ { name = "Node"
              ; args = Cons (Tycon ("node", [ Tyvar "a" ], defns), Empty)
              }
            ; { name = "Leaf"
              ; args = Cons (Tycon ("leaf", [ Tyvar "a" ], defns), Empty)
              }
            ]
        }

This transformation exposes the structure of a grammar with recursive references, while preserving the meaning of recursively-defined elements.

Type constructor applied to arguments. Used to denote recursive type references. Only meaningful when used inside the defns of a Tycon grammar, to refer to a type constructor in the nearest enclosing defn list.

Lazily computed grammar. Use Lazy to avoid top-level side effects. To define recursive grammars, use Recursive instead.

accepts an empty list of sexps

accepts a non-empty list with head and tail matching the given grammars

accepts zero or more sexps, each matching the given grammar

accepts sexps representing fields of a record

Comparison is case insensitive. Used for custom parsers.

Comparison is case sensitive. Used for polymorphic variants.

Comparison is case insensitive for the first character and case sensitive afterward. Used for regular variants.