Estoy interactuando con la comunidad para buscar ideas y posibles soluciones para una macro personalización de LaTeX. Esto está inspirado en una discusión en estehilo, que explora la posibilidad de reemplazar dinámicamente tokens con secuencias de control. Específicamente, la segunda respuesta en el hilo proporciona una base para mi enfoque actual, cuyo objetivo es reemplazar símbolos o palabras arbitrarias con secuencias de control específicas usando el comando \myspecdef somethinghere : \somecontrolseq.
Aquí está el extracto de código de la segunda respuesta del hilo antes mencionado, que demuestra el intento inicial de crear esta funcionalidad:
\long\def\isnextchar#1#2#3{\begingroup\toks0={\endgroup#2}\toks1={\endgroup#3}%
\let\tmp=#1\futurelet\next\isnextcharA
}
\def\isnextcharA{\the\toks\ifx\tmp\next0\else1\fi\space}
\def\skipnext#1#2{#1}
\def\trynext#1{\trynextA#1\relax\relax}
\def\trynextA#1#2\relax#3\relax#4#5{%
\ifx\relax#2\relax \def\next{\isnextchar#1{\skipnext{#4}}{#5#3}}\else
\def\next{\isnextchar#1{\skipnext{\trynextA#2\relax#3#1\relax#4{#5}}}{#5#3}}\fi
\next
}
\def\mspecdefA#1#2#3 : #4{\ifx#2\undefined
\def#2{\trynext{#3}#4{#1}}\else
\toks0={\trynext{#3}#4}\toks1=\expandafter{#2}%
\edef#2{\the\toks0{\the\toks1}}\fi
}
\def\mspecdef#1{%
\expandafter\ifx\csname m:#1\endcsname\relax
\expandafter\mathchardef\csname m:#1\endcsname=\mathcode`#1
\fi
\mathcode`#1="8000
\begingroup \lccode`~=`#1
\lowercase{\endgroup\expandafter\mspecdefA\csname m:#1\endcsname~}%
}
\mspecdef << : \ll
\mspecdef <> : \neq
\mspecdef <= : \leq
\mspecdef <== : \Leftarrow
\mspecdef <=> : \Leftrightarrow
\mspecdef <-- : \leftarrow
\mspecdef <-> : \leftrightarrow
\mspecdef >> : \gg
\mspecdef >= : \geq
\mspecdef --> : \rightarrow
\mspecdef -+ : \pm
\mspecdef +- : \mp
\mspecdef ... : \dots
\mspecdef == : \equiv
\mspecdef =. : \doteq
\mspecdef ==> : \Rightarrow
\mspecdef =( : \subseteq
\mspecdef =) : \supseteq
\mspecdef =[ : \sqsubseteq
\mspecdef =] : \sqsubseteq
\myspecdef integration : \int %<- an example of what I want
\myspecdef int : \int %<- this produces an error whilst...
\myspecdef int : \sin %<- does not!
test:
$$ a << b < c <= d >= e > f >> g $$
$$ a <> b = c =. d == e $$
$$ a <== b <-- c <-> d <=> e --> f ==> g $$
$$ a +- b = -(-a -+ +b) $$
$$ a, ..., z <> a + ...+ z $$
$$ a =( b =) c =[ e =] f $$
\[ x^+ \] %<- this produces an error
Aunque este método permite la sustitución dinámica, como la transformación integralen \int, introduce varios problemas. En particular, el comando provoca errores de llaves inesperados con ciertas entradas, como \[0^+\]al definir \myspecdef +- : \pm. Si bien una notación alternativa \[0^{+}\]resuelve este problema, no es un requisito ideal. Además, la sustitución afecta inadvertidamente la funcionalidad del carácter tilde ~, lo que genera errores como el número faltante, tratado como cero. Además, el uso de comandos como \operatornameproduce 'bad mathchar'errores debido a la inclusión de -en la definición.
Para abordar estos problemas y refinar el comportamiento del comando, la cuarta respuesta del hilo ofrece un enfoque alternativo utilizando la sintaxis expl3 como se ilustra a continuación:
\documentclass{article}
\usepackage{amsmath}
\usepackage{xparse}
\ExplSyntaxOn
\seq_new:N \l_math_subs_seq
\cs_new_protected:Npn \math_add_sub:nn #1 #2
{
\seq_put_right:Nn \l_math_subs_seq { { #1 } { #2 } }
}
\cs_new_protected:Npn \math_ascii_sub:n #1
{
\tl_set:Nn \l_tmpa_tl { #1 }
\seq_map_inline:Nn \l_math_subs_seq
{
\tl_replace_all:Nnn \l_tmpa_tl ##1
}
\tl_use:N \l_tmpa_tl
}
\cs_new_protected:Npn \math_grabinline:w #1 $
{
\math_ascii_sub:n { #1 } $
}
\cs_new_protected:Npn \math_grabdisplay:w #1 \]
{
\math_ascii_sub:n { #1 } \]
}
% Set substitutions (be careful with order!)
% Three letter sequences first
\math_add_sub:nn { <== } { \Leftarrow }
\math_add_sub:nn { <=> } { \Leftrightarrow }
\math_add_sub:nn { <-- } { \leftarrow }
\math_add_sub:nn { <-> } { \leftrightarrow }
\math_add_sub:nn { --> } { \rightarrow }
\math_add_sub:nn { ==> } { \Rightarrow }
\math_add_sub:nn { ... } { \dots }
% Then two letter sequences
\math_add_sub:nn { << } { \ll }
\math_add_sub:nn { <> } { \neq }
\math_add_sub:nn { <= } { \leq }
\math_add_sub:nn { >> } { \gg }
\math_add_sub:nn { >= } { \geq }
\math_add_sub:nn { -+ } { \mp }
\math_add_sub:nn { +- } { \pm }
\math_add_sub:nn { == } { \equiv }
\math_add_sub:nn { =. } { \doteq }
\math_add_sub:nn { =( } { \subseteq }
\math_add_sub:nn { =) } { \supseteq }
\math_add_sub:nn { =[ } { \sqsubseteq }
\math_add_sub:nn { =] } { \sqsubseteq }
% Enable substitutions for $...$ and \[...\]
\everymath { \math_grabinline:w }
\tl_put_right:Nn \[ { \math_grabdisplay:w }
\ExplSyntaxOff
\begin{document}
\centering
\newcommand*{\test}[1]{%
$#1$%
\[#1\]%
}
\test{a << b < c <= d >= e > f >> g}
\test{a <> b = c =. d == e}
\test{a <== b <-- c <-> d <=> e --> f ==> g}
\test{a +- b = -(-a -+ +b)}
\test{a, ..., z <> a + ...+ z}
\test{a =( b =) c =[ e =] f}
\end{document}
Si bien este método parece prometedor y resuelve algunos problemas presentados por el enfoque inicial, tiene sus propias limitaciones. En particular, el orden de las sustituciones afecta significativamente el resultado, lo que hace que la solución sea menos flexible y más engorrosa para un uso extensivo. Además, intenté crear un alias para \spec_add_sub:nn using \cs_new_eq:NN \mspecdef \spec_add_sub:nn, pero no funcionó como se esperaba fuera de \ExplSyntaxOn ... \ExplSyntaxOff.
Mi objetivo es perfeccionar esta personalización de LaTeX para obtener un sistema de sustitución de comandos más robusto y flexible, idealmente uno que pueda usarse convenientemente dentro del entorno del documento, ya que es posible que el acceso al preámbulo no siempre esté disponible. Entiendo que esta podría ser una solicitud desafiante o poco convencional, pero creo que presenta un problema fascinante para la comunidad LaTeX.
Agradezco cualquier idea, sugerencia o enfoque alternativo que pueda conducir a una solución mejorada. Gracias de antemano por su tiempo y ayuda.
Respuesta1
Mejoré el código LaTeX3 proporcionado en su pregunta y ahora soluciona dos de los problemas que enfrentó.
Permite un orden de sustitución arbitrario.
Esto es posible manteniendo un árbol de prefijos para los símbolos en LaTeX. La tabla de sustitución deseada se puede obtener a partir del recorrido posterior al pedido del árbol de prefijos. Sin embargo, debido a esto, cada vez que se inserta un nuevo símbolo, el usuario debe llamar
\math_sub_generate:para convertir el árbol de prefijos en una tabla de sustitución (por supuesto,\math_add_sub:nnsiempre puede llamar\math_sub_generate:)Soporta alias
Es probable que el comportamiento inconsistente se deba a diferencias de código de categoría entre el modo documento y el modo LaTeX3. Esto se puede corregir usando
\tl_set_rescan:Nnn.
Observe que en el código he cambiado el orden de los símbolos de 2 y 3 caracteres, y los resultados deberían seguir siendo correctos.
La tabla de sustitución final se muestra a continuación:
The sequence \l_math_subs_seq contains the items (without outer braces):
> {{<<}{\ll }}
> {{<>}{\neq }}
> {{<==}{\Leftarrow }}
> {{<=>}{\Leftrightarrow }}
> {{<=}{\leq }}
> {{<--}{\leftarrow }}
> {{<->}{\leftrightarrow }}
> {{>>}{\gg }}
> {{>=}{\geq }}
> {{-+}{\mp }}
> {{-->}{\rightarrow }}
> {{+-}{\pm }}
> {{==>}{\Rightarrow }}
> {{==}{\equiv }}
> {{=.}{\doteq }}
> {{=(}{\subseteq }}
> {{=)}{\supseteq }}
> {{=[}{\sqsubseteq }}
> {{=]}{\sqsubseteq }}
> {{...}{\dots }}
> {{@@@@@}{\mbox { }FIVE\mbox { }}}
> {{@@@@}{\mbox { }FOUR\mbox { }}}
> {{@@@}{\mbox { }THREE\mbox { }}}.
Código
\documentclass{article}
\usepackage{amsmath}
\usepackage{xparse}
\ExplSyntaxOn
\seq_new:N \l_math_subs_seq
\msg_new:nnn {math} {symbol-exists} {symbol~#1~already~exists}
\int_new:N \g_math_struct_counter
\int_gset:Nn \g_math_struct_counter {1}
\cs_new_protected:Npn \mathstruct_new:N #1
{
\tl_set:Nx #1 {l_mathstruct_internal_\int_use:N \g_math_struct_counter _prop}
\prop_new:c {#1}
\int_gincr:N \g_math_struct_counter
\prop_new:c {l_mathstruct_internal_\int_use:N \g_math_struct_counter _prop}
\prop_put:cnn {#1} {value} {}
\prop_put:cnn {#1} {exist} {\c_false_bool}
\prop_put:cnn {#1} {mapping} {}
\prop_put:cnx {#1} {children} {l_mathstruct_internal_\int_use:N \g_math_struct_counter _prop}
\int_gincr:N \g_math_struct_counter
}
\mathstruct_new:N \l_math_prefix_tree_root
\tl_new:N \l_math_children_prop_tl
\tl_new:N \l_math_tmpa_tl
\tl_new:N \l_math_tmpb_tl
\tl_new:N \l_math_tmpc_tl
\cs_new_protected:Npn \math__recursive_add_sub:nnnn #1#2#3#4
{
\str_if_empty:nTF {#2}
{
\prop_get:cnN {#1} {exist} \l_math_tmpa_tl
\exp_args:NV \bool_if:nTF {\l_math_tmpa_tl}
{
% if symbol alreasy exists, send a warning
\msg_warning:nnn {math} {symbol-exists} {#4}
}
{
% need to set this symbol as "exists" and set the mapping
\prop_put:cnn {#1} {exist} {\c_true_bool}
\prop_put:cnn {#1} {mapping} {#3}
}
}
{
\prop_get:cnN {#1} {children} \l_math_children_prop_tl
\str_set:Nx \l_math_tmpa_tl {\str_head:n {#2}}
% see if it is one of its children
\prop_if_in:cVTF {\l_math_children_prop_tl} \l_math_tmpa_tl
{
% if the node exists, continue recursively
\tl_set:Nx \l_math_tmpc_tl {\str_tail:n {#2}}
\prop_get:cVN {\l_math_children_prop_tl} \l_math_tmpa_tl \l_math_tmpb_tl
\math__recursive_add_sub:Vxnn \l_math_tmpb_tl {\str_tail:n {#2}} {#3} {#4}
}
{
% otherwise, need to create new node
\mathstruct_new:N \l_math_tmpb_tl
\prop_put:cnV {\l_math_tmpb_tl} {value} \l_math_tmpa_tl
\prop_put:cVV {\l_math_children_prop_tl} \l_math_tmpa_tl \l_math_tmpb_tl
% apply recursively
\math__recursive_add_sub:Vxnn \l_math_tmpb_tl {\str_tail:n {#2}} {#3} {#4}
}
}
}
\cs_generate_variant:Nn \math__recursive_add_sub:nnnn {Vxnn,VVVV}
\tl_new:N \l_math_add_tmpa_tl
\tl_new:N \l_math_add_tmpb_tl
\cs_new_protected:Npn \math_add_sub:nn #1 #2
{
\tl_set_rescan:Nnn \l_math_add_tmpa_tl {\cctab_select:N\c_code_cctab} {#1}
\tl_set_rescan:Nnn \l_math_add_tmpb_tl {\cctab_select:N\c_code_cctab} {#2}
\math__recursive_add_sub:VVVV \l_math_prefix_tree_root \l_math_add_tmpa_tl \l_math_add_tmpb_tl \l_math_add_tmpa_tl
}
% post order traversal
\cs_new_protected:Npn \math__sub_recursive_generate:nn #1#2
{
\group_begin:
% check children first
\prop_get:cnN {#1} {children} \l_math_children_prop_tl
\prop_map_inline:cn {\l_math_children_prop_tl}
{
\math__sub_recursive_generate:nn {##2} {#2##1}
}
% check current node
\prop_get:cnN {#1} {exist} \l_math_tmpa_tl
\bool_if:nT {\l_math_tmpa_tl}
{
\prop_get:cnN {#1} {mapping} \l_math_tmpb_tl
\tl_set_rescan:Nnn \l_math_tmpc_tl { \cctab_select:N \c_document_cctab } {#2}
\seq_gput_right:Nx \l_math_subs_seq { {\exp_not:V \l_math_tmpc_tl} {\exp_not:V \l_math_tmpb_tl} }
}
\group_end:
}
% traverse the tree to get the correct order
\cs_new_protected:Npn \math_sub_generate:
{
\seq_gclear:N \l_math_subs_seq
\exp_args:NV \math__sub_recursive_generate:nn \l_math_prefix_tree_root {}
}
\cs_new_protected:Npn \math_ascii_sub:n #1
{
\tl_set:Nn \l_tmpa_tl { #1 }
\seq_map_inline:Nn \l_math_subs_seq
{
\tl_replace_all:Nnn \l_tmpa_tl ##1
}
\tl_use:N \l_tmpa_tl
}
\cs_new_protected:Npn \math_grabinline:w #1 $
{
\math_ascii_sub:n { #1 } $
}
\cs_new_protected:Npn \math_grabdisplay:w #1 \]
{
\math_ascii_sub:n { #1 } \]
}
\cs_set_eq:NN \MathAddSub \math_add_sub:nn
\cs_set_eq:NN \MathGenSub \math_sub_generate:
% Enable substitutions for $...$ and \[...\]
\everymath { \math_grabinline:w }
\tl_put_right:Nn \[ { \math_grabdisplay:w }
\ExplSyntaxOff
\begin{document}
\centering
\newcommand*{\test}[1]{%
$#1$%
\[#1\]%
}
\MathAddSub{ << }{ \ll }
\MathAddSub{ <> }{ \neq }
\MathAddSub{ <= }{ \leq }
\MathAddSub{ >> }{ \gg }
\MathAddSub{ >= }{ \geq }
\MathAddSub{ -+ }{ \mp }
\MathAddSub{ +- }{ \pm }
\MathAddSub{ == }{ \equiv }
\MathAddSub{ =. }{ \doteq }
\MathAddSub{ =( }{ \subseteq }
\MathAddSub{ =) }{ \supseteq }
\MathAddSub{ =[ }{ \sqsubseteq }
\MathAddSub{ =] }{ \sqsubseteq }
\MathAddSub{ <== }{ \Leftarrow }
\MathAddSub{ <=> }{ \Leftrightarrow }
\MathAddSub{ <-- }{ \leftarrow }
\MathAddSub{ <-> }{ \leftrightarrow }
\MathAddSub{ --> }{ \rightarrow }
\MathAddSub{ ==> }{ \Rightarrow }
\MathAddSub{ ... }{ \dots }
\MathAddSub{ int }{ \int }
% generate the substitution table based on post-order traversal of the prefix tree
\MathGenSub
\ExplSyntaxOn
% show the substitution table
\seq_show:N \l_math_subs_seq
\ExplSyntaxOff
\test{a << b < c <= d >= e > f >> g}
\test{a <> b = c =. d == e}
\test{a <== b <-- c <-> d <=> e --> f ==> g}
\test{a +- b = -(-a -+ +b)}
\test{a, ..., z <> a + ...+ z}
\test{a =( b =) c =[ e =] f}
\test{int _a^b}
\test{@@@@@ @@@@ @@@}
\MathAddSub{ @@@ }{ \mbox{~}THREE\mbox{~} }
\MathAddSub{ @@@@ }{ \mbox{~}FOUR\mbox{~} }
\MathAddSub{ @@@@@ }{ \mbox{~}FIVE\mbox{~} }
% generate the substitution table again
\MathGenSub
\ExplSyntaxOn
% show the substitution table
\seq_show:N \l_math_subs_seq
\ExplSyntaxOff
\test{@@@@@ @@@@ @@@}
\end{document}