Ast_helper.Exp(3)

📦
version 5.5.0 · 19 versions
, in arch rolling

💖 Ast_helper.Exp — the manual, but make it cute 💖

Hiii bestie 💅 so this page lives in the OCaml library manual and it's called Ast_helper.Exp(3). It's all about Expressions — like, the whole thing. Every function here is a little helper that builds you a Parsetree expression-shaped thing out of its ingredients. It's giving "AST construction, but make it ergonomic." 🦋

✨ NAME ✨

Ast_helper.Exp — Expressions ✨

No cap, that's the whole name section. Short king. 👑

🎀 MODULE 🎀

The module is literally:

Module Ast_helper.Exp

Yeah. That's it. It is itself. Main character energy. 🌈

💜 DOCUMENTATION 💜

🌸 Module Exp 🌸

Module Exp
 : sig end

So it's a module named Exp whose signature is sig end — the docs are just showing you the module shape and then moving on, because the good stuff is inside. Keep scrolling, bestie 😭

🫶 Expressions 🫶

Okay so here's the tea ☕ — every single one of these bad boys takes these two optional lil cuties first:

  • ?loc:Ast_helper.loc
  • ?attrs:Ast_helper.attrs

That's the shared uniform, iykyk. Then the actual arguments come after, and you get a Parsetree.expression back at the end. Let's go through them one by one, no skipping, I promise 💯

  • mk — takes a Parsetree.expression_desc, hands you back a Parsetree.expression. The blueprint-to-building pipeline. 🏗️
val mk : ?loc:Ast_helper.loc -> ?attrs:Ast_helper.attrs ->
       Parsetree.expression_desc -> Parsetree.expression
  • attr — this one's different, bestie! It takes the expression first and there are no ?loc/?attrs here — it's Parsetree.expression -> Parsetree.attribute -> Parsetree.expression. Two positional args, no optional drama. 🙈
val attr : Parsetree.expression -> Parsetree.attribute ->
       Parsetree.expression
  • ident — give it an Ast_helper.lid and you get an expression. Ident-ity crisis? Never heard of her. 🪞
val ident : ?loc:Ast_helper.loc -> ?attrs:Ast_helper.attrs ->
       Ast_helper.lid -> Parsetree.expression
  • constant — an Ast_helper.lid's calm cousin. You feed it a Parsetree.constant, it gives you an expression. Consistent. Reliable. Slay. 🍓
val constant : ?loc:Ast_helper.loc -> ?attrs:Ast_helper.attrs ->
       Parsetree.constant -> Parsetree.expression
  • let_ — yes with the underscore, that's not a typo 👀. An Asttypes.rec_flag, a Parsetree.value_binding list, and an expression walk in; an expression walks out.
val let_ : ?loc:Ast_helper.loc -> ?attrs:Ast_helper.attrs ->
       Asttypes.rec_flag -> Parsetree.value_binding list ->
       Parsetree.expression -> Parsetree.expression
  • function_ — underscore again, we love a keyword-dodging queen 👑. Takes a Parsetree.function_param list, a Parsetree.type_constraint option, and a Parsetree.function_body.
val function_ : ?loc:Ast_helper.loc -> ?attrs:Ast_helper.attrs ->
       Parsetree.function_param list -> Parsetree.type_constraint option ->
       Parsetree.function_body -> Parsetree.expression
  • apply — the application one. An expression plus a (Asttypes.arg_label * Parsetree.expression) list and boom, expression. It's giving "you had one job and you applied yourself." 💅
val apply : ?loc:Ast_helper.loc -> ?attrs:Ast_helper.attrs ->
       Parsetree.expression -> (Asttypes.arg_label * Parsetree.expression) list
       -> Parsetree.expression
  • match_ — trailing underscore, she's shy 🫣. An expression and a Parsetree.case list go in, an expression comes out.
val match_ : ?loc:Ast_helper.loc -> ?attrs:Ast_helper.attrs ->
       Parsetree.expression -> Parsetree.case list -> Parsetree.expression
  • try_ — same shape as her sister match_, also rocking the underscore. Expression + Parsetree.case list → expression. Try her, she's flawless ✨
val try_ : ?loc:Ast_helper.loc -> ?attrs:Ast_helper.attrs ->
       Parsetree.expression -> Parsetree.case list -> Parsetree.expression
  • tuple — a (string option * Parsetree.expression) list in, an expression out. Note the string option in there, that's real and I'm not making it up 🔥
val tuple : ?loc:Ast_helper.loc -> ?attrs:Ast_helper.attrs -> (string
       option * Parsetree.expression) list -> Parsetree.expression
  • construct — an Ast_helper.lid plus a Parsetree.expression option, and you get an expression. Construction project: complete ✅
val construct : ?loc:Ast_helper.loc -> ?attrs:Ast_helper.attrs ->
       Ast_helper.lid -> Parsetree.expression option -> Parsetree.expression
  • variant — an Asttypes.label and a Parsetree.expression option walk in. Variant hours, who's she 🦋
val variant : ?loc:Ast_helper.loc -> ?attrs:Ast_helper.attrs ->
       Asttypes.label -> Parsetree.expression option -> Parsetree.expression
  • record — a (Ast_helper.lid * Parsetree.expression) list and a Parsetree.expression option at the end, then out pops an expression. Two-part situation, stay with me 📝
val record : ?loc:Ast_helper.loc -> ?attrs:Ast_helper.attrs ->
       (Ast_helper.lid * Parsetree.expression) list -> Parsetree.expression
       option -> Parsetree.expression
  • field — expression, then Ast_helper.lid, then expression. Order matters, don't @ me 🙃
val field : ?loc:Ast_helper.loc -> ?attrs:Ast_helper.attrs ->
       Parsetree.expression -> Ast_helper.lid -> Parsetree.expression
  • setfield — three positional besties: expression, Ast_helper.lid, expression. (Yes, that's what's written. Yes, it's a lot. Yes, it's iconic.) 🔥
val setfield : ?loc:Ast_helper.loc -> ?attrs:Ast_helper.attrs ->
       Parsetree.expression -> Ast_helper.lid -> Parsetree.expression ->
       Parsetree.expression
  • array — a Parsetree.expression list goes in, one expression comes out. Many become one. Girl group energy. 🎤
val array : ?loc:Ast_helper.loc -> ?attrs:Ast_helper.attrs ->
       Parsetree.expression list -> Parsetree.expression
  • ifthenelse — expression, expression, then a Parsetree.expression option (that's your else branch being optional, nudge nudge), then expression. 👀
val ifthenelse : ?loc:Ast_helper.loc -> ?attrs:Ast_helper.attrs ->
       Parsetree.expression -> Parsetree.expression -> Parsetree.expression
       option -> Parsetree.expression
  • sequence — expression, expression, expression. Two in, one out. Do them in order, bestie ➡️
val sequence : ?loc:Ast_helper.loc -> ?attrs:Ast_helper.attrs ->
       Parsetree.expression -> Parsetree.expression -> Parsetree.expression
  • while_ — underscore, obviously 💅. Two expressions in, one expression out.
val while_ : ?loc:Ast_helper.loc -> ?attrs:Ast_helper.attrs ->
       Parsetree.expression -> Parsetree.expression -> Parsetree.expression
  • for_ — the long one, buckle up 🎢. Parsetree.pattern, then two expressions, then an Asttypes.direction_flag, then another expression. Five positional arguments, all accounted for, none of them optional.
val for_ : ?loc:Ast_helper.loc -> ?attrs:Ast_helper.attrs ->
       Parsetree.pattern -> Parsetree.expression -> Parsetree.expression ->
       Asttypes.direction_flag -> Parsetree.expression -> Parsetree.expression
  • coerce — an expression, a Parsetree.core_type option, and a Parsetree.core_type. Glow-up transformation arc ✨
val coerce : ?loc:Ast_helper.loc -> ?attrs:Ast_helper.attrs ->
       Parsetree.expression -> Parsetree.core_type option ->
       Parsetree.core_type -> Parsetree.expression
  • constraint_ — underscore gang 🔪. An expression and a Parsetree.core_type.
val constraint_ : ?loc:Ast_helper.loc -> ?attrs:Ast_helper.attrs ->
       Parsetree.expression -> Parsetree.core_type -> Parsetree.expression
  • send — an expression and an Ast_helper.str. Sending it, fr fr 📨
val send : ?loc:Ast_helper.loc -> ?attrs:Ast_helper.attrs ->
       Parsetree.expression -> Ast_helper.str -> Parsetree.expression
  • new_ — underscore because new was taken 😔. Just an Ast_helper.lid, that's the whole meal.
val new_ : ?loc:Ast_helper.loc -> ?attrs:Ast_helper.attrs ->
       Ast_helper.lid -> Parsetree.expression
  • setinstvar — Ast_helper.str first, then an expression. Note the order, it's not the same as field up there 👀
val setinstvar : ?loc:Ast_helper.loc -> ?attrs:Ast_helper.attrs ->
       Ast_helper.str -> Parsetree.expression -> Parsetree.expression
  • override — a (Ast_helper.str * Parsetree.expression) list. Just the one listy arg. Simple, clean, ate 💅
val override : ?loc:Ast_helper.loc -> ?attrs:Ast_helper.attrs ->
       (Ast_helper.str * Parsetree.expression) list -> Parsetree.expression
  • assert_ — underscore, she's asserting herself 💁‍♀️. One expression in, one out.
val assert_ : ?loc:Ast_helper.loc -> ?attrs:Ast_helper.attrs ->
       Parsetree.expression -> Parsetree.expression
  • lazy_ — underscore AND lazy. Truly the mood. One expression in, one out. 😴
val lazy_ : ?loc:Ast_helper.loc -> ?attrs:Ast_helper.attrs ->
       Parsetree.expression -> Parsetree.expression
  • poly — an expression plus a Parsetree.core_type option, out comes an expression. Polymorphic and proud 🌈
val poly : ?loc:Ast_helper.loc -> ?attrs:Ast_helper.attrs ->
       Parsetree.expression -> Parsetree.core_type option ->
       Parsetree.expression
  • object_ — underscore, and it takes a Parsetree.class_structure. Object-oriented moment, we stan 🎀
val object_ : ?loc:Ast_helper.loc -> ?attrs:Ast_helper.attrs ->
       Parsetree.class_structure -> Parsetree.expression
  • newtype — an Ast_helper.str and an expression, then expression. Fresh type, fresh me 💫
val newtype : ?loc:Ast_helper.loc -> ?attrs:Ast_helper.attrs ->
       Ast_helper.str -> Parsetree.expression -> Parsetree.expression
  • pack — a Parsetree.module_expr plus a Parsetree.package_type option. Pack it up, pack it in 🧳
val pack : ?loc:Ast_helper.loc -> ?attrs:Ast_helper.attrs ->
       Parsetree.module_expr -> Parsetree.package_type option ->
       Parsetree.expression
  • letop — a Parsetree.binding_op, then a Parsetree.binding_op list, then an expression. Let-operators said "we're here too" 🔥
val letop : ?loc:Ast_helper.loc -> ?attrs:Ast_helper.attrs ->
       Parsetree.binding_op -> Parsetree.binding_op list ->
       Parsetree.expression -> Parsetree.expression
  • extension — takes a Parsetree.extension. Extension representation, periodt. ⭐
val extension : ?loc:Ast_helper.loc -> ?attrs:Ast_helper.attrs ->
       Parsetree.extension -> Parsetree.expression
  • unreachable — takes literally unit (so (), the emptiest queen alive) and gives you an expression. Haunting. 💀
val unreachable : ?loc:Ast_helper.loc -> ?attrs:Ast_helper.attrs -> unit
       -> Parsetree.expression
  • struct_item — a Parsetree.structure_item and a Parsetree.expression go in, one expression comes out. Structure, but make it an expression 🏛️
val struct_item : ?loc:Ast_helper.loc -> ?attrs:Ast_helper.attrs ->
       Parsetree.structure_item -> Parsetree.expression -> Parsetree.expression
  • case — ⚠️ heads up bestie, this one plays by its own rules: no ?loc, no ?attrs, and it returns a Parsetree.case, not an expression. It's Parsetree.pattern, then ?guard:Parsetree.expression (a named optional — note the label!), then Parsetree.expression.
val case : Parsetree.pattern -> ?guard:Parsetree.expression ->
       Parsetree.expression -> Parsetree.case
  • binding_op — also a rebel 🫣. No ?loc/?attrs, and the return type is Parsetree.binding_op. Order is: Ast_helper.str, Parsetree.pattern, Parsetree.expression, then Ast_helper.loc last, not optional, no question mark.
val binding_op : Ast_helper.str -> Parsetree.pattern ->
       Parsetree.expression -> Ast_helper.loc -> Parsetree.binding_op
💡 Friendly reminder from your girl: attr, case, and binding_op are the three that don't do the ?loc/?attrs thing, and case + binding_op give you back Parsetree.case / Parsetree.binding_op instead of an expression. Don't get caught out, iykyk 🫶

🌟 Sign-off 🌟

That's the whole page, bestie — no crumbs left, no options skipped, every signature exactly where it belongs 💖✨🎀

This little masterpiece was brought to you by OCamldoc, dated 2026-06-22, living at Ast_helper.Exp(3). Like, she's documented, she's dated, she's iconic. Periodt. 👑💅🦋

📦 where this page comes from