A function that accepts a pair or a list of pairs

In many circumstances it is practical and clear to do this with pattern matching.

Option 1

f[x : {{_, _} ..}] := f /@ x

f[{a_, b_}] := a^b

Now:

f[{p, q}]

p^q

f[{{a, b}, {c, d}, {e, f}}]

{a^b, c^d, e^f}

Option 2

The code above it written assuming that your function best operates on a single pair of values: the function is mapped over every pair individually. If however the function is written to more efficiently operate on the list of pairs then it would be better to consider f[{a, b}] as a special case rather than the other way around. For example:

f2[a : {{_, _} ..}] := Power @@ (a\[Transpose])
f2[x : {_, _}] := f2[{x}]

f2[{a, b}]
f2[{{a, b}, {c, d}, {e, f}}]

{a^b}

{a^b, c^d, e^f}

You could use := First @ f2[{x}] if you wish f2 to return a bare a^b in the first instance.

The second function is an order of magnitude faster on large packed arrays:

rnd = RandomReal[{1, 19}, {1500000, 2}];

f[rnd]  // Timing // First
f2[rnd] // Timing // First

1.514

0.141

Option 3

Yet another method is to use a single pattern that matches either form, using Alternatives. This method is less common, and may be less efficient than the other options, but it can be quite concise which I appreciate.

Using this the f2 function might be written like this:

f3[{a : {_, _} ..} | a : {_, _}] := Power @@ ({a}\[Transpose])

With a default configuration making this definition produces a message:

Pattern::patv: Name a used for both fixed and variable length patterns. >>

This is not an error but rather a warning that you may have made a mistake. I fairly frequently use pattern names for both fixed and variable length patterns therefore I either turn off or ignore this message.

Function is as f2 above:

f3[{a, b}]
f3[{{a, b}, {c, d}, {e, f}}]

{a^b}

{a^b, c^d, e^f}

---

A note on definition ordering

Normally multiple DownValues definitions (simple definitions with a pattern on the left side) are automatically ordered by apparent specificity. This is briefly described in the documentation page The Ordering Of Definitions. But, as stated there:

Although in many practical cases, Mathematica can recognize when one rule is more general than another, you should realize that this is not always possible. For example, if two rules both contain complicated conditions, it may not be possible to work out which is more general, and, in fact, there may not be a definite ordering. Whenever the appropriate ordering is not clear, Mathematica stores rules in the order you give them.

In the methods above Mathematica cannot decide the order of the patterns used and the definitions will be tried in the order given. It is important therefore to make the {{_, _} ..} definition first otherwise {{1, 2}, {3, 4}} would be incorrectly matched by {a_, b_}.

In the case of Option 3 patterns given in Alternatives are always matched in the order given and therefore must be ordered manually when order is important.

Pattern matching would be my preferred choice of implementation as well. As an alternative, observe the following:

{{{a, b}, {c, d}, {e, f}}} ~Flatten~ {1, 2}
(* {{a, b}, {c, d}, {e, f}} *)

{{a, b}} ~Flatten~ {1}
(* {{a, b}} *)

Knowing this, we can make a definition as:

f[x_] := g /@ {x} ~Flatten~ Range@ArrayDepth@x

where g is the function that does the computations on the sublists. Try it out:

f[{{a, b}, {c, d}}]
(* {g[{a, b}], g[{c, d}]} *)

f[{a, b}]
(* {g[{a, b}]} *)

f[{{a, b}}]
(* {g[{a, b}]} *)

Here is a short one

f[args_List] := Map[DoStuff, args, {-2}]

It works because the -2nd level is always the right one to apply the function:

f[{a1, b1}]
f[{{a1, b1}}]
f[{{a, b}, {c, d}}]
(*
Out[95]= DoStuff[{a1, b1}]

Out[96]= {DoStuff[{a1, b1}]}

Out[97]= {DoStuff[{a, b}], DoStuff[{c, d}]}
*)