Parse(3)

🌸 NAME 🌸

okay so bestie, you opened Parse(3) — the OCaml library page for Parse — and no cap, this is lowkey the parser's entry-point era. Compiler-libs girlie, unstable-core, main-character energy. 💅

🎀 Module 🎀

Module Parse : sig end

Entry points in the parser.

⚠️ Warning: this module is unstable and part of Compiler_libs. She's iconic, but she's not giving "stable API promise," so vibe-check before you commit. 💀

✨ Documentation ✨

First up, the first batch of entry points, no notes:

• 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 — okay so 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. BUT plot twist: 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 of 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. 💜

mwah 💋 — this cutie page is from OCamldoc, dated 2026-06-22, and it's literally Parse(3). periodt. 🎀