1) Change default gofmt default settings for

                  parsing and printing to new syntax.

                  Use -oldparser to parse the old syntax,
                  use -oldprinter to print the old syntax.

               2) Change default gofmt formatting settings
                  to use tabs for indentation only and to use
                  spaces for alignment. This will make the code
                  alignment insensitive to an editor's tabwidth.

                  Use -spaces=false to use tabs for alignment.

               3) Manually changed src/exp/parser/parser_test.go
                  so that it doesn't try to parse the parser's
                  source files using the old syntax (they have
                  new syntax now).

               4) gofmt -w src misc test/bench

	       2nd set of files.

R=rsc
CC=golang-dev
http://codereview.appspot.com/179067

1 files changed, 151 insertions, 151 deletions

diff --git a/src/pkg/exp/iterable/iterable_test.go b/src/pkg/exp/iterable/iterable_test.go
index 242a725a9..1d60d4b91 100644
--- a/src/pkg/exp/iterable/iterable_test.go
+++ b/src/pkg/exp/iterable/iterable_test.go
@@ -5,42 +5,42 @@
 package iterable
 
 import (
-	"container/vector";
-	"testing";
+	"container/vector"
+	"testing"
 )
 
 func TestArrayTypes(t *testing.T) {
 	// Test that conversion works correctly.
-	bytes := ByteArray([]byte{1, 2, 3});
+	bytes := ByteArray([]byte{1, 2, 3})
 	if x := Data(bytes)[1].(byte); x != 2 {
 		t.Error("Data(bytes)[1].(byte) = %v, want 2", x)
 	}
-	ints := IntArray([]int{1, 2, 3});
+	ints := IntArray([]int{1, 2, 3})
 	if x := Data(ints)[2].(int); x != 3 {
 		t.Error("Data(ints)[2].(int) = %v, want 3", x)
 	}
-	floats := FloatArray([]float{1, 2, 3});
+	floats := FloatArray([]float{1, 2, 3})
 	if x := Data(floats)[0].(float); x != 1 {
 		t.Error("Data(floats)[0].(float) = %v, want 1", x)
 	}
-	strings := StringArray([]string{"a", "b", "c"});
+	strings := StringArray([]string{"a", "b", "c"})
 	if x := Data(strings)[1].(string); x != "b" {
 		t.Error(`Data(strings)[1].(string) = %q, want "b"`, x)
 	}
 }
 
 var (
-	oneToFive	= IntArray{1, 2, 3, 4, 5};
-	sixToTen	= IntArray{6, 7, 8, 9, 10};
-	elevenToTwenty	= IntArray{11, 12, 13, 14, 15, 16, 17, 18, 19, 20};
+	oneToFive      = IntArray{1, 2, 3, 4, 5}
+	sixToTen       = IntArray{6, 7, 8, 9, 10}
+	elevenToTwenty = IntArray{11, 12, 13, 14, 15, 16, 17, 18, 19, 20}
 )
 
-func isNegative(n interface{}) bool	{ return n.(int) < 0 }
-func isPositive(n interface{}) bool	{ return n.(int) > 0 }
-func isAbove3(n interface{}) bool	{ return n.(int) > 3 }
-func isEven(n interface{}) bool		{ return n.(int)%2 == 0 }
-func doubler(n interface{}) interface{}	{ return n.(int) * 2 }
-func addOne(n interface{}) interface{}	{ return n.(int) + 1 }
+func isNegative(n interface{}) bool     { return n.(int) < 0 }
+func isPositive(n interface{}) bool     { return n.(int) > 0 }
+func isAbove3(n interface{}) bool       { return n.(int) > 3 }
+func isEven(n interface{}) bool         { return n.(int)%2 == 0 }
+func doubler(n interface{}) interface{} { return n.(int) * 2 }
+func addOne(n interface{}) interface{}  { return n.(int) + 1 }
 func adder(acc interface{}, n interface{}) interface{} {
 	return acc.(int) + n.(int)
 }
@@ -49,13 +49,13 @@ func adder(acc interface{}, n interface{}) interface{} {
 type integerStream struct{}
 
 func (i integerStream) Iter() <-chan interface{} {
-	ch := make(chan interface{});
+	ch := make(chan interface{})
 	go func() {
 		for i := 0; ; i++ {
 			ch <- i
 		}
-	}();
-	return ch;
+	}()
+	return ch
 }
 
 func TestAll(t *testing.T) {
@@ -78,236 +78,236 @@ func TestAny(t *testing.T) {
 
 func assertArraysAreEqual(t *testing.T, res []interface{}, expected []int) {
 	if len(res) != len(expected) {
-		t.Errorf("len(res) = %v, want %v", len(res), len(expected));
-		goto missing;
+		t.Errorf("len(res) = %v, want %v", len(res), len(expected))
+		goto missing
 	}
 	for i := range res {
 		if v := res[i].(int); v != expected[i] {
-			t.Errorf("res[%v] = %v, want %v", i, v, expected[i]);
-			goto missing;
+			t.Errorf("res[%v] = %v, want %v", i, v, expected[i])
+			goto missing
 		}
 	}
-	return;
+	return
 missing:
-	t.Errorf("res = %v\nwant  %v", res, expected);
+	t.Errorf("res = %v\nwant  %v", res, expected)
 }
 
 func TestFilter(t *testing.T) {
-	ints := integerStream{};
-	moreInts := Filter(ints, isAbove3).Iter();
-	res := make([]interface{}, 3);
+	ints := integerStream{}
+	moreInts := Filter(ints, isAbove3).Iter()
+	res := make([]interface{}, 3)
 	for i := 0; i < 3; i++ {
 		res[i] = <-moreInts
 	}
-	assertArraysAreEqual(t, res, []int{4, 5, 6});
+	assertArraysAreEqual(t, res, []int{4, 5, 6})
 }
 
 func TestFind(t *testing.T) {
-	ints := integerStream{};
-	first := Find(ints, isAbove3);
+	ints := integerStream{}
+	first := Find(ints, isAbove3)
 	if first.(int) != 4 {
 		t.Errorf("Find(ints, isAbove3) = %v, want 4", first)
 	}
 }
 
 func TestInject(t *testing.T) {
-	res := Inject(oneToFive, 0, adder);
+	res := Inject(oneToFive, 0, adder)
 	if res.(int) != 15 {
 		t.Errorf("Inject(oneToFive, 0, adder) = %v, want 15", res)
 	}
 }
 
 func TestMap(t *testing.T) {
-	res := Data(Map(Map(oneToFive, doubler), addOne));
-	assertArraysAreEqual(t, res, []int{3, 5, 7, 9, 11});
+	res := Data(Map(Map(oneToFive, doubler), addOne))
+	assertArraysAreEqual(t, res, []int{3, 5, 7, 9, 11})
 }
 
 func TestPartition(t *testing.T) {
-	ti, fi := Partition(oneToFive, isEven);
-	assertArraysAreEqual(t, Data(ti), []int{2, 4});
-	assertArraysAreEqual(t, Data(fi), []int{1, 3, 5});
+	ti, fi := Partition(oneToFive, isEven)
+	assertArraysAreEqual(t, Data(ti), []int{2, 4})
+	assertArraysAreEqual(t, Data(fi), []int{1, 3, 5})
 }
 
 func TestTake(t *testing.T) {
-	res := Take(oneToFive, 2);
-	assertArraysAreEqual(t, Data(res), []int{1, 2});
-	assertArraysAreEqual(t, Data(res), []int{1, 2});	// second test to ensure that .Iter() returns a new channel
+	res := Take(oneToFive, 2)
+	assertArraysAreEqual(t, Data(res), []int{1, 2})
+	assertArraysAreEqual(t, Data(res), []int{1, 2}) // second test to ensure that .Iter() returns a new channel
 
 	// take none
-	res = Take(oneToFive, 0);
-	assertArraysAreEqual(t, Data(res), []int{});
+	res = Take(oneToFive, 0)
+	assertArraysAreEqual(t, Data(res), []int{})
 
 	// try to take more than available
-	res = Take(oneToFive, 20);
-	assertArraysAreEqual(t, Data(res), oneToFive);
+	res = Take(oneToFive, 20)
+	assertArraysAreEqual(t, Data(res), oneToFive)
 }
 
 func TestTakeWhile(t *testing.T) {
 	// take some
-	res := TakeWhile(oneToFive, func(v interface{}) bool { return v.(int) <= 3 });
-	assertArraysAreEqual(t, Data(res), []int{1, 2, 3});
-	assertArraysAreEqual(t, Data(res), []int{1, 2, 3});	// second test to ensure that .Iter() returns a new channel
+	res := TakeWhile(oneToFive, func(v interface{}) bool { return v.(int) <= 3 })
+	assertArraysAreEqual(t, Data(res), []int{1, 2, 3})
+	assertArraysAreEqual(t, Data(res), []int{1, 2, 3}) // second test to ensure that .Iter() returns a new channel
 
 	// take none
-	res = TakeWhile(oneToFive, func(v interface{}) bool { return v.(int) > 3000 });
-	assertArraysAreEqual(t, Data(res), []int{});
+	res = TakeWhile(oneToFive, func(v interface{}) bool { return v.(int) > 3000 })
+	assertArraysAreEqual(t, Data(res), []int{})
 
 	// take all
-	res = TakeWhile(oneToFive, func(v interface{}) bool { return v.(int) < 3000 });
-	assertArraysAreEqual(t, Data(res), oneToFive);
+	res = TakeWhile(oneToFive, func(v interface{}) bool { return v.(int) < 3000 })
+	assertArraysAreEqual(t, Data(res), oneToFive)
 }
 
 func TestDrop(t *testing.T) {
 	// drop none
-	res := Drop(oneToFive, 0);
-	assertArraysAreEqual(t, Data(res), oneToFive);
-	assertArraysAreEqual(t, Data(res), oneToFive);	// second test to ensure that .Iter() returns a new channel
+	res := Drop(oneToFive, 0)
+	assertArraysAreEqual(t, Data(res), oneToFive)
+	assertArraysAreEqual(t, Data(res), oneToFive) // second test to ensure that .Iter() returns a new channel
 
 	// drop some
-	res = Drop(oneToFive, 2);
-	assertArraysAreEqual(t, Data(res), []int{3, 4, 5});
-	assertArraysAreEqual(t, Data(res), []int{3, 4, 5});	// second test to ensure that .Iter() returns a new channel
+	res = Drop(oneToFive, 2)
+	assertArraysAreEqual(t, Data(res), []int{3, 4, 5})
+	assertArraysAreEqual(t, Data(res), []int{3, 4, 5}) // second test to ensure that .Iter() returns a new channel
 
 	// drop more than available
-	res = Drop(oneToFive, 88);
-	assertArraysAreEqual(t, Data(res), []int{});
+	res = Drop(oneToFive, 88)
+	assertArraysAreEqual(t, Data(res), []int{})
 }
 
 func TestDropWhile(t *testing.T) {
 	// drop some
-	res := DropWhile(oneToFive, func(v interface{}) bool { return v.(int) < 3 });
-	assertArraysAreEqual(t, Data(res), []int{3, 4, 5});
-	assertArraysAreEqual(t, Data(res), []int{3, 4, 5});	// second test to ensure that .Iter() returns a new channel
+	res := DropWhile(oneToFive, func(v interface{}) bool { return v.(int) < 3 })
+	assertArraysAreEqual(t, Data(res), []int{3, 4, 5})
+	assertArraysAreEqual(t, Data(res), []int{3, 4, 5}) // second test to ensure that .Iter() returns a new channel
 
 	// test case where all elements are dropped
-	res = DropWhile(oneToFive, func(v interface{}) bool { return v.(int) < 100 });
-	assertArraysAreEqual(t, Data(res), []int{});
+	res = DropWhile(oneToFive, func(v interface{}) bool { return v.(int) < 100 })
+	assertArraysAreEqual(t, Data(res), []int{})
 
 	// test case where none are dropped
-	res = DropWhile(oneToFive, func(v interface{}) bool { return v.(int) > 1000 });
-	assertArraysAreEqual(t, Data(res), oneToFive);
+	res = DropWhile(oneToFive, func(v interface{}) bool { return v.(int) > 1000 })
+	assertArraysAreEqual(t, Data(res), oneToFive)
 }
 
 func TestCycle(t *testing.T) {
-	res := Cycle(oneToFive);
-	exp := []int{1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4};
+	res := Cycle(oneToFive)
+	exp := []int{1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4}
 
 	// read the first nineteen values from the iterable
-	out := make([]interface{}, 19);
+	out := make([]interface{}, 19)
 	for i, it := 0, res.Iter(); i < 19; i++ {
 		out[i] = <-it
 	}
-	assertArraysAreEqual(t, out, exp);
+	assertArraysAreEqual(t, out, exp)
 
-	res2 := Cycle(sixToTen);
-	exp2 := []int{6, 7, 8, 9, 10, 6, 7, 8, 9, 10, 6, 7, 8, 9, 10, 6, 7, 8, 9};
+	res2 := Cycle(sixToTen)
+	exp2 := []int{6, 7, 8, 9, 10, 6, 7, 8, 9, 10, 6, 7, 8, 9, 10, 6, 7, 8, 9}
 	for i, it := 0, res2.Iter(); i < 19; i++ {
 		out[i] = <-it
 	}
-	assertArraysAreEqual(t, out, exp2);
+	assertArraysAreEqual(t, out, exp2)
 
 	// ensure first iterator was not harmed
 	for i, it := 0, res.Iter(); i < 19; i++ {
 		out[i] = <-it
 	}
-	assertArraysAreEqual(t, out, exp);
+	assertArraysAreEqual(t, out, exp)
 }
 
 func TestChain(t *testing.T) {
 
-	exp := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20};
-	res := Chain([]Iterable{oneToFive, sixToTen, elevenToTwenty});
-	assertArraysAreEqual(t, Data(res), exp);
+	exp := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}
+	res := Chain([]Iterable{oneToFive, sixToTen, elevenToTwenty})
+	assertArraysAreEqual(t, Data(res), exp)
 
 	// reusing the same iterator should produce the same result again
-	assertArraysAreEqual(t, Data(res), exp);
+	assertArraysAreEqual(t, Data(res), exp)
 
 	// test short read from Chain
-	i := 0;
-	out := make([]interface{}, 4);
+	i := 0
+	out := make([]interface{}, 4)
 	for v := range res.Iter() {
-		out[i] = v;
-		i++;
+		out[i] = v
+		i++
 		if i == len(out) {
 			break
 		}
 	}
-	assertArraysAreEqual(t, out, exp[0:4]);
+	assertArraysAreEqual(t, out, exp[0:4])
 
 	// test zero length array
-	res = Chain([]Iterable{});
-	assertArraysAreEqual(t, Data(res), []int{});
+	res = Chain([]Iterable{})
+	assertArraysAreEqual(t, Data(res), []int{})
 }
 
 func TestZipWith(t *testing.T) {
-	exp := []int{7, 9, 11, 13, 15};
+	exp := []int{7, 9, 11, 13, 15}
 
 	// f with 2 args and 1 return value
-	f := func(a, b interface{}) interface{} { return a.(int) + b.(int) };
-	res := ZipWith2(f, oneToFive, sixToTen);
-	assertArraysAreEqual(t, Data(res), exp);
+	f := func(a, b interface{}) interface{} { return a.(int) + b.(int) }
+	res := ZipWith2(f, oneToFive, sixToTen)
+	assertArraysAreEqual(t, Data(res), exp)
 
 	// test again to make sure returns new iter each time
-	assertArraysAreEqual(t, Data(res), exp);
+	assertArraysAreEqual(t, Data(res), exp)
 
 	// test a function with 3 args
-	f2 := func(a, b, c interface{}) interface{} { return a.(int) + b.(int) + c.(int) };
-	res = ZipWith3(f2, oneToFive, sixToTen, oneToFive);
-	exp = []int{8, 11, 14, 17, 20};
-	assertArraysAreEqual(t, Data(res), exp);
+	f2 := func(a, b, c interface{}) interface{} { return a.(int) + b.(int) + c.(int) }
+	res = ZipWith3(f2, oneToFive, sixToTen, oneToFive)
+	exp = []int{8, 11, 14, 17, 20}
+	assertArraysAreEqual(t, Data(res), exp)
 
 	// test a function with multiple values returned
-	f3 := func(a, b interface{}) interface{} { return ([]interface{}{a.(int) + 1, b.(int) + 1}) };
-	res = ZipWith2(f3, oneToFive, sixToTen);
+	f3 := func(a, b interface{}) interface{} { return ([]interface{}{a.(int) + 1, b.(int) + 1}) }
+	res = ZipWith2(f3, oneToFive, sixToTen)
 
-	exp2 := [][]int{[]int{2, 7}, []int{3, 8}, []int{4, 9}, []int{5, 10}, []int{6, 11}};
-	i := 0;
+	exp2 := [][]int{[]int{2, 7}, []int{3, 8}, []int{4, 9}, []int{5, 10}, []int{6, 11}}
+	i := 0
 	for v := range res.Iter() {
-		out := v.([]interface{});
-		assertArraysAreEqual(t, out, exp2[i]);
-		i++;
+		out := v.([]interface{})
+		assertArraysAreEqual(t, out, exp2[i])
+		i++
 	}
 
 	// test different length iterators--should stop after shortest is exhausted
-	res = ZipWith2(f, elevenToTwenty, oneToFive);
-	exp = []int{12, 14, 16, 18, 20};
-	assertArraysAreEqual(t, Data(res), exp);
+	res = ZipWith2(f, elevenToTwenty, oneToFive)
+	exp = []int{12, 14, 16, 18, 20}
+	assertArraysAreEqual(t, Data(res), exp)
 }
 
 func TestSlice(t *testing.T) {
-	out := Data(Slice(elevenToTwenty, 2, 6));
-	exp := []int{13, 14, 15, 16};
-	assertArraysAreEqual(t, out, exp);
+	out := Data(Slice(elevenToTwenty, 2, 6))
+	exp := []int{13, 14, 15, 16}
+	assertArraysAreEqual(t, out, exp)
 
 	// entire iterable
-	out = Data(Slice(elevenToTwenty, 0, len(elevenToTwenty)));
-	exp = []int{11, 12, 13, 14, 15, 16, 17, 18, 19, 20};
-	assertArraysAreEqual(t, out, exp);
+	out = Data(Slice(elevenToTwenty, 0, len(elevenToTwenty)))
+	exp = []int{11, 12, 13, 14, 15, 16, 17, 18, 19, 20}
+	assertArraysAreEqual(t, out, exp)
 
 	// empty slice at offset 0
-	exp = []int{};
-	out = Data(Slice(elevenToTwenty, 0, 0));
-	assertArraysAreEqual(t, out, exp);
+	exp = []int{}
+	out = Data(Slice(elevenToTwenty, 0, 0))
+	assertArraysAreEqual(t, out, exp)
 
 	// slice upper bound exceeds length of iterable
-	exp = []int{1, 2, 3, 4, 5};
-	out = Data(Slice(oneToFive, 0, 88));
-	assertArraysAreEqual(t, out, exp);
+	exp = []int{1, 2, 3, 4, 5}
+	out = Data(Slice(oneToFive, 0, 88))
+	assertArraysAreEqual(t, out, exp)
 
 	// slice upper bounce is lower than lower bound
-	exp = []int{};
-	out = Data(Slice(oneToFive, 93, 4));
-	assertArraysAreEqual(t, out, exp);
+	exp = []int{}
+	out = Data(Slice(oneToFive, 93, 4))
+	assertArraysAreEqual(t, out, exp)
 
 	// slice lower bound is greater than len of iterable
-	exp = []int{};
-	out = Data(Slice(oneToFive, 93, 108));
-	assertArraysAreEqual(t, out, exp);
+	exp = []int{}
+	out = Data(Slice(oneToFive, 93, 108))
+	assertArraysAreEqual(t, out, exp)
 }
 
 func TestRepeat(t *testing.T) {
-	res := Repeat(42);
-	i := 0;
+	res := Repeat(42)
+	i := 0
 	for v := range res.Iter() {
 		if v.(int) != 42 {
 			t.Fatal("Repeat returned the wrong value")
@@ -315,25 +315,25 @@ func TestRepeat(t *testing.T) {
 		if i == 9 {
 			break
 		}
-		i++;
+		i++
 	}
 }
 
 func TestRepeatTimes(t *testing.T) {
-	res := RepeatTimes(84, 9);
-	exp := []int{84, 84, 84, 84, 84, 84, 84, 84, 84};
-	assertArraysAreEqual(t, Data(res), exp);
-	assertArraysAreEqual(t, Data(res), exp);	// second time to ensure new iter is returned
+	res := RepeatTimes(84, 9)
+	exp := []int{84, 84, 84, 84, 84, 84, 84, 84, 84}
+	assertArraysAreEqual(t, Data(res), exp)
+	assertArraysAreEqual(t, Data(res), exp) // second time to ensure new iter is returned
 
 	// 0 repeat
-	res = RepeatTimes(7, 0);
-	exp = []int{};
-	assertArraysAreEqual(t, Data(res), exp);
+	res = RepeatTimes(7, 0)
+	exp = []int{}
+	assertArraysAreEqual(t, Data(res), exp)
 
 	// negative repeat
-	res = RepeatTimes(7, -3);
-	exp = []int{};
-	assertArraysAreEqual(t, Data(res), exp);
+	res = RepeatTimes(7, -3)
+	exp = []int{}
+	assertArraysAreEqual(t, Data(res), exp)
 }
 
 // a type that implements Key for ints
@@ -342,20 +342,20 @@ type intkey struct{}
 func (v intkey) Key(a interface{}) interface{} {
 	return a
 }
-func (v intkey) Equal(a, b interface{}) bool	{ return a.(int) == b.(int) }
+func (v intkey) Equal(a, b interface{}) bool { return a.(int) == b.(int) }
 
 func TestGroupBy(t *testing.T) {
-	in := IntArray{1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5};
-	exp := [][]int{[]int{1}, []int{2, 2}, []int{3, 3, 3}, []int{4, 4, 4, 4}, []int{5, 5, 5, 5, 5}};
-	i := 0;
+	in := IntArray{1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5}
+	exp := [][]int{[]int{1}, []int{2, 2}, []int{3, 3, 3}, []int{4, 4, 4, 4}, []int{5, 5, 5, 5, 5}}
+	i := 0
 	for x := range GroupBy(in, intkey{}).Iter() {
-		gr := x.(Group);
+		gr := x.(Group)
 		if gr.Key.(int) != i+1 {
 			t.Fatal("group key wrong; expected", i+1, "but got", gr.Key.(int))
 		}
-		vals := Data(gr.Vals);
-		assertArraysAreEqual(t, vals, exp[i]);
-		i++;
+		vals := Data(gr.Vals)
+		assertArraysAreEqual(t, vals, exp[i])
+		i++
 	}
 	if i != 5 {
 		t.Fatal("did not return expected number of groups")
@@ -367,21 +367,21 @@ func TestGroupBy(t *testing.T) {
 	}
 
 	// test case with only uniques
-	var out vector.Vector;
+	var out vector.Vector
 	for x := range GroupBy(elevenToTwenty, intkey{}).Iter() {
 		out.Push(x.(Group).Key)
 	}
-	assertArraysAreEqual(t, out.Data(), elevenToTwenty);
+	assertArraysAreEqual(t, out.Data(), elevenToTwenty)
 }
 
 func TestUnique(t *testing.T) {
-	in := IntArray([]int{1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5});
-	exp := []int{1, 2, 3, 4, 5};
-	res := Unique(in, intkey{});
-	assertArraysAreEqual(t, Data(res), exp);
-	assertArraysAreEqual(t, Data(res), exp);	// second time to ensure new iter is returned
+	in := IntArray([]int{1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5})
+	exp := []int{1, 2, 3, 4, 5}
+	res := Unique(in, intkey{})
+	assertArraysAreEqual(t, Data(res), exp)
+	assertArraysAreEqual(t, Data(res), exp) // second time to ensure new iter is returned
 
 	// test case with only uniques
-	res = Unique(elevenToTwenty, intkey{});
-	assertArraysAreEqual(t, Data(res), elevenToTwenty);
+	res = Unique(elevenToTwenty, intkey{})
+	assertArraysAreEqual(t, Data(res), elevenToTwenty)
 }