Shortest power set implementation Problem definition

Print out the powerset of a given set. For example:

[1, 2, 3] =&gt; [[], [1], [2], [3], [1, 2], [1, 3], [2, 3], [1, 2, 3]]


Each element is to be printed on a separate line, so the above example would be printed as:

[]
[1]
[2]
...
[1, 2, 3]


Example code (in D, python example here):

import std.stdio;

string[][] powerset(string[] set) {
    if (set.length == 1) {
        return [set, []];
    }

    string[][] ret;
    foreach (item; powerset(set[1 .. $])) {
        ret ~= set[0]~item;
        ret ~= item;
    }

    return ret;
}

void main(string[] argv) {
    foreach (set; powerset(argv[1 .. $]))
        writeln(set);
}


Input

Elements will be passed as arguments. For example, the example provided above would be passed to a program called powerset as:

powerset 1 2 3


Arguments will be alphanumeric.

Rules


No libraries besides io
Output does not have to be ordered
Powerset does not have to be stored, only printed
Elements in the set must be delimited (e.g. 1,2,3, [1,2,3] and ['1','2','3'] are acceptable, but 123 is not


Trailing delimiters are fine (e.g. 1,2,3, == 1,2,3)

Best is determined based on number of bytes


The best solution will be decided no less than 10 days after the first submission.
Mathematica 16

Code 

Subsets is native to Mathematica.

Column@Subsets@s


The code (without column) can be verified on WolframAlpha. (I had to use brackets instead of @; they mean the same thing.

Usage

s={1,2,3}
Column@Subsets@s






This method (55 chars) uses the approach suggested by @w0lf.

s #&amp;/@Tuples[{0,1},Length@s]/.{0:&gt;Sequence[]}//Column


Breakdown

Generate the tuples, composed of 0 and 1's of length Length[s]

Tuples[{0, 1}, Length@s]



  {{0, 0, 0}, {0, 0, 1}, {0, 1, 0}, {0, 1, 1}, {1, 0, 0}, {1, 0, 1}, {1,
     1, 0}, {1, 1, 1}}


Multiply the original list (vector) by each tuple:

s # &amp; /@ Tuples[{0, 1}, Length@s]



  {{0, 0, 0}, {0, 0, 3}, {0, 2, 0}, {0, 2, 3}, {1, 0, 0}, {1, 0, 3}, {1,
     2, 0}, {1, 2, 3}}


Delete the 0's. % is shorthand for "the preceding output".

%/. {0 :> Sequence[]}


  {{}, {3}, {2}, {2, 3}, {1}, {1, 3}, {1, 2}, {1, 2, 3}}


Display in column: