code review 180049: 1) Change default gofmt default settings for

src/pkg/rand/rand.go

Index: src/pkg/rand/rand.go
===================================================================
--- a/src/pkg/rand/rand.go
+++ b/src/pkg/rand/rand.go
@@ -10,42 +10,42 @@
 // A Source represents a source of uniformly-distributed
 // pseudo-random int64 values in the range [0, 1<<63).
 type Source interface {
-	Int63() int64;
-	Seed(seed int64);
+	Int63() int64
+	Seed(seed int64)
 }
 
 // NewSource returns a new pseudo-random Source seeded with the given value.
 func NewSource(seed int64) Source {
-	var rng rngSource;
-	rng.Seed(seed);
-	return &rng;
+	var rng rngSource
+	rng.Seed(seed)
+	return &rng
 }
 
 // A Rand is a source of random numbers.
 type Rand struct {
-	src Source;
+	src Source
 }
 
 // New returns a new Rand that uses random values from src
 // to generate other random values.
-func New(src Source) *Rand	{ return &Rand{src} }
+func New(src Source) *Rand { return &Rand{src} }
 
 // Seed uses the provided seed value to initialize the generator to a deterministic state.
-func (r *Rand) Seed(seed int64)	{ r.src.Seed(seed) }
+func (r *Rand) Seed(seed int64) { r.src.Seed(seed) }
 
 // Int63 returns a non-negative pseudo-random 63-bit integer as an int64.
-func (r *Rand) Int63() int64	{ return r.src.Int63() }
+func (r *Rand) Int63() int64 { return r.src.Int63() }
 
 // Uint32 returns a pseudo-random 32-bit value as a uint32.
-func (r *Rand) Uint32() uint32	{ return uint32(r.Int63() >> 31) }
+func (r *Rand) Uint32() uint32 { return uint32(r.Int63() >> 31) }
 
 // Int31 returns a non-negative pseudo-random 31-bit integer as an int32.
-func (r *Rand) Int31() int32	{ return int32(r.Int63() >> 32) }
+func (r *Rand) Int31() int32 { return int32(r.Int63() >> 32) }
 
 // Int returns a non-negative pseudo-random int.
 func (r *Rand) Int() int {
-	u := uint(r.Int63());
-	return int(u << 1 >> 1);	// clear sign bit if int == int32
+	u := uint(r.Int63())
+	return int(u << 1 >> 1) // clear sign bit if int == int32
 }
 
 // Int63n returns, as an int64, a non-negative pseudo-random number in [0,n).
@@ -53,40 +53,40 @@
 	if n <= 0 {
 		return 0
 	}
-	max := int64((1 << 63) - 1 - (1<<63)%uint64(n));
-	v := r.Int63();
+	max := int64((1 << 63) - 1 - (1<<63)%uint64(n))
+	v := r.Int63()
 	for v > max {
 		v = r.Int63()
 	}
-	return v % n;
+	return v % n
 }
 
 // Int31n returns, as an int32, a non-negative pseudo-random number in [0,n).
-func (r *Rand) Int31n(n int32) int32	{ return int32(r.Int63n(int64(n))) }
+func (r *Rand) Int31n(n int32) int32 { return int32(r.Int63n(int64(n))) }
 
 // Intn returns, as an int, a non-negative pseudo-random number in [0,n).
-func (r *Rand) Intn(n int) int	{ return int(r.Int63n(int64(n))) }
+func (r *Rand) Intn(n int) int { return int(r.Int63n(int64(n))) }
 
 // Float64 returns, as a float64, a pseudo-random number in [0.0,1.0).
-func (r *Rand) Float64() float64	{ return float64(r.Int63()) / (1 << 63) }
+func (r *Rand) Float64() float64 { return float64(r.Int63()) / (1 << 63) }
 
 // Float32 returns, as a float32, a pseudo-random number in [0.0,1.0).
-func (r *Rand) Float32() float32	{ return float32(r.Float64()) }
+func (r *Rand) Float32() float32 { return float32(r.Float64()) }
 
 // Float returns, as a float, a pseudo-random number in [0.0,1.0).
-func (r *Rand) Float() float	{ return float(r.Float64()) }
+func (r *Rand) Float() float { return float(r.Float64()) }
 
 // Perm returns, as a slice of n ints, a pseudo-random permutation of the integers [0,n).
 func (r *Rand) Perm(n int) []int {
-	m := make([]int, n);
+	m := make([]int, n)
 	for i := 0; i < n; i++ {
 		m[i] = i
 	}
 	for i := 0; i < n; i++ {
-		j := r.Intn(i + 1);
-		m[i], m[j] = m[j], m[i];
+		j := r.Intn(i + 1)
+		m[i], m[j] = m[j], m[i]
 	}
-	return m;
+	return m
 }
 
 /*
@@ -96,40 +96,40 @@
 var globalRand = New(&lockedSource{src: NewSource(1)})
 
 // Seed uses the provided seed value to initialize the generator to a deterministic state.
-func Seed(seed int64)	{ globalRand.Seed(seed) }
+func Seed(seed int64) { globalRand.Seed(seed) }
 
 // Int63 returns a non-negative pseudo-random 63-bit integer as an int64.
-func Int63() int64	{ return globalRand.Int63() }
+func Int63() int64 { return globalRand.Int63() }
 
 // Uint32 returns a pseudo-random 32-bit value as a uint32.
-func Uint32() uint32	{ return globalRand.Uint32() }
+func Uint32() uint32 { return globalRand.Uint32() }
 
 // Int31 returns a non-negative pseudo-random 31-bit integer as an int32.
-func Int31() int32	{ return globalRand.Int31() }
+func Int31() int32 { return globalRand.Int31() }
 
 // Int returns a non-negative pseudo-random int.
-func Int() int	{ return globalRand.Int() }
+func Int() int { return globalRand.Int() }
 
 // Int63n returns, as an int64, a non-negative pseudo-random number in [0,n).
-func Int63n(n int64) int64	{ return globalRand.Int63n(n) }
+func Int63n(n int64) int64 { return globalRand.Int63n(n) }
 
 // Int31n returns, as an int32, a non-negative pseudo-random number in [0,n).
-func Int31n(n int32) int32	{ return globalRand.Int31n(n) }
+func Int31n(n int32) int32 { return globalRand.Int31n(n) }
 
 // Intn returns, as an int, a non-negative pseudo-random number in [0,n).
-func Intn(n int) int	{ return globalRand.Intn(n) }
+func Intn(n int) int { return globalRand.Intn(n) }
 
 // Float64 returns, as a float64, a pseudo-random number in [0.0,1.0).
-func Float64() float64	{ return globalRand.Float64() }
+func Float64() float64 { return globalRand.Float64() }
 
 // Float32 returns, as a float32, a pseudo-random number in [0.0,1.0).
-func Float32() float32	{ return globalRand.Float32() }
+func Float32() float32 { return globalRand.Float32() }
 
 // Float returns, as a float, a pseudo-random number in [0.0,1.0).
-func Float() float	{ return globalRand.Float() }
+func Float() float { return globalRand.Float() }
 
 // Perm returns, as a slice of n ints, a pseudo-random permutation of the integers [0,n).
-func Perm(n int) []int	{ return globalRand.Perm(n) }
+func Perm(n int) []int { return globalRand.Perm(n) }
 
 // NormFloat64 returns a normally distributed float64 in the range
 // [-math.MaxFloat64, +math.MaxFloat64] with
@@ -139,7 +139,7 @@
 //
 //  sample = NormFloat64() * desiredStdDev + desiredMean
 //
-func NormFloat64() float64	{ return globalRand.NormFloat64() }
+func NormFloat64() float64 { return globalRand.NormFloat64() }
 
 // ExpFloat64 returns an exponentially distributed float64 in the range
 // (0, +math.MaxFloat64] with an exponential distribution whose rate parameter
@@ -149,22 +149,22 @@
 //
 //  sample = ExpFloat64() / desiredRateParameter
 //
-func ExpFloat64() float64	{ return globalRand.ExpFloat64() }
+func ExpFloat64() float64 { return globalRand.ExpFloat64() }
 
 type lockedSource struct {
-	lk	sync.Mutex;
-	src	Source;
+	lk  sync.Mutex
+	src Source
 }
 
 func (r *lockedSource) Int63() (n int64) {
-	r.lk.Lock();
-	n = r.src.Int63();
-	r.lk.Unlock();
-	return;
+	r.lk.Lock()
+	n = r.src.Int63()
+	r.lk.Unlock()
+	return
 }
 
 func (r *lockedSource) Seed(seed int64) {
-	r.lk.Lock();
-	r.src.Seed(seed);
-	r.lk.Unlock();
+	r.lk.Lock()
+	r.src.Seed(seed)
+	r.lk.Unlock()
 }