---
name: "Parse"
section: "3o"
platform: "linux"
package: "ocaml"
version: "5.5.0-1"
release: "Arch Linux 2026-11-01"
platforms: ["linux"]
url: "https://new.carta.tech/Parse"
---

# Parse(3o)

Entry points in the parser

## NAME

Parse - Entry points in the parser

## Module

Module   Parse

## Documentation

Module **Parse**\
  :  **sig end**

Entry points in the parser

Warning: this module is unstable and part of **Compiler\_libs** .

*val implementation* :  **Lexing.lexbuf -\> Parsetree.structure**

*val interface* :  **Lexing.lexbuf -\> Parsetree.signature**

*val toplevel\_phrase* :  **Lexing.lexbuf -\> Parsetree.toplevel\_phrase**

*val use\_file* :  **Lexing.lexbuf -\> Parsetree.toplevel\_phrase list**

*val core\_type* :  **Lexing.lexbuf -\> Parsetree.core\_type**

*val expression* :  **Lexing.lexbuf -\> Parsetree.expression**

*val pattern* :  **Lexing.lexbuf -\> Parsetree.pattern**

*val module\_type* :  **Lexing.lexbuf -\> Parsetree.module\_type**

*val module\_expr* :  **Lexing.lexbuf -\> Parsetree.module\_expr**

The functions below can be used to parse Longident safely.

*val longident* :  **Lexing.lexbuf -\> Longident.t**

The function  **longident** is guaranteed to parse all subclasses of  **Longident.t** used in OCaml: values, constructors, simple or extended module paths, and types or module types.

However, this function accepts inputs which are not accepted by the compiler, because they combine functor applications and infix operators. In valid OCaml syntax, only value-level identifiers may end with infix operators  **Foo.( + )** . Moreover, in value-level identifiers the module path  **Foo** must be simple ( **M.N** rather than  **F(X)** ): functor applications may only appear in type-level identifiers. As a consequence, a path such as  **F(X).( + )** is not a valid OCaml identifier; but it is accepted by this function.

The next functions are specialized to a subclass of  **Longident.t**

*val val\_ident* :  **Lexing.lexbuf -\> Longident.t**

This function parses a syntactically valid path for a value. For instance, **x** ,  **M.x** , and  **(+.)** are valid. Contrarily,  **M.A** ,  **F(X).x** , and  **true** are rejected.

Longident for OCaml's value cannot contain functor application. The last component of the  **Longident.t** is not capitalized, but can be an operator  **A.Path.To.(.%.%.(;..)\<-)**

*val constr\_ident* :  **Lexing.lexbuf -\> Longident.t**

This function parses a syntactically valid path for a variant constructor. For instance,  **A** ,  **M.A** and  **M.(::)** are valid, but both  **M.a** and  **F(X).A** are rejected.

Longident for OCaml's variant constructors cannot contain functor application. The last component of the  **Longident.t** is capitalized, or it may be one the special constructors:  **true** , **false** , **()** , **\[\]** , **(::)** . Among those special constructors, only  **(::)** can be prefixed by a module path ( **A.B.C.(::)** ).

*val simple\_module\_path* :  **Lexing.lexbuf -\> Longident.t**

This function parses a syntactically valid path for a module. For instance,  **A** , and  **M.A** are valid, but both  **M.a** and  **F(X).A** are rejected.

Longident for OCaml's module cannot contain functor application. The last component of the  **Longident.t** is capitalized.

*val extended\_module\_path* :  **Lexing.lexbuf -\> Longident.t**

This function parse syntactically valid path for an extended module. For instance,  **A.B** and  **F(A).B** are valid. Contrarily, **(.%())** or  **\[\]** are both rejected.

The last component of the  **Longident.t** is capitalized.

*val type\_ident* :  **Lexing.lexbuf -\> Longident.t**

This function parse syntactically valid path for a type or a module type. For instance,  **A** ,  **t** ,  **M.t** and  **F(X).t** are valid. Contrarily, **(.%())** or  **\[\]** are both rejected.

In path for type and module types, only operators and special constructors are rejected.