Say I have a macro that does *something* in math mode (say, change the mathalphabet). This macro, `\somecommand`

, takes one argument. I might want use is like this, feeding an empty argument into it: `\(\somecommand{} +x\)`

. I also want the plus sign before `x`

to be a unary operator.

I find that whether a plus or minus sign is considered unary or binary is, while clear in theory, not always *obvious* upon first inspection:

```
\documentclass{article}
\newcommand{\zeroArgCommand}{}
\newcommand{\oneArgCommand}[1]{}
\begin{document}
\noindent
\( +x\) \\ % unary: "+x"
\(\zeroArgCommand +x\) \\ % unary: "+x"
\(\zeroArgCommand{} +x\) \\ % binary: " + x"
\(\oneArgCommand{} +x\) \\ % unary: "+x"
\(\oneArgCommand{}{} +x\) \\ % binary: " + x"
\end{document}
```

In the light of this, I am wondering about the **best way of defining a unary plus/minus sign**.

Intuitively I would write `\(\somecommand{} {+} x\)`

or `\(\somecommand{} {+ x}\)`

, but I am wondering about expert opinion about a method that for sure works in all contexts.

*This question was posed because in another thread, a user suggested that defining a \unaryplus macro is clearer than \somecommand {+} x. (I think what that commenter had in mind was that the reader might not be familiar with the arity of \somecommand.)*

**Addendum:** Is there a good way to define a macro `\genuineunaryplus`

that produces a `+`

but that in a context `<before>\genuineunaryplus<after>`

attaches to `<after>`

as a unary operator but has spacing to `<before>`

exactly as if the `\genuineunaryplus`

were not there? That is, a macro such that if the spacing between `<B> <A>`

is of length/type L, the expression `<B>\genuineunaryplus<A>`

will produce `<B> +<A>`

in the output, with the spacing between `<B>`

and `+`

exactly like the spacing would be between `<B>`

and `<A>`

if the `\genuineunaryplus`

were not there, namely L?

**Answer idea for addendum:** David Carlisle's comment below outlines a possible answer for this addendum.

## Best Answer

The inspection of the math list happens

afterexpansion (and after assignments). It is an extra stage just applicable to math mode that converts the math list into a horizontal list that is then typeset as a normal horizontal list.So there is no real connection between the macro structure and the math spacing, It does not matter whether the thing to the left of the

`+`

has arguments or not, it just matters what it expands to (nothing in your example) so your example is equivalent toand as your comments show a binop like

`+`

gets binary spacing if it is between two mathord atoms such as`{}`

or`x`

.Your example (from elsewhere, with

`\somecommand`

being a zero-argument macro)is

Here the

`{+}`

construct makes a mathord so you get no spacing. My comment that this was probably bad markup was mainly related to the trailing`{}`

after`\somecommand`

it is OK to do that habitually in text mode to avoid dropping spaces but in math mode it's usually has an effect.is

so here the math list has two, not three, mathord atoms:

`{}`

and`+x`

. In this simple case it doesn't affect the spacing, but the inner expression is a single atom, so`{+x}`

(and not`x`

) would take any superscripts etc, and as it is an inner list linebreaking is suppressed and any white space is forced to its natural width (again not relevant here); basically in math node`{...}`

is a box command like`\hbox{....}`

.There are in fact two choices for a unary math sign, a mathord or a mathop, it's easy to get an ad hoc mathord by using

`{+}`

but it is probably more consistent to declare the operators explicitly.As you see from (1) if two binop atoms are adjacent the second one effectively turns into a mathord so you get the spacing as in (2) or (3) although arguably as a prefix operator giving it mathop spacing (with a small gap before its argument) is more consistent.

either way you don't want to be filling you document expressions with weird

`{}`

constructs and`\mathxx`

primitives, just defineor whatever version you like and then use

and it will all work out OK.