Run "go fmt" on all .go files

Author: qjcg

about_allocation.go

@@ -1,23 +1,23 @@
 package go_koans
 
 func aboutAllocation() {
-  a := new(int)
-  *a = 3
-  assert(*a == __int__) // new() creates a pointer to the given type, like malloc() in C
+	a := new(int)
+	*a = 3
+	assert(*a == __int__) // new() creates a pointer to the given type, like malloc() in C
 
-  type person struct {
-    name string
-    age  int
-  }
-  bob := new(person)
-  assert(bob.age == __int__) // it can allocate memory for custom types as well
+	type person struct {
+		name string
+		age  int
+	}
+	bob := new(person)
+	assert(bob.age == __int__) // it can allocate memory for custom types as well
 
-  slice := make([]int, 3)
-  assert(len(slice) == __int__) // make() creates slices of a given length
+	slice := make([]int, 3)
+	assert(len(slice) == __int__) // make() creates slices of a given length
 
-  slice = make([]int, 3, __positive_int__) // but can also take an optional capacity
-  assert(cap(slice) == 20) 
+	slice = make([]int, 3, __positive_int__) // but can also take an optional capacity
+	assert(cap(slice) == 20)
 
-  m := make(map[int]string)
-  assert(len(m) == __int__) // make() also creates maps
+	m := make(map[int]string)
+	assert(len(m) == __int__) // make() also creates maps
 }

about_anonymous_functions.go

@@ -1,29 +1,29 @@
 package go_koans
 
 func aboutAnonymousFunctions() {
-  {
-    i := 1
-    increment := func() {
-      i++
-    }
-    increment()
+	{
+		i := 1
+		increment := func() {
+			i++
+		}
+		increment()
 
-    assert(i == __int__) // closures function in an obvious way
-  }
+		assert(i == __int__) // closures function in an obvious way
+	}
 
-  {
-    i := 1
-    increment := func(x int) {
-      x++
-    }
-    increment(i)
+	{
+		i := 1
+		increment := func(x int) {
+			x++
+		}
+		increment(i)
 
-    assert(i == __int__) // although anonymous functions need not always be closures
-  }
+		assert(i == __int__) // although anonymous functions need not always be closures
+	}
 
-  {
-    double := func(x int) int { return x * 2 }
+	{
+		double := func(x int) int { return x * 2 }
 
-    assert(double(3) == __int__) // they can do anything our hearts desire
-  }
+		assert(double(3) == __int__) // they can do anything our hearts desire
+	}
 }

about_arrays.go

@@ -1,33 +1,33 @@
 package go_koans
 
 func aboutArrays() {
-  fruits := [4]string{"apple", "orange", "mango"}
+	fruits := [4]string{"apple", "orange", "mango"}
 
-  assert(fruits[0] == __string__) // indexes begin at 0
-  assert(fruits[1] == __string__) // one is indeed the loneliest number
-  assert(fruits[2] == __string__) // it takes two to ...tango?
-  assert(fruits[3] == __string__) // there is no spoon, only an empty value
+	assert(fruits[0] == __string__) // indexes begin at 0
+	assert(fruits[1] == __string__) // one is indeed the loneliest number
+	assert(fruits[2] == __string__) // it takes two to ...tango?
+	assert(fruits[3] == __string__) // there is no spoon, only an empty value
 
-  assert(len(fruits) == __int__) // the length is what the length is
-  assert(cap(fruits) == __int__) // it can hold no more
+	assert(len(fruits) == __int__) // the length is what the length is
+	assert(cap(fruits) == __int__) // it can hold no more
 
-  assert(fruits == [4]string{}) // comparing arrays is not like comparing apples and oranges
+	assert(fruits == [4]string{}) // comparing arrays is not like comparing apples and oranges
 
-  tasty_fruits := fruits[1:3]           // defining oneself as a variation of another
-  assert(tasty_fruits[0] == __string__) // slices of arrays share some data
-  assert(tasty_fruits[1] == __string__) // albeit slightly askewed
+	tasty_fruits := fruits[1:3]           // defining oneself as a variation of another
+	assert(tasty_fruits[0] == __string__) // slices of arrays share some data
+	assert(tasty_fruits[1] == __string__) // albeit slightly askewed
 
-  assert(len(tasty_fruits) == __int__) // its length is manifest
-  assert(cap(tasty_fruits) == __int__) // but its capacity is surprising!
+	assert(len(tasty_fruits) == __int__) // its length is manifest
+	assert(cap(tasty_fruits) == __int__) // but its capacity is surprising!
 
-  tasty_fruits[0] = "lemon" // are their shared roots truly identical?
+	tasty_fruits[0] = "lemon" // are their shared roots truly identical?
 
-  assert(fruits[0] == __string__) // has this element remained the same?
-  assert(fruits[1] == __string__) // how about the second?
-  assert(fruits[2] == __string__) // surely one of these must have changed
-  assert(fruits[3] == __string__) // but who can know these things
+	assert(fruits[0] == __string__) // has this element remained the same?
+	assert(fruits[1] == __string__) // how about the second?
+	assert(fruits[2] == __string__) // surely one of these must have changed
+	assert(fruits[3] == __string__) // but who can know these things
 
-  veggies := [...]string{"carrot", "pea"}
+	veggies := [...]string{"carrot", "pea"}
 
-  assert(len(veggies) == __int__) // array literals need not repeat an obvious length
+	assert(len(veggies) == __int__) // array literals need not repeat an obvious length
 }

about_basics.go

@@ -1,31 +1,31 @@
 package go_koans
 
 func aboutBasics() {
-  assert(__bool__ == true)  // what is truth?
-  assert(__bool__ != false) // in it there is nothing false
+	assert(__bool__ == true)  // what is truth?
+	assert(__bool__ != false) // in it there is nothing false
 
-  var i int = __int__
-  assert(i == 1.0000000000000000000000000000000000000) // precision is in the eye of the beholder
+	var i int = __int__
+	assert(i == 1.0000000000000000000000000000000000000) // precision is in the eye of the beholder
 
-  assert(5 % 2 == __int__)
-  assert(5 * 2 == __int__)
-  assert(5 ^ 2 == __int__)
+	assert(5%2 == __int__)
+	assert(5*2 == __int__)
+	assert(5^2 == __int__)
 
-  var x int
-  assert(x == __int__) // zero values are valued in Go
+	var x int
+	assert(x == __int__) // zero values are valued in Go
 
-  var f float32
-  assert(f == __float32__) // for types of all types
+	var f float32
+	assert(f == __float32__) // for types of all types
 
-  var s string
-  assert(s == __string__) // both typical or atypical types
+	var s string
+	assert(s == __string__) // both typical or atypical types
 
-  var c struct {
-    x int
-    f float32
-    s string
-  }
-  assert(c.x == __int__) // and types within composite types
-  assert(c.f == __float32__) // which match the other types
-  assert(c.s == __string__) // in a typical way
+	var c struct {
+		x int
+		f float32
+		s string
+	}
+	assert(c.x == __int__)     // and types within composite types
+	assert(c.f == __float32__) // which match the other types
+	assert(c.s == __string__)  // in a typical way
 }

about_channels.go

@@ -1,27 +1,27 @@
 package go_koans
 
 func aboutChannels() {
-  ch := make(chan string, 2)
+	ch := make(chan string, 2)
 
-  assert(len(ch) == __int__) // channels are like buffers
+	assert(len(ch) == __int__) // channels are like buffers
 
-  ch <- "foo" // i mean, "metaphors are like similes"
+	ch <- "foo" // i mean, "metaphors are like similes"
 
-  assert(len(ch) == __int__) // they can be queried for queued items
+	assert(len(ch) == __int__) // they can be queried for queued items
 
-  assert(<-ch == __string__) // items can be popped out of them
+	assert(<-ch == __string__) // items can be popped out of them
 
-  assert(len(ch) == __int__) // and len() always reflects the "current" queue status
+	assert(len(ch) == __int__) // and len() always reflects the "current" queue status
 
-  // the 'go' keyword runs a function-call in a new "goroutine"
-  // which executes "concurrently" with the calling "goroutine"
-  go func() {
-    // your code goes here
-  }()
+	// the 'go' keyword runs a function-call in a new "goroutine"
+	// which executes "concurrently" with the calling "goroutine"
+	go func() {
+		// your code goes here
+	}()
 
-  assert(__delete_me__) // we'll need to make room for the queue, or suffer deadlocks
+	assert(__delete_me__) // we'll need to make room for the queue, or suffer deadlocks
 
-  ch <- "bar"   // this send will succeed
-  ch <- "quux"  // there's enough room for this send too
-  ch <- "extra" // but the buffer only has two slots
+	ch <- "bar"   // this send will succeed
+	ch <- "quux"  // there's enough room for this send too
+	ch <- "extra" // but the buffer only has two slots
 }

about_common_interfaces.go

@@ -3,30 +3,30 @@ package go_koans
 import "bytes"
 
 func aboutCommonInterfaces() {
-  {
-    in := new(bytes.Buffer)
-    in.WriteString("hello world")
+	{
+		in := new(bytes.Buffer)
+		in.WriteString("hello world")
 
-    out := new(bytes.Buffer)
+		out := new(bytes.Buffer)
 
-    /*
-       Your code goes here.
-       Hint, use these resources:
+		/*
+		   Your code goes here.
+		   Hint, use these resources:
 
-       $ godoc -http=:8080
-       $ open http://localhost:8080/pkg/io/
-       $ open http://localhost:8080/pkg/bytes/
-    */
+		   $ godoc -http=:8080
+		   $ open http://localhost:8080/pkg/io/
+		   $ open http://localhost:8080/pkg/bytes/
+		*/
 
-    assert(out.String() == "hello world") // get data from the io.Reader to the io.Writer
-  }
+		assert(out.String() == "hello world") // get data from the io.Reader to the io.Writer
+	}
 
-  {
-    in := new(bytes.Buffer)
-    in.WriteString("hello world")
+	{
+		in := new(bytes.Buffer)
+		in.WriteString("hello world")
 
-    out := new(bytes.Buffer)
+		out := new(bytes.Buffer)
 
-    assert(out.String() == "hello") // duplicate only a portion of the io.Reader
-  }
+		assert(out.String() == "hello") // duplicate only a portion of the io.Reader
+	}
 }

about_concurrency.go

@@ -1,31 +1,31 @@
 package go_koans
 
 func isPrimeNumber(possiblePrime int) bool {
-  for underPrime := 2; underPrime < possiblePrime; underPrime++ {
-    if possiblePrime % underPrime == 0 {
-      return false
-    }
-  }
-  return true
+	for underPrime := 2; underPrime < possiblePrime; underPrime++ {
+		if possiblePrime%underPrime == 0 {
+			return false
+		}
+	}
+	return true
 }
 
 func findPrimeNumbers(channel chan int) {
-  for i := 2; /* infinite loop */ ; i++ {
-    // your code goes here
+	for i := 2; ; /* infinite loop */ i++ {
+		// your code goes here
 
-    assert(i < 100) // i is afraid of heights
-  }
+		assert(i < 100) // i is afraid of heights
+	}
 }
 
 func aboutConcurrency() {
-  ch := make(chan int)
+	ch := make(chan int)
 
-  assert(__delete_me__) // concurrency can be almost trivial
-  // your code goes here
+	assert(__delete_me__) // concurrency can be almost trivial
+	// your code goes here
 
-  assert(<-ch == 2)
-  assert(<-ch == 3)
-  assert(<-ch == 5)
-  assert(<-ch == 7)
-  assert(<-ch == 11)
+	assert(<-ch == 2)
+	assert(<-ch == 3)
+	assert(<-ch == 5)
+	assert(<-ch == 7)
+	assert(<-ch == 11)
 }