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, 60 insertions, 60 deletions

diff --git a/src/pkg/exp/iterable/iterable.go b/src/pkg/exp/iterable/iterable.go
index 764900c53..b1ae0e90f 100644
--- a/src/pkg/exp/iterable/iterable.go
+++ b/src/pkg/exp/iterable/iterable.go
@@ -9,13 +9,13 @@
 package iterable
 
 import (
-	"container/list";
-	"container/vector";
+	"container/list"
+	"container/vector"
 )
 
 type Iterable interface {
 	// Iter should return a fresh channel each time it is called.
-	Iter() <-chan interface{};
+	Iter() <-chan interface{}
 }
 
 func not(f func(interface{}) bool) (func(interface{}) bool) {
@@ -29,7 +29,7 @@ func All(iter Iterable, f func(interface{}) bool) bool {
 			return false
 		}
 	}
-	return true;
+	return true
 }
 
 // Any tests whether f is true for at least one element of iter.
@@ -39,18 +39,18 @@ func Any(iter Iterable, f func(interface{}) bool) bool {
 
 // Data returns a slice containing the elements of iter.
 func Data(iter Iterable) []interface{} {
-	vec := new(vector.Vector);
+	vec := new(vector.Vector)
 	for e := range iter.Iter() {
 		vec.Push(e)
 	}
-	return vec.Data();
+	return vec.Data()
 }
 
 // filteredIterable is a struct that implements Iterable with each element
 // passed through a filter.
 type filteredIterable struct {
-	it	Iterable;
-	f	func(interface{}) bool;
+	it Iterable
+	f  func(interface{}) bool
 }
 
 func (f *filteredIterable) iterate(out chan<- interface{}) {
@@ -59,13 +59,13 @@ func (f *filteredIterable) iterate(out chan<- interface{}) {
 			out <- e
 		}
 	}
-	close(out);
+	close(out)
 }
 
 func (f *filteredIterable) Iter() <-chan interface{} {
-	ch := make(chan interface{});
-	go f.iterate(ch);
-	return ch;
+	ch := make(chan interface{})
+	go f.iterate(ch)
+	return ch
 }
 
 // Filter returns an Iterable that returns the elements of iter that satisfy f.
@@ -79,7 +79,7 @@ func Find(iter Iterable, f func(interface{}) bool) interface{} {
 	for e := range Filter(iter, f).Iter() {
 		return e
 	}
-	return nil;
+	return nil
 }
 
 // Injector is a type representing a function that takes two arguments,
@@ -96,30 +96,30 @@ type Injector func(interface{}, interface{}) interface{}
 //                          func(ax interface {}, x interface {}) interface {} {
 //                            return ax.(int) + x.(int) }).(int)
 func Inject(iter Iterable, initial interface{}, f Injector) interface{} {
-	acc := initial;
+	acc := initial
 	for e := range iter.Iter() {
 		acc = f(acc, e)
 	}
-	return acc;
+	return acc
 }
 
 // mappedIterable is a helper struct that implements Iterable, returned by Map.
 type mappedIterable struct {
-	it	Iterable;
-	f	func(interface{}) interface{};
+	it Iterable
+	f  func(interface{}) interface{}
 }
 
 func (m *mappedIterable) iterate(out chan<- interface{}) {
 	for e := range m.it.Iter() {
 		out <- m.f(e)
 	}
-	close(out);
+	close(out)
 }
 
 func (m *mappedIterable) Iter() <-chan interface{} {
-	ch := make(chan interface{});
-	go m.iterate(ch);
-	return ch;
+	ch := make(chan interface{})
+	go m.iterate(ch)
+	return ch
 }
 
 // Map returns an Iterable that returns the result of applying f to each
@@ -139,13 +139,13 @@ type iterFunc func(chan<- interface{})
 
 // provide the Iterable interface
 func (v iterFunc) Iter() <-chan interface{} {
-	ch := make(chan interface{});
-	go v(ch);
-	return ch;
+	ch := make(chan interface{})
+	go v(ch)
+	return ch
 }
 
 // Take returns an Iterable that contains the first n elements of iter.
-func Take(iter Iterable, n int) Iterable	{ return Slice(iter, 0, n) }
+func Take(iter Iterable, n int) Iterable { return Slice(iter, 0, n) }
 
 // TakeWhile returns an Iterable that contains elements from iter while f is true.
 func TakeWhile(iter Iterable, f func(interface{}) bool) Iterable {
@@ -154,41 +154,41 @@ func TakeWhile(iter Iterable, f func(interface{}) bool) Iterable {
 			if !f(v) {
 				break
 			}
-			ch <- v;
+			ch <- v
 		}
-		close(ch);
+		close(ch)
 	})
 }
 
 // Drop returns an Iterable that returns each element of iter after the first n elements.
 func Drop(iter Iterable, n int) Iterable {
 	return iterFunc(func(ch chan<- interface{}) {
-		m := n;
+		m := n
 		for v := range iter.Iter() {
 			if m > 0 {
-				m--;
-				continue;
+				m--
+				continue
 			}
-			ch <- v;
+			ch <- v
 		}
-		close(ch);
+		close(ch)
 	})
 }
 
 // DropWhile returns an Iterable that returns each element of iter after the initial sequence for which f returns true.
 func DropWhile(iter Iterable, f func(interface{}) bool) Iterable {
 	return iterFunc(func(ch chan<- interface{}) {
-		drop := true;
+		drop := true
 		for v := range iter.Iter() {
 			if drop {
 				if f(v) {
 					continue
 				}
-				drop = false;
+				drop = false
 			}
-			ch <- v;
+			ch <- v
 		}
-		close(ch);
+		close(ch)
 	})
 }
 
@@ -211,7 +211,7 @@ func Chain(args []Iterable) Iterable {
 				ch <- v
 			}
 		}
-		close(ch);
+		close(ch)
 	})
 }
 
@@ -220,23 +220,23 @@ func Chain(args []Iterable) Iterable {
 // the lengths of the input Iterables.
 func Zip(args []Iterable) Iterable {
 	return iterFunc(func(ch chan<- interface{}) {
-		defer close(ch);
+		defer close(ch)
 		if len(args) == 0 {
 			return
 		}
-		iters := make([]<-chan interface{}, len(args));
+		iters := make([]<-chan interface{}, len(args))
 		for i := 0; i < len(iters); i++ {
 			iters[i] = args[i].Iter()
 		}
 		for {
-			out := make([]interface{}, len(args));
+			out := make([]interface{}, len(args))
 			for i, v := range iters {
-				out[i] = <-v;
+				out[i] = <-v
 				if closed(v) {
 					return
 				}
 			}
-			ch <- out;
+			ch <- out
 		}
 	})
 }
@@ -244,16 +244,16 @@ func Zip(args []Iterable) Iterable {
 // ZipWith returns an Iterable containing the result of executing f using arguments read from a and b.
 func ZipWith2(f func(c, d interface{}) interface{}, a, b Iterable) Iterable {
 	return Map(Zip([]Iterable{a, b}), func(a1 interface{}) interface{} {
-		arr := a1.([]interface{});
-		return f(arr[0], arr[1]);
+		arr := a1.([]interface{})
+		return f(arr[0], arr[1])
 	})
 }
 
 // ZipWith returns an Iterable containing the result of executing f using arguments read from a, b and c.
 func ZipWith3(f func(d, e, f interface{}) interface{}, a, b, c Iterable) Iterable {
 	return Map(Zip([]Iterable{a, b, c}), func(a1 interface{}) interface{} {
-		arr := a1.([]interface{});
-		return f(arr[0], arr[1], arr[2]);
+		arr := a1.([]interface{})
+		return f(arr[0], arr[1], arr[2])
 	})
 }
 
@@ -261,8 +261,8 @@ func ZipWith3(f func(d, e, f interface{}) interface{}, a, b, c Iterable) Iterabl
 // with indexes in [start, stop).
 func Slice(iter Iterable, start, stop int) Iterable {
 	return iterFunc(func(ch chan<- interface{}) {
-		defer close(ch);
-		i := 0;
+		defer close(ch)
+		i := 0
 		for v := range iter.Iter() {
 			switch {
 			case i >= stop:
@@ -270,7 +270,7 @@ func Slice(iter Iterable, start, stop int) Iterable {
 			case i >= start:
 				ch <- v
 			}
-			i++;
+			i++
 		}
 	})
 }
@@ -290,23 +290,23 @@ func RepeatTimes(v interface{}, n int) Iterable {
 		for i := 0; i < n; i++ {
 			ch <- v
 		}
-		close(ch);
+		close(ch)
 	})
 }
 
 // Group is the type for elements returned by the GroupBy function.
 type Group struct {
-	Key	interface{};	// key value for matching items
-	Vals	Iterable;	// Iterable for receiving values in the group
+	Key  interface{} // key value for matching items
+	Vals Iterable    // Iterable for receiving values in the group
 }
 
 // Key defines the interface required by the GroupBy function.
 type Grouper interface {
 	// Return the key for the given value
-	Key(interface{}) interface{};
+	Key(interface{}) interface{}
 
 	// Compute equality for the given keys
-	Equal(a, b interface{}) bool;
+	Equal(a, b interface{}) bool
 }
 
 // GroupBy combines sequences of logically identical values from iter using k
@@ -317,23 +317,23 @@ type Grouper interface {
 func GroupBy(iter Iterable, k Grouper) Iterable {
 	return iterFunc(func(ch chan<- interface{}) {
 		var curkey interface{}
-		var lst *list.List;
+		var lst *list.List
 		// Basic strategy is to read one group at a time into a list prior to emitting the Group value
 		for v := range iter.Iter() {
-			kv := k.Key(v);
+			kv := k.Key(v)
 			if lst == nil || !k.Equal(curkey, kv) {
 				if lst != nil {
 					ch <- Group{curkey, lst}
 				}
-				lst = list.New();
-				curkey = kv;
+				lst = list.New()
+				curkey = kv
 			}
-			lst.PushBack(v);
+			lst.PushBack(v)
 		}
 		if lst != nil {
 			ch <- Group{curkey, lst}
 		}
-		close(ch);
+		close(ch)
 	})
 }