LaTeXML...::MathML(3)

🌸 NAME 🌸

okay so bestie, this is the LaTeXML...::MathML(3) page from the User Contributed Perl Documentation, and it's all about LaTeXML::Post::MathML — the Post-Processing modules for converting math to MathML. This page is giving very niche Perl math fairy energy, and I'm obsessed. ✨

🦋 SYNOPSIS 🦋

LaTeXML::Post::MathML is the abstract base class for the MathML Postprocessor. This base class ate, no cap. Then LaTeXML::Post::MathML::Presentation and LaTeXML::Post::MathML::Content do the actual converting: they turn XMath into either Presentation MathML or Content MathML, or they use that format as the principle branch for Parallel markup. (Yes, the page says "principle" — I'm not fixing it, I'm just reporting it 💀)

🎀 DESCRIPTION 🎀

The conversion is mostly a tree walk of the XMath expression. Appropriate handlers get selected and called depending on the operators and forms it encounters. The way this tree walk picks handlers is lowkey main character energy. You can define handlers on applications of operators, or on tokens; when a token is applied, its application handler takes precedence over its token handler.

💅 DefMathML($key,$presentation,$content); 💅

This defines presentation and content handlers for $key. The $key is shaped like TYPE:ROLE:MEANING, where:

• TYPE — is one either Token or Apply (or Hint ?)
• ROLE — is a grammatical role (on XMath tokens)
• MEANING — is the meaning attribute (on XMath tokens)

Any of these can be ? to match any role or meaning; matches of both are preferred, then match of meaning or role, or neither. Match vibes, fr fr.

The subroutine handlers for presentation and content are given by $presentation and $content, respectively. Either can be undef, in which case some other matching handler will be invoked.

For Token handlers, the arguments passed are the token node; for Apply handler, the arguments passed are the operator node and any arguments.

However, it looks like some TOKEN handlers are being defined to take $content,%attributes — being the string content of the token, and the token's attributes! Bestie, I'm just reading the page. 😭

🌈 Presentation Conversion Utilties 🌈

• $mmlpost->pmml_top($node,$style); — this is the top-level converter applied to an XMath node. It establishes a local context for font, style, size, etc. It generally does the bulk of the work for a PresentationMathML's translateNode, although the latter wraps the actual m:math element around it. (style is display or text).
• pmml($node), pmml_smaller($node), pmml_scriptsizsize($node) — converts the XMath $node to Presentation MathML. The latter two are used when the context calls for smaller (eg. fraction parts) or scriptsize (eg sub or superscript) size or style, so that the size encoded within $node will be properly accounted for.
• pmml_mi($node,%attributes), pmml_mn($node,%attributes), pmml_mo($node,%attributes) — these are Token handlers, to create m:mi, m:mn and m:mo elements, respectively. When called as a handler, they will be supplied only with an XMath node (typically an XMTok). For convenient reuse, these functions may also be called on a 'virtual' token: with $node being a string (that would have been the text content of the XMTok), and the %attributes that would have been the token's attributes.
• pmml_infix($op,@args), pmml_script($op,@args), pmml_bigop($op,@args) — these are Apply handlers, for handling general infix, sub or superscript, or bigop (eg. summations) constructs. They are called with the operator token, followed by the arguments; all are XMath elements.
• pmml_row(@items) — this wraps an m:mrow around the already converted @items if need; that is, if there is only a single item it is returned without the m:mrow.
• pmml_unrow($pmml) — this perverse utility takes something that has already been converted to Presentation MathML. If the argument is an m:mrow, it returns a list of the mathml elements within that row, otherwise it returns a list containing the single element $pmml.
• pmml_parenthesize($item,$open,$close) — this utility parenthesizes the (already converted MathML) $item with the string delimiters $open and $close. These are converted to an m:mrow with m:mo for the fences, unless the usemfenced switch is set, in which case m:mfenced is used.
• pmml_punctuate($separators,@items) — this utility creates an m:mrow by interjecting the punctuation between suceessive items in the list of already converted @items. If there are more than one character in $separators the first is used between the first pair, the next between the next pair; if the separators is exhausted, the last is repeated between remaining pairs. $separators defaults to (repeated) comma.

🍓 Content Conversion Utilties 🍓

• "$mmlpost-"cmml_top($node); > — okay yes, the page literally prints this signature like that, with the weird quote and the > at the end, and I am not touching it. It's the top-level converter applied to an XMath node. It establishes a local context for font, style, size, etc (were it needed). It generally does the bulk of the work for a ContentMathML's translateNode, although the latter wraps the actual m:math element around it.
• cmml($node) — converts the XMath $node to Content MathML.
• cmml_leaf($token) — converts the XMath token to an m:ci, m:cn or m:csymbol, under appropriate circumstances.
• cmml_decoratedSymbol($item) — similar to cmml_leaf, but used when an operator is itself, apparently, an application. This converts $item to Presentation MathML to use for the content of the m:ci.
• cmml_not($arg) — construct the not of the argument $arg.
• cmml_synth_not($op,@args) — synthesize an operator by applying m:not to another operator ($op) applied to its @args (XMath elements that will be converted to Content MathML). This is useful to define a handler for, eg., c<not-approximately-equals> in terms of c<m:approx>.
• cmml_synth_complement($op,@args) — synthesize an operator by applying a complementary operator ($op) to the reverse of its @args (XMath elements that will be converted to Content MathML). This is useful to define a handler for, eg. superset-of-or-equals using m:subset.
• cmml_or_compose($operators,@args) — synthesize an operator that stands for the "or" of several other operators (eg. c<less-than-or-similar-to-or-approximately-equals>) by composing it of the m:or of applying each of m:less and m:approx to the arguments. The first operator is applied to the converted arguments, while the rest are applied to m:share elements referring to the previous ones.
• cmml_share($node) — converts the XMath $node to Content MathML, after assuring that it has an id, so that it can be shared.
• cmml_shared($node) — generates a m:share element referting to $node, which should have an id (such as after calling cmml_share). Yes, "referting" — the page said it, not me. 🙈

👑 Math Processors, Generally. 👑

We should probably formalize the idea of a Math Processor as an abstract class, but let this description provide a starting overview. A MathProcessor follows the API of LaTeXML::Post processors, by handling process, which invokes processNode on all Math nodes; that latter inserts the result of either translateNode or translateParallel, applied to the XMath representation, into the Math node.

Parallel translation is done whenever additional MathProcessors have been specified, via the setParallel method; these are simply other MathProcessors following the same API. Periodt.

---

okay that's the whole page, bestie 🫶. It's perl v5.42.3, dated 2024-02-26, and the manual is LaTeXML...::MathML(3). Mwah 💋✨