Will LaTeX3 have proper support for hooks? Does LuaTeX?

Question

Tex has powerful support for extensions triggered by events happen in generating output, by running one of six token lists appropriately:

 \everycr \everydisplay \everyhbox \everymath \everypar \everyvbox

They're used with effect in such places as Latex classes, but they are much less useful than they could be, because the \everyfoo={\t\o ks} assignment simply wipes the current value, making it rather tricky to use them by authors of packages and documents. Emacs' Elisp has a widely understood technology for registering and deregistering code to run at events, namely hooks.

The LaTeX3 Project's expl3 library offers supports for managing token lists, and LuaTeX augments TeX's event handling mechanism with a set of Lua callbacks. Are these the beginning of proper support for event-driven TeX code, as usable as hooks? Is this a priority for developers on these projects?

Answer 1

LuaTeX does not offer these hooks out of the box, but you can make them yourself. The LuaLaTeX people do this (thanks!). See http://github.com/mpg/luatexbase (and there: luatexbase-mcb.dtx).

Answer 2

Sure, it would be great if LaTeX3 provided hooks for this sort of thing—not using the primitives directly, but rather providing an interface to a reliable way to use these token registers.

Unfortunately, ripping out the current LaTeX2e machinery for, say, giving a good way to access \everypar simply isn't possible without breaking backwards compatibility with lots and lots of current packages. Experimental LaTeX3 packages such as galley are written to start thinking about these ideas, but we're quite a way away from anything that can be used for general purposes.

Answer 3

Expanding on the LaTeX3 side of things, I guess this is a place where I'd expect to provide a different input syntax to LaTeX2e. As the question points out, the current implementation uses the token register syntax

\everyfoo{tokens}

which overwrites whatever was in \everyfoo unless you do

\everyfoo\expandafter{\the\everyfoo tokens}

which is not exactly obvious. So a better approach would be something like the current \AtBeginDocument, something like:

\AtEveryFoo{tokens}

where this is additive. The implementation of such an approach would be easy enough.

Proof of concept A short piece of concept code that might be an approach for LaTeX3. The idea here is that the TeX primitive is only used by the kernel, with two separate hooks provided. First, settings that the kernel needs are applied, then ones from programmers and finally those from the user. In the demo I've only considered the \everymath concept. I've provided an interface for the user to both add to and clear the list, plus an alias to the LaTeX2e \everymath interface. (In a pure LaTeX3 approach I'd drop this TeX-like interface, or at least mark it depreciated.)

\documentclass{article}
\usepackage{xparse}
\ExplSyntaxOn
\makeatletter
\tl_new:N \l_every_math_programmers_tl
\tl_new:N \l_every_math_users_tl
\toks_set:Nn \tex_everymath:D {
  \check@mathfonts % LaTeX2e's requirement
  \tl_use:N \l_every_math_programmers_tl
  \tl_use:N \l_every_math_users_tl
}
\NewDocumentCommand \InsertForEvery { m +m } {
  \tl_put_right:cn { l_every_ #1 _users_tl } {#2}  
}
\NewDocumentCommand \ClearForEvery { m } {
  \tl_clear:c { l_every_ #1 _users_tl }
}
\RenewDocumentCommand \everymath { +m } { \InsertForEvery { math } {#1} }
\ExplSyntaxOff
\begin{document}

\InsertForEvery{math}{\mathrm{Look!\,}}
\( y = mx +  c \)

\ClearForEvery{math}
\( y = mx +  c \)

\end{document}

I should add that a real implementation would need error-checking and so on.