f[arg1, arg2,...,argN] vs. f[{arg1, arg2,...,argN}]

Question

I am trying to reproduce the API of a function (written in R) that accepts an arbitrary number of arguments and handles it the same way as it would handle a single argument that is a list of different data sets.

Is there a Mathematica idiom that allows a function to be defined so that:

f[ arg1, arg2, ..., argN ]

behaves the same as

f[ {arg1, arg2, ..., argN} ]

?

Answer 1

As described by Andy Ross in a comment, you can make a definition that preprocesses the argument(s) into a canonical form. Turning his example around simply to illustrate flexibility:

f[{args__}] := f[args]

f[args__] := Multinomial[args] / Plus[args]

f[{12, 7, 3}] == f[12, 7, 3]

True

This method is useful for more complicated preprocessing, but in simple cases such as this it is often easier to use Alternatives:

g[{args__} | args__] := Multinomial[args]/Plus[args]

g[{12, 7, 3}] == g[12, 7, 3]

True

Be aware that when using Alternatives you must manually order the patterns, for they are tried in sequence. The pattern args__ | {args__} would not work as desired because args__ will match {12, 7, 3} as a single argument.

Answer 2

There are many ways to handle this. The approach I would most likely take can be illustrated by the following example:

f[seqn : ___] := Module[{args = {seqn}},
    Switch[args,
       {{___}}, "List of args",
       {_}, "One arg",
       {_, __}, "Two or more args",
       {}, "No args"
    ]]

f[{x, y, z}]

(* ==> "List of args" *)

f[{x}]

(* ==> "List of args" *)

f[]

(* ==> "No args" *)

f[x]

(* ==> "One arg" *)

f[x, y, z]

(* ==> "Two or more args" *)

Of course, each application of this technique would replace the strings seen here with some action appropriate to its own needs.

Another approach is to write separate functions for each argument pattern you want to handle:

g[args : {___}] := "List of args"
g[] := "No args"
g[arg_] := "One arg"
g[arg_, rest__] := "Two or more args"

g[{x, y, z}]

(* ==> "List of args" *)

g[{x}]

(* ==> "List of args" *)

g[]

(* ==> "No args" *)

g[x]

(* ==> "One arg" *)

g[x, y, z]

(* ==> "Two or more args" *)