Kdtyjb

Summary. This answer (which I have been expanding upon in several iterations) describes how one may take a single character (such as "), make it active, and use it to produce alternative single-character control sequences (such "a) which behave much like a normal control sequence might.

(#1) Repurposing a typical non-letter character. If you're not using any package which redefines " for its own purposes, you can use it to define an alternative namespace for macros, as follows.

makeatletter



   catcode`"=13



   def"#1{csname @mymacro#1endcsname}



   defnewmacro"#1{%

       @ifnextchar [{%

           expandafternewcommandcsname @mymacro#1endcsname

        }{%

            expandafterdefcsname @mymacro#1endcsname{%

                csname @@mymacro#1endcsnameignorespaces}%

            expandafternewcommandcsname @@mymacro#1endcsname

        }}



   defrenewmacro"#1{%

       @ifnextchar [{%

           expandafterrenewcommandcsname @mymacro#1endcsname

        }{%

            expandafterdefcsname @mymacro#1endcsname{%

                csname @@mymacro#1endcsnameignorespaces}%

            expandafterrenewcommandcsname @@mymacro#1endcsname

        }}



makeatother

What this does is make " active (interpreted as a single-character control sequence), and then provides a definition for it which causes "a or "q (for instance) to invoke the control sequences @mymacroa and @mymacroq, respectively. The macros newmacro and renewmacro provide a simple interface for defining the macros invoked using the " character, with the syntax newmacro"a{...}, renewmacro"q{...}, etc. using syntax similar to newcommand and renewcommand, including any (optional) arguments that you want. We perform some extra testing when the macros are defined, to check whether they take arguments: if not, we add an extra layer of commands with a trailing ignorespaces to ensure that any white-space after the macros "a or "q (or whatever) is consumed.

If you need to interoperate with babel or another package which provides a special meaning for ", you may need to use a different character — which you use is at your discretion, although it should be a character with catcode 12 (or if you're daring, a letter which normally has catcode 11 if there's a letter which is almost never used in the language of your document, e.g. w in French). One can also adopt a multi-character solution (e.g. such as the one exhibited in Christian Lindig's solution for quickly switching to bold typeface). But multi-character solutions will probably defeat the purpose if you're particularly concerned with number of keystrokes and such.

(#2) Limited repurposing of a special character. I notice in the comments that you are mostly interested in using these alternative macros in math-mode. This allows us to make use of further techniques. At the same time, the limited scope makes it feasible to be more adventurous in the character which we usurp for the purpose.

In this case, I will show how to achieve a similar effect as above using the # character, which is normally involved in enumerating arguments to macros. What we will do is make # active only within mathmode (and displayed environments), where a prudent LaTeX user can usually refrain from defining new macros. This will also involve some cosmetic differences to the way that we implement the interface.

makeatletter



   catcode`#=13

   catcode`$=6

      def#$1{csname @mymacro$1endcsname}

   catcode`$=3

   catcode`#=6



   defnewmacro##1{%

       @ifnextchar [{%

           expandafternewcommandcsname @mymacro#1endcsname

        }{%

            expandafterdefcsname @mymacro#1endcsname{%

                csname @@mymacro#1endcsnameignorespaces}%

            expandafternewcommandcsname @@mymacro#1endcsname

        }}



   defrenewmacro##1{%

       @ifnextchar [{%

           expandafterrenewcommandcsname @mymacro#1endcsname

        }{%

            expandafterdefcsname @mymacro#1endcsname{%

                csname @@mymacro#1endcsnameignorespaces}%

            expandafterrenewcommandcsname @@mymacro#1endcsname

        }}



makeatother



everymath=expandafter{theeverymathcatcode`#=13}

everydisplay=expandafter{theeverydisplaycatcode`#=13}

The first few commands define what the character # does when it is active: i.e. the same thing that " did in the example before. To do this, we make # active, and temporarily make $ the character which denotes arguments to macros. We then restore the usual meanings of # and $ before proceeding, if only to prevent headaches.

One will typically define macros in the pre-amble, which is ipso facto outside of math-mode. So, we will need a slightly different syntax for defining macros with newmacro and renewmacro which does not assume that # is active (not to mention that # may be needed to describe arguments!). The simplest approach is to use the syntax newmacro#a{something} or renewmacro#q[1]{something}, using the command sequence # as part of the syntax of these commands. Note that these commands can also be used in the document body, in normal text mode.

Finally, we redefine the hooks everymath and everydisplay, which are invoked whenever you use $ math mode $ or [ displayed math ] (including the environments provided by the amsmath package), to make # an active character. Its normal status as the character denoting arguments are restored when one leaves math/display mode.

If you wish, try the following in a document body to try out this code, in a document with the code above and which uses the amsmath package. This is intended to demonstrate the faithful interoperation of this code with mathmode and with subsequent definition of macros.

begin{document}

newmacro#a[2]{#1 stackrel?= #2}



$ #abc $



begin{align}

  begin{gathered}

            #a 1 2  \

            #a {mathsf{P}}{mathsf{NP}}

  end{gathered}

    & &

        #ask

end{align}



newcommandtest[2][bfseries]{textsf{#1 #2}}

test{bold and sans-serif}

test[itshape]{italic and sans-serif}

end{document}

(#3) Remarks on these techniques. The macros defined in this way will behave differently than normal control sequences, as the example with # illustrates. Specifically, the mechanism I've described here really is designed for single-character macro names.

Taking the example where we make " active for the sake of discussion: the source-code "abc will expand to @mymacroa bc rather than @mymacroabc. (The name of the "macro" stops at the very first argument to the " character, which is a in this case.) And if you try to define a macro using newmacro"abc{something}, the effect will be the same as writing

newmacro"a{b}%

c{something}

rather than defining a macro @newmacroabc which produces {something}.

You can define macros with longer names such as newmacro"{abc}, but that's silly. Alternatively, you can define " to try and obtain as many letter-characters (having catcode 11) as possible to constitute the name of a macro, as Bruno has done in another answer. But I'm not really interested in doing so, especially as the point is to define alternative single-character macros. This is already a non-standard mechanism; without further motivation, one should have in mind a specific idea of a special case when one should want to use it. I present the solution for when that special case is "access to extremely short macro names".

Having worked at an academic publisher for years, I want to remark that in my opinion, such macros are a terrible nuisance. Your input may be consistent with itself, but it will not be consistent with anyone else's.

But if you absolutely have to define syntactical macros for some (to me) unfathomable reason, then by far the best ones are those that actually describe their content. These are not generally the shortest ones, but at least then when another person has to edit your text, the input syntax gives clues to the produced output. For example:

A in Q

is somewhat reasonable if Q is mathbb{Q}, but

theta neq Q

I consider bad whatever the definition of Q is.

Macros that use active characters instead of backlash are absolutely horrible, and for much these same reason: imagine editing someone else's file where stuff like a simple @ sign suddenly is a macro.

Secondary argument: in some workflows, your actual TeX input can become part of the result (for example as alternate text for a bitmap in a html/epub view). none of the macro definitions will survive, so the reader (even one that understands LaTeX well) would have to make a guess at the intended meaning.

A typical way of getting special effects in math mode is to set the "mathcode" of some characters to "8000. TeX looks at the mathcode when encountering a character of category code 11 (letter) or 12 (other). Normally, the mathcode indicates what character of the font should be used, as well as its family (responsible for the spacing), but the special value "8000 tells TeX to treat the charcter instead as if it were active.

EDIT: I had earlier some code which read token by token, stopping at the first non-letter, and making a control sequence out of what was found. Niel points out that it is rather useless since we want short macro names. I replaced it by a more useful feature: now, the active character used will typeset itself if followed by a space token.

makeatletter

newcommand{@sm}[1]

  {edef@sm@char{string #1}futurelet@let@token@sm@test}

newcommand{@sm@test}

  {ifx @sptoken@let@token

     csname @sm@@sm@charendcsname

   else

     expandafter@sm@do

   fi}

newcommand{@sm@do}[1]

  {csname @sm@@sm@char @#1endcsname}



newcommand{newshortmacro}[1]

  {expandafter@sm@newcsname @sm@string #1endcsname #1}

newcommand{@sm@new}[3]

  {ifx#1relax

    mathchardef#1mathcode`#2relax

    begingroup

    lccode`~=`#2relax

    lowercase{endgroupdef~{@sm{#2}}}%

    AtBeginDocument{mathcode`#2="8000 }%

   fi

   expandafternewcommandcsname @sm@string #2@string #3endcsname

  }

makeatother



% Used as

documentclass{amsart}

newshortmacro`l[1]{({#1}_1,{#1}_2,ldots,{#1}_n)}

newshortmacro!C{mathbb{C}}

newshortmacro!Q{mathbb{Q}}

newshortmacro!R{mathbb{R}}

newshortmacro!({begin{pmatrix}}

newshortmacro!){end{pmatrix}}

newshortmacro?I{mathcal{I}}

newshortmacro?>{supseteq}

newshortmacro.c{cdots}

newshortmacro.d{ddots}

newshortmacro.v{vdots}

newcommand{be}{begin{equation}}

newcommand{ee}{end{equation}}

begin{document}

There are many examples of fields: (!C?>!R?>.c?>!Q).

And a very nice matrix:

be ?I=!(1&0&.c&0\0&1&.d&.v\.v&.d&.d&0\0&.c&0&1!),! ee

end{document}

I'm not convinced that this is very readable.

The macros , 1, ..., 9 are generally regarded as userspace scratch csnames: you can repurpose them as short macro names in the way that you want.

You can define a macro that lets all these macro names be equal to the long csname you used in their definitions, and if you are worried that some badly behaved package is repurposing them, then you can have another macro that tests that equality with the long csname, using ifx, has not been violated.

Again this is not really an answer to the question, but if you really want to save on keystrokes, then perhaps a better option to catcode-fu is to use a smart text editor. For example emacs has a funky LaTeX-math-abbrev-prefix which is ` by default.

This gives you access to a bunch of mathmode symbols in two keystrokes. For example, you can get
subset
by typing ` {

By customising LaTeX-math-list you can get whatever you like out of this prefix command.

Vim with some snippet add-on can almost certainly achieve the same thing. I don't know what other editors will allow you this sort of prefix key control, but I'm sure there are others. If you're interested in efficiency to the level of worrying about a handful of keystrokes, then I think this is a better option than fiddling with making other characters active...

Postscript: The weird paragraphing was needed to allow ` to display properly. I really hit the limits of markdown typing this...

There's the at package by Mark Wooding. It makes possible to say

newatcommand X{Whatever you like}

newatcommand Y[2]{Whatever you like with #1 and #2}

and then use @X or @Y{a}{b}. However this is likely to conflict with hyperref (the package is quite old and not developed any more), so it's best not to use the newly defined @-commands in moving arguments. But one can at least try.

A completely different approach, which saves keystrokes while maintaining full portability and avoiding definitional conflicts, is to create keyboard shortcuts using a 3rd-party task automation or text expander program. I use Keyboard Maestro (KM) for Mac, but equivalent apps may be available for Windows and Linux.

For example, I've configured KM so that, when I'm working in my favored TeX editor, and press CtrlT, the macro pastes the following where my cursor is:

ensuremath{text{ }}

Here's a screenshot of the macro. Simple ones like this are quite easy to write; the only wrinkle was that I had to escape the backslashes: