Definición de palabras clave reutilizables y fácilmente editables

Definición de palabras clave reutilizables y fácilmente editables

Estoy escribiendo un artículo en el que todavía no he tomado todas las decisiones estilísticas. Es decir, no he decidido qué palabras largas quiero abreviar y cómo quiero abreviarlas, si el autor del artículo es un "yo", un "nosotros", un "el autor" o los "autores", etc. Entonces, lo que quiero hacer es definir algunas palabras clave que se reutilizarán muchas veces.

Quiero en la parte superior de mi documento hacer algo como \newcommand{\auth}{we}y cada vez que escriba \auth{}en mi documento debería aparecer la palabra "nosotros". Ahora, los más experimentados notarán que lo que estoy describiendo aquí en realidad hará lo que quiero, pasando a la verdadera pregunta.

Lo que realmente quiero hacer es vincular una palabra en el diccionario de inglés a un comando y, al pasar un argumento a ese comando, poder cambiar ligeramente su salida. Entonces, por ejemplo, si defino \auth{}escupir "nosotros", quiero \auth{upper}escupir "Nosotros" en su lugar. También me gustaría poder obtener formas posesivas como "Nuestro" y "nuestro" llamando \auth{upper, possessive}, \auth{possessive}o algo similar. ¿Cuál sería la mejor manera de lograrlo? ¿Puedo crear una especie de diccionario o qué recomiendas?

¡Muchas gracias!

Respuesta1

Bueno, lo he intentado. Por cierto, sólo funciona en LuaLaTeX:

%!TEX program = lualatex
\documentclass{article}
\usepackage{polyglossia}
\usepackage{luacode}
\begin{luacode*}
dofile(kpse.find_file("l-lpeg.lua"))
dofile(kpse.find_file("util-sto.lua"))
dofile(kpse.find_file("util-prs.lua"))
Pronouns = {
    ["formal"] = {
        ["possessive"] = "ours",
        ["nominative"] = "we",
        ["oblique"] = "us"
    },
    ["informal"] = {
        ["possessive"] = "mine",
        ["nominative"] = "I",
        ["oblique"] = "me"
    }
}
function Auth(keywords)
    local dummy = utilities.parsers.settings_to_array(keywords)
    for i,v in ipairs(dummy) do
        if Pronouns[dummy[i]] ~= nil then result = Pronouns[dummy[i]] end
    end
    for i,v in ipairs(dummy) do
        if result[dummy[i]] ~= nil then result = result[dummy[i]] end
    end
    return result
end
function Upper(string)
    return unicode.utf8.upper(unicode.utf8.sub(string,1,1))..unicode.utf8.sub(string,2,utf8.len(string))
end
\end{luacode*}
\def\auth#1{\directlua{tex.print(Auth("#1"))}}
\def\Auth#1{\directlua{tex.print(Upper(Auth("#1")))}}
\begin{document}
\auth{oblique,informal} \Auth{formal,possessive}
\end{document}

Respuesta2

Esto fue sorprendentemente complejo, pero aquí hay una solución que funciona con cualquier TeX*

\begingroup
\catcode`!=11 % for private macros
\endlinechar=-1
\catcode`\^^M=12 \catcode`\^^?=12\relax
\gdef\!stop{^^?}
\gdef\!fi{\fi}
\newtoks\!before \newtoks\!after

% some convenient shorthands
\gdef\!csnm#1{\csname#1\endcsname} 
\gdef\!ecsnm#1#2{\expandafter#1\csname#2\endcsname}

% the main command sets up the catcodes for reading in
% the definitions of the second argument
\gdef\newvarcommand#1{
  \begingroup\catcode`\^^M=12 \catcode`\^^?=12\relax
  {\escapechar=-1 \xdef\!name{\string#1}}
  \!ecsnm\newtoks{toks:\!name}
  \gdef#1##1{
    {\escapechar=-1 \xdef\!name{\string#1}}
    \begingroup
    \!processnextkey##1,^^?,
    \!ecsnm\the{toks:\!name}
    \!result
    \endgroup
  }
  \!newvarcommand
}

% for each modifier in the argument, set the corresponding
% conditional true
\gdef\!processnextkey#1,{\def\arg{#1}
  \ifx\!stop\arg\else
    \ifx\empty\arg\def\!key{default}\else\def\!key{#1}\fi
    \!ecsnm\ifx{ifkey:\!name:\!key}\relax
      \errmessage{Unknown key \!key\space for command \!name}
    \else\!csnm{key:\!name:\!key true}\fi
  \expandafter\!processnextkey\fi
}

% here we read the argument line by line
\gdef\!newvarcommand#1{\!getnext#1^^M^^?^^M}
\gdef\!getnext#1^^M{\def\arg{#1} 
  \ifx\!stop\arg\endgroup\else
  \ifx\empty\arg\else\!parse#1^^M\fi
  \expandafter\!getnext\fi
}

% for each entry, new conditionals are created to test whether a
% modifier is present or not, and a token list containing the
% conditionals and the word to be printed is appended to the
% token list read by the command to be defined
\gdef\!parse#1:#2^^M{\!before={}\!after={}\def\arg{#1}
  \ifx\empty\arg
    {\globaldefs=1 \!ecsnm\newif{ifkey:\!name:default}}
    \!before=\expandafter{\csname ifkey:\!name:default\endcsname}
    \!after=\expandafter{\!fi}
  \else\!setupnextkey#1,^^?,\fi
  \edef\!addtoks{\!ecsnm\the{toks:\!name}
    \the\!before\def\noexpand\!result{#2}\the\!after}
  \global\!csnm{toks:\!name}=\expandafter{\!addtoks}
}

% creating \newifs for each modifier
\gdef\!setupnextkey#1,{\def\arg{#1}
  \ifx\!stop\arg\else
    {\globaldefs=1 \!ecsnm\newif{ifkey:\!name:#1}}
    \!before=\expandafter{\the\expandafter\expandafter
      \expandafter\!before\!csnm{ifkey:\!name:#1}}
    \!after=\expandafter{\the\expandafter\!after\!fi}
  \expandafter\!setupnextkey\fi
}
\endgroup

Luego puede definir su "diccionario" de la siguiente manera:

\newvarcommand\auth{
  :we
  upper:We
  possessive:ours
  upper,possessive:Ours
}

En cada línea, escribe las palabras separadas por comas que desea usar como argumentos y luego, después de dos puntos, la palabra que debe aparecer. El valor predeterminado se puede especificar con :valo default:val.Importante:Las entradas deben ocurrir en el orden del número creciente de especificadores (es decir, debe tener todas las entradas de una palabra primero, luego las que tienen dos palabras separadas por comas, luego tres y así sucesivamente); de lo contrario, podría obtener resultados incorrectos.

\auth{} \auth{default} % these two are the same, "we"
\auth{upper} % "We"
\auth{possessive} % "ours"
\auth{upper,possessive} \auth{possessive,upper} % both "Ours"
\auth{lower} % this gives an "Unknown key" error

Déjame explicarte en la upper,possessive:Ourslínea cómo funciona el código. Básicamente, cuando se lee la línea, primero crea condicionales \ifkey:auth:uppery \ifkey:auth:possessive. Luego, una lista de tokens

\ifkey:auth:upper
  \ifkey:auth:possessive
    \def\!result{Ours}
  \fi
\fi

se construye y se agrega a una lista de tokens denominada \toks:auth. Si usa \auth{upper,possessive}, se leen los argumentos y los condicionales correspondientes \ifkey:auth:uppery ifkey:auth:possessivese establecen en verdadero, la toks:authlista de tokens se descomprime y \!resultse imprime.


*Sin embargo, se supone que no es externo \newif, como en LaTeX, pero para TeX simple serían necesarias algunas adaptaciones.

información relacionada