How can I return a Sequence?

Question

Recently I had the need to redefine a certain symbol in my init.m so it would be automatically omitted from any lists it appears in. I decided to redefine it to an empty sequence, e.g. Locked = Sequence[], but that got me thinking. What if I wanted to return a sequence (not necessarily an empty one) in a := definition? Return doesn't have the SequenceHold attribute, and adding it in a package might cause problems, so what would I do?

EDIT: I think I've figured out what exactly causes me to have the problem. I've defined it to display a Message first to let me know whenever a package I'm importing attempts to "attack my computer". (It is trying to cause my computer to behave in a manner not consistent with my wishes, after all.) So I defined it as Locked := (Message[Locked::nope]; Sequence[]), but strangely it just returns Null. (It doesn't show a return value, but if I do {Locked}, it returns {Null}, and if I try to set it as an attribute it says that Null is not a valid attribute and doesn't set any of them.)

Answer 1

Calculate the List of results you wish to return and use Apply to replace the head:

listFn[a_, b___] := If[a > 0, {b}, {0}];
seqFn[args___] := Sequence @@ listFn[args];
f[1, seqFn[2, 3, 4, 5], 6]
f[1, seqFn[-2, 3, 4, 5], 6]

(*--> f[1, 3, 4, 5, 6] *)
(*--> f[1, 0, 6] *)

Here listFn represents the calculation of the results and does not need to be a separate function. The particular example above can be written more simply as

seqFn[a_, b___] := Sequence @@ If[a > 0, {b}, {0}]

Edit

It should be stressed that the method assumes listFn actually evaluates to the List of desired inputs; if not, the Head of the expression returned will be replaced with Sequence, perhaps with undesired results. In such a case, a method such as @Jens's may be used.

For instance if a is non-numeric, say a Symbol, in the example above, then you get

f[1, seqFn[x, 3, 4, 5], 6]
(*-> f[1, x > 0, {3, 4, 5}, {0}, 6] *)

Often one can construct a List of the actual results, though. (With thanks to @Mr.Wizard.)

Answer 2

Here is one idea:

Clear[sf, mySequence]

sf[x_] := If[x > 0, mySequence[8, 9], 0]

mySequence /: (h : Except[If])[x___, mySequence[y___], 
  z___] := h[x, y, z]

f[1, 2, sf[1], 4]

(* ==> f[1, 2, 8, 9, 4] *)

So I defined a sf function that returns the sequence as the result of an If statement. This is just an example, illustrating the general scenario that the result will be returned by some evaluation of the form returningHead[...,mySequence,...].

What gets returned is not a Sequence but instead an inert wrapper mySequence, which will be converted into a Sequence by the definition following mySequence /: - the only restriction being that I don't want it to be converted when it's in the last expression of my function, whose head was returningHead (specifically If in this example). In all other cases, mySequence will be converted to Sequence, as is illustrated by the last line.

Edit

The advantage of this wrapper approach combined with TagSetDelayed (the /: definition) is that you then have more fine-grained control over when mySequence gets delivered as a sequence. For example, you may be calling sf from inside a List as in the above example, but sometimes from inside a function f2 that can't deal with sequences. Then you can add f2 to the list in the Except statement to avoid errors in the processing of sf, until its output gets placed into the correct context.

Answer 3

Maybe I've missed the point, but a sequence in most ways is just another Mathematica expression, so consider just returning a sequence.

f[args___] := args
g[x, f[a, b, c], y]

g[x, a, b, c, y]

g[x, f[], y]

g[x, y]

Update

I have edited this answer to incorporate Mr. Wizard's observation that args in f[args___] := args is already a sequence and doesn't need to be wrapped with Sequence.

Answer 4

I hardly ever use this kind of stuff anymore, but here are some ideas

SetDelayed

To return a sequence using a function defined by SetDelayed, simply try

seqFu[] := Sequence[]

Or even

Clear[seqFu]
seqFu[args___] := Sequence[args];

There is a trap that you should be wary of here. The following may seem to work as expected

seqFu2[args___]:= Unevaluated[args]

seqFu2[1,2]

Sequence[1,2]

but the following does not produce a sequence

seqFu2[1]

1 

Other

You can also create sequences on the fly. Sometimes Unevaluated is useful for this. For example, you can do

CompoundExpression[args, Unevaluated[Sequence[]]]

Sequence[]

Or

Identity[Unevaluated[Sequence[]]]

Sequence[]