Merge pull request #323 from appleboy/patch-9

fix: coding style and file format for all example.

eBook/examples/chapter_10/embed_func1.go

@@ -1,43 +1,44 @@
-package main
-
-import (
-	"fmt"
-)
-
-type Log struct {
-	msg string
-}
-
-type Customer struct {
-    Name	string
-    log 	*Log
-}
-
-func main() {
-	// c := new(Customer)
-	// c.Name = "Barak Obama"
-	// c.log = new(Log)
-	// c.log.msg = "1 - Yes we can!"
-	// shorter:
-	c := &Customer{"Barak Obama", &Log{"1 - Yes we can!"}}
-	// fmt.Println(c)   // &{Barak Obama 1 - Yes we can!}
-	c.Log().Add("2 - After me the world will be a better place!")
-	//fmt.Println(c.log)
-	fmt.Println(c.Log())
-}
-
-func (l *Log) Add(s string) {
-	l.msg += "\n" + s
-}
-
-func (l *Log) String() string {
-	return l.msg
-}
-
-func (c *Customer) Log() *Log {
-    return c.log
-}
-/* Output:
-1 - Yes we can!
-2 - After me the world will be a better place!
-*/
+package main
+
+import (
+	"fmt"
+)
+
+type Log struct {
+	msg string
+}
+
+type Customer struct {
+	Name string
+	log  *Log
+}
+
+func main() {
+	// c := new(Customer)
+	// c.Name = "Barak Obama"
+	// c.log = new(Log)
+	// c.log.msg = "1 - Yes we can!"
+	// shorter:
+	c := &Customer{"Barak Obama", &Log{"1 - Yes we can!"}}
+	// fmt.Println(c)   // &{Barak Obama 1 - Yes we can!}
+	c.Log().Add("2 - After me the world will be a better place!")
+	//fmt.Println(c.log)
+	fmt.Println(c.Log())
+}
+
+func (l *Log) Add(s string) {
+	l.msg += "\n" + s
+}
+
+func (l *Log) String() string {
+	return l.msg
+}
+
+func (c *Customer) Log() *Log {
+	return c.log
+}
+
+/* Output:
+1 - Yes we can!
+2 - After me the world will be a better place!
+*/

eBook/examples/chapter_10/embed_func2.go

@@ -1,38 +1,38 @@
-package main
-
-import (
-	"fmt"
-)
-
-type Log struct {
-	msg string
-}
-
-type Customer struct {
-    Name	string
-    Log
-}
-
-func main() {
-	c := &Customer{"Barak Obama", Log{"1 - Yes we can!"}}
-	c.Add("2 - After me the world will be a better place!")
-	fmt.Println(c)
-}
-
-func (l *Log) Add(s string) {
-	l.msg += "\n" + s
-}
-
-func (c *Customer) String() string {
-	return c.Name + "\nLog:" + fmt.Sprintln(c.Log)
-}
-
-func (l *Log) String() string {
-	return l.msg
-}
-
-/* Output:
-Barak Obama
-Log:{1 - Yes we can!
-2 - After me the world will be a better place!}
-*/
+package main
+
+import (
+	"fmt"
+)
+
+type Log struct {
+	msg string
+}
+
+type Customer struct {
+	Name string
+	Log
+}
+
+func main() {
+	c := &Customer{"Barak Obama", Log{"1 - Yes we can!"}}
+	c.Add("2 - After me the world will be a better place!")
+	fmt.Println(c)
+}
+
+func (l *Log) Add(s string) {
+	l.msg += "\n" + s
+}
+
+func (c *Customer) String() string {
+	return c.Name + "\nLog:" + fmt.Sprintln(c.Log)
+}
+
+func (l *Log) String() string {
+	return l.msg
+}
+
+/* Output:
+Barak Obama
+Log:{1 - Yes we can!
+2 - After me the world will be a better place!}
+*/

eBook/examples/chapter_10/embedd_struct.go

@@ -1,18 +1,18 @@
-package main
-
-import "fmt"
-
-type A struct {
-	ax, ay int
-}
-
-type B struct {
-	A
-	bx, by float32
-}
-
-func main() {
-	b := B{A{1, 2}, 3.0, 4.0}
-	fmt.Println(b.ax, b.ay, b.bx, b.by)
-	fmt.Println(b.A)
-}
+package main
+
+import "fmt"
+
+type A struct {
+	ax, ay int
+}
+
+type B struct {
+	A
+	bx, by float32
+}
+
+func main() {
+	b := B{A{1, 2}, 3.0, 4.0}
+	fmt.Println(b.ax, b.ay, b.bx, b.by)
+	fmt.Println(b.A)
+}

eBook/examples/chapter_10/main.go

@@ -1,16 +1,17 @@
-package main
-
-import (
-	"fmt"
-	"./struct_pack/structPack"
-)
-
-func main() {
-	struct1 := new(structPack.ExpStruct)
-	struct1.Mi1 = 10
-	struct1.Mf1 = 16.
-	fmt.Printf("Mi1 = %d\n", struct1.Mi1)
-	fmt.Printf("Mf1 = %f\n", struct1.Mf1)
-}
-// Mi1 = 10
-// Mf1 = 16.000000
+package main
+
+import (
+	"./struct_pack/structPack"
+	"fmt"
+)
+
+func main() {
+	struct1 := new(structPack.ExpStruct)
+	struct1.Mi1 = 10
+	struct1.Mf1 = 16.
+	fmt.Printf("Mi1 = %d\n", struct1.Mi1)
+	fmt.Printf("Mf1 = %f\n", struct1.Mf1)
+}
+
+// Mi1 = 10
+// Mf1 = 16.000000

eBook/examples/chapter_10/method1.go

@@ -1,29 +1,29 @@
-package main
-
-import "fmt"
-
-type TwoInts struct {
-	a int
-	b int
-}
-
-func main() {
-	two1 := new(TwoInts)
-	two1.a = 12
-	two1.b = 10
-
-	fmt.Printf("The sum is: %d\n", two1.AddThem())
-	fmt.Printf("Add them to the param: %d\n", two1.AddToParam(20))
-	
-	// literal:
-	two2 := TwoInts{3, 4}
-	fmt.Printf("The sum is: %d\n", two2.AddThem())
-}
-
-func (tn *TwoInts) AddThem() int {
-	return tn.a + tn.b
-}
-
-func (tn *TwoInts) AddToParam(param int) int {
-	return tn.a + tn.b + param
-}
+package main
+
+import "fmt"
+
+type TwoInts struct {
+	a int
+	b int
+}
+
+func main() {
+	two1 := new(TwoInts)
+	two1.a = 12
+	two1.b = 10
+
+	fmt.Printf("The sum is: %d\n", two1.AddThem())
+	fmt.Printf("Add them to the param: %d\n", two1.AddToParam(20))
+
+	// literal:
+	two2 := TwoInts{3, 4}
+	fmt.Printf("The sum is: %d\n", two2.AddThem())
+}
+
+func (tn *TwoInts) AddThem() int {
+	return tn.a + tn.b
+}
+
+func (tn *TwoInts) AddToParam(param int) int {
+	return tn.a + tn.b + param
+}

eBook/examples/chapter_10/method2.go

@@ -1,16 +1,16 @@
-package main
-
-import "fmt"
-
-type IntVector []int
-
-func (v IntVector) Sum() (s int) {
-	for _, x := range v {
-		s += x
-	}
-	return
-}
-
-func main() {
-	fmt.Println(IntVector{1, 2, 3}.Sum())  // Output: 6
-}
+package main
+
+import "fmt"
+
+type IntVector []int
+
+func (v IntVector) Sum() (s int) {
+	for _, x := range v {
+		s += x
+	}
+	return
+}
+
+func main() {
+	fmt.Println(IntVector{1, 2, 3}.Sum()) // Output: 6
+}

eBook/examples/chapter_10/method3.go

@@ -1,24 +1,24 @@
-package main
-
-import (
-	"fmt"
-	"math"
-)
-
-type Point struct {
-	x, y float64
-}
-
-func (p *Point) Abs() float64 {
-	return math.Sqrt(p.x*p.x + p.y*p.y)
-}
-
-type NamedPoint struct {
-	Point
-	name string
-}
-
-func main() {
-	n := &NamedPoint{Point{3, 4}, "Pythagoras"}
-	fmt.Println(n.Abs()) // prints 5
-}
+package main
+
+import (
+	"fmt"
+	"math"
+)
+
+type Point struct {
+	x, y float64
+}
+
+func (p *Point) Abs() float64 {
+	return math.Sqrt(p.x*p.x + p.y*p.y)
+}
+
+type NamedPoint struct {
+	Point
+	name string
+}
+
+func main() {
+	n := &NamedPoint{Point{3, 4}, "Pythagoras"}
+	fmt.Println(n.Abs()) // prints 5
+}

eBook/examples/chapter_10/method4.go

@@ -1,28 +1,28 @@
-package main
-
-import (
-	"fmt"
-	"math"
-)
-
-type Point struct {
-	x, y float64
-}
-
-func (p *Point) Abs() float64 {
-	return math.Sqrt(p.x*p.x + p.y*p.y)
-}
-
-type NamedPoint struct {
-	Point
-	name string
-}
-
-func (n *NamedPoint) Abs() float64 {
-	return n.Point.Abs() * 100.
-}
-
-func main() {
-	n := &NamedPoint{Point{3, 4}, "Pythagoras"}
-	fmt.Println(n.Abs()) // prints 500
-}
+package main
+
+import (
+	"fmt"
+	"math"
+)
+
+type Point struct {
+	x, y float64
+}
+
+func (p *Point) Abs() float64 {
+	return math.Sqrt(p.x*p.x + p.y*p.y)
+}
+
+type NamedPoint struct {
+	Point
+	name string
+}
+
+func (n *NamedPoint) Abs() float64 {
+	return n.Point.Abs() * 100.
+}
+
+func main() {
+	n := &NamedPoint{Point{3, 4}, "Pythagoras"}
+	fmt.Println(n.Abs()) // prints 500
+}

eBook/examples/chapter_10/method_on_time.go

@@ -1,25 +1,26 @@
-// method_on_time.go
-package main
-
-import (
-	"fmt"
-    "time"
-)
-
-type myTime struct {
-    time.Time //anonymous field
-}
-
-func (t myTime) first3Chars() string {
-    return t.Time.String()[0:3]
-}
-
-func main() {
-    m := myTime{time.Now()} 
-    fmt.Println("Full time now:", m.String()) //calling existing String method on anonymous Time field
-    fmt.Println("First 3 chars:", m.first3Chars()) //calling myTime.first3Chars
-}
-/* Output:
-Full time now: Mon Oct 24 15:34:54 Romance Daylight Time 2011
-First 3 chars: Mon
-*/
+// method_on_time.go
+package main
+
+import (
+	"fmt"
+	"time"
+)
+
+type myTime struct {
+	time.Time //anonymous field
+}
+
+func (t myTime) first3Chars() string {
+	return t.Time.String()[0:3]
+}
+
+func main() {
+	m := myTime{time.Now()}
+	fmt.Println("Full time now:", m.String())      //calling existing String method on anonymous Time field
+	fmt.Println("First 3 chars:", m.first3Chars()) //calling myTime.first3Chars
+}
+
+/* Output:
+Full time now: Mon Oct 24 15:34:54 Romance Daylight Time 2011
+First 3 chars: Mon
+*/

eBook/examples/chapter_10/method_string.go

@@ -1,27 +1,25 @@
-package main
-
-import (
-	"fmt"
-	"strconv"
-)
-
-type TwoInts struct {
-	a int
-	b int
-}
-
-func main() {
-	two1 := new(TwoInts)
-	two1.a = 12
-	two1.b = 10
-	fmt.Printf("two1 is: %v\n", two1)
-	fmt.Println("two1 is:", two1)
-	fmt.Printf("two1 is: %T\n", two1)
-	fmt.Printf("two1 is: %#v\n", two1)
-}
-
-func (tn *TwoInts) String() string {
-	return "(" + strconv.Itoa(tn.a) + " / " + strconv.Itoa(tn.b) + ")"
-}
-
-
+package main
+
+import (
+	"fmt"
+	"strconv"
+)
+
+type TwoInts struct {
+	a int
+	b int
+}
+
+func main() {
+	two1 := new(TwoInts)
+	two1.a = 12
+	two1.b = 10
+	fmt.Printf("two1 is: %v\n", two1)
+	fmt.Println("two1 is:", two1)
+	fmt.Printf("two1 is: %T\n", two1)
+	fmt.Printf("two1 is: %#v\n", two1)
+}
+
+func (tn *TwoInts) String() string {
+	return "(" + strconv.Itoa(tn.a) + " / " + strconv.Itoa(tn.b) + ")"
+}

eBook/examples/chapter_10/methodset1.go

@@ -1,22 +1,23 @@
-// methodset1.go
-package main
-
-import (
-	"fmt"
-)
-
-type List []int
-func (l List) Len() int { return len(l) }
-func (l *List) Append(val int) { *l = append(*l, val) }
-
-func main() {
-	  // A bare value
-        var lst List
-        lst.Append(1)
-        fmt.Printf("%v (len: %d)\n", lst, lst.Len()) // [1] (len: 1)
-
-        // A pointer value
-        plst := new(List)
-        plst.Append(2)
-        fmt.Printf("%v (len: %d)\n", plst, lst.Len()) // &[2] (len: 1)
-}
+// methodset1.go
+package main
+
+import (
+	"fmt"
+)
+
+type List []int
+
+func (l List) Len() int        { return len(l) }
+func (l *List) Append(val int) { *l = append(*l, val) }
+
+func main() {
+	// A bare value
+	var lst List
+	lst.Append(1)
+	fmt.Printf("%v (len: %d)\n", lst, lst.Len()) // [1] (len: 1)
+
+	// A pointer value
+	plst := new(List)
+	plst.Append(2)
+	fmt.Printf("%v (len: %d)\n", plst, lst.Len()) // &[2] (len: 1)
+}

eBook/examples/chapter_10/mult_inheritance.go

@@ -1,34 +1,35 @@
-// mult_inheritance.go
-package main
-
-import "fmt"
-
-type Camera struct { } 
-
-func (c *Camera) TakeAPicture() string { 
-    return "Click"
-}
-
-type Phone struct { } 
-
-func (p *Phone ) Call() string { 
-    return "Ring Ring"
-}
-
-// multiple inheritance
-type CameraPhone struct {
-    Camera 
-    Phone  
-}
-
-func main() {
-    cp := new(CameraPhone)  
-    fmt.Println("Our new CameraPhone exhibits multiple behaviors ...")
-    fmt.Println("It exhibits behavior of a Camera: ", cp.TakeAPicture())     
-	fmt.Println("It works like a Phone too: ", cp.Call()) 
-}
-/* Output:
-Our new CameraPhone exhibits multiple behaviors ...
-It exhibits behavior of a Camera:  Click
-It works like a Phone too:  Ring Ring
-*/
+// mult_inheritance.go
+package main
+
+import "fmt"
+
+type Camera struct{}
+
+func (c *Camera) TakeAPicture() string {
+	return "Click"
+}
+
+type Phone struct{}
+
+func (p *Phone) Call() string {
+	return "Ring Ring"
+}
+
+// multiple inheritance
+type CameraPhone struct {
+	Camera
+	Phone
+}
+
+func main() {
+	cp := new(CameraPhone)
+	fmt.Println("Our new CameraPhone exhibits multiple behaviors ...")
+	fmt.Println("It exhibits behavior of a Camera: ", cp.TakeAPicture())
+	fmt.Println("It works like a Phone too: ", cp.Call())
+}
+
+/* Output:
+Our new CameraPhone exhibits multiple behaviors ...
+It exhibits behavior of a Camera:  Click
+It works like a Phone too:  Ring Ring
+*/

eBook/examples/chapter_10/new_make.go

@@ -1,27 +1,27 @@
-// annoy1.go
-package main
-
-type Foo map[string]string
-type Bar struct {
-	thingOne string
-	thingTwo int
-}
-
-func main() {
-	// OK:
-	y := new(Bar)
-	(*y).thingOne = "hello"
-	(*y).thingTwo = 1
-	// not OK:
-	z := make(Bar) // compile error: cannot make type Bar
-	z.thingOne = "hello"
-	z.thingTwo = 1
-	// OK:
-	x := make(Foo)
-	x["x"] = "goodbye"
-	x["y"] = "world"
-	// not OK:
-	u := new(Foo)
-	(*u)["x"] = "goodbye" // !! panic !!: runtime error: assignment to entry in nil map
-	(*u)["y"] = "world"
-}
+// annoy1.go
+package main
+
+type Foo map[string]string
+type Bar struct {
+	thingOne string
+	thingTwo int
+}
+
+func main() {
+	// OK:
+	y := new(Bar)
+	(*y).thingOne = "hello"
+	(*y).thingTwo = 1
+	// not OK:
+	z := make(Bar) // compile error: cannot make type Bar
+	z.thingOne = "hello"
+	z.thingTwo = 1
+	// OK:
+	x := make(Foo)
+	x["x"] = "goodbye"
+	x["y"] = "world"
+	// not OK:
+	u := new(Foo)
+	(*u)["x"] = "goodbye" // !! panic !!: runtime error: assignment to entry in nil map
+	(*u)["y"] = "world"
+}

eBook/examples/chapter_10/person.go

@@ -1,41 +1,42 @@
-package main
-
-import (
-	"fmt"
-	"strings"
-)
-
-type Person struct {
-	firstName	string
-	lastName	string
-}
-
-func upPerson (p *Person) {
-	p.firstName = strings.ToUpper(p.firstName)
-	p.lastName = strings.ToUpper(p.lastName)
-}
-
-func main() {
-// 1- struct as a value type:
-	var pers1 Person
-	pers1.firstName = "Chris"
-	pers1.lastName = "Woodward"
-	upPerson(&pers1)
-	fmt.Printf("The name of the person is %s %s\n", pers1.firstName, pers1.lastName)
-// 2 - struct as a pointer:
-	pers2 := new(Person)
-	pers2.firstName = "Chris"
-	pers2.lastName = "Woodward"
-	(*pers2).lastName = "Woodward"
-	upPerson(pers2)
-	fmt.Printf("The name of the person is %s %s\n", pers2.firstName, pers2.lastName)
-// 3 - struct as a literal:
-	pers3 := &Person{"Chris","Woodward"}
-	upPerson(pers3)
-	fmt.Printf("The name of the person is %s %s\n", pers3.firstName, pers3.lastName)
-}	
-/* Output:
-The name of the person is CHRIS WOODWARD
-The name of the person is CHRIS WOODWARD
-The name of the person is CHRIS WOODWARD
-*/
+package main
+
+import (
+	"fmt"
+	"strings"
+)
+
+type Person struct {
+	firstName string
+	lastName  string
+}
+
+func upPerson(p *Person) {
+	p.firstName = strings.ToUpper(p.firstName)
+	p.lastName = strings.ToUpper(p.lastName)
+}
+
+func main() {
+	// 1- struct as a value type:
+	var pers1 Person
+	pers1.firstName = "Chris"
+	pers1.lastName = "Woodward"
+	upPerson(&pers1)
+	fmt.Printf("The name of the person is %s %s\n", pers1.firstName, pers1.lastName)
+	// 2 - struct as a pointer:
+	pers2 := new(Person)
+	pers2.firstName = "Chris"
+	pers2.lastName = "Woodward"
+	(*pers2).lastName = "Woodward"
+	upPerson(pers2)
+	fmt.Printf("The name of the person is %s %s\n", pers2.firstName, pers2.lastName)
+	// 3 - struct as a literal:
+	pers3 := &Person{"Chris", "Woodward"}
+	upPerson(pers3)
+	fmt.Printf("The name of the person is %s %s\n", pers3.firstName, pers3.lastName)
+}
+
+/* Output:
+The name of the person is CHRIS WOODWARD
+The name of the person is CHRIS WOODWARD
+The name of the person is CHRIS WOODWARD
+*/

eBook/examples/chapter_10/person2.go

@@ -1,17 +1,14 @@
-package person
-
-type Person struct {
-	firstName	string
-	lastName	string
-}
-
-func (p *Person) FirstName() string {
-	return p.firstName
-}
-
-func (p *Person) SetFirstName(newName string) {
-	 p.firstName = newName
-}
-
-
-
+package person
+
+type Person struct {
+	firstName string
+	lastName  string
+}
+
+func (p *Person) FirstName() string {
+	return p.firstName
+}
+
+func (p *Person) SetFirstName(newName string) {
+	p.firstName = newName
+}

eBook/examples/chapter_10/pointer_value.go

@@ -1,28 +1,29 @@
-// pointer_value.go
-package main
-
-import (
-	"fmt"
-)
-
-type B struct {
-	thing  int
-}
-
-func (b *B) change() {  b.thing = 1 }
-
-func (b B) write() string { return fmt.Sprint(b) }
-
-func main() {
-	  var b1 B  // b1 is value
-      b1.change()
-      fmt.Println(b1.write())
-
-      b2 := new(B)  // b2 is pointer
-      b2.change()
-      fmt.Println(b2.write())
-}
-/* Output:
-{1}
-{1}
-*/
+// pointer_value.go
+package main
+
+import (
+	"fmt"
+)
+
+type B struct {
+	thing int
+}
+
+func (b *B) change() { b.thing = 1 }
+
+func (b B) write() string { return fmt.Sprint(b) }
+
+func main() {
+	var b1 B // b1 is value
+	b1.change()
+	fmt.Println(b1.write())
+
+	b2 := new(B) // b2 is pointer
+	b2.change()
+	fmt.Println(b2.write())
+}
+
+/* Output:
+{1}
+{1}
+*/

eBook/examples/chapter_10/struct_conversions.go

@@ -1,24 +1,25 @@
-// struct_conversions.go
-package main
-
-import (
-	"fmt"
-)
-
-type number struct {
-	f	float32
-}
-
-type nr number   // alias type
-
-func main() {
-	a := number{5.0}
-	b := nr{5.0}
-	// var i float32 = b   // compile-error: cannot use b (type nr) as type float32 in assignment
-	// var i = float32(b)  // compile-error: cannot convert b (type nr) to type float32
-	// var c number = b    // compile-error: cannot use b (type nr) as type number in assignment
-	// needs a conversion:
-	var c = number(b)
-	fmt.Println(a, b, c)
-}
-// output: {5} {5} {5}
+// struct_conversions.go
+package main
+
+import (
+	"fmt"
+)
+
+type number struct {
+	f float32
+}
+
+type nr number // alias type
+
+func main() {
+	a := number{5.0}
+	b := nr{5.0}
+	// var i float32 = b   // compile-error: cannot use b (type nr) as type float32 in assignment
+	// var i = float32(b)  // compile-error: cannot convert b (type nr) to type float32
+	// var c number = b    // compile-error: cannot use b (type nr) as type number in assignment
+	// needs a conversion:
+	var c = number(b)
+	fmt.Println(a, b, c)
+}
+
+// output: {5} {5} {5}

eBook/examples/chapter_10/struct_pack/structPack.go

@@ -1,6 +1,6 @@
-package structPack
-
-type ExpStruct struct {
-	Mi1 int
-	Mf1 float32
-}
+package structPack
+
+type ExpStruct struct {
+	Mi1 int
+	Mf1 float32
+}

eBook/examples/chapter_10/struct_tag.go

@@ -1,30 +1,31 @@
-package main
-
-import (
-	"fmt"
-	"reflect"
-)
-
-type TagType struct {  //  tags
-	field1	bool	"An important answer"
-	field2	string	"The name of the thing"
-	field3	int     "How much there are"
-}
-
-func main() {
-	tt := TagType{true, "Barak Obama", 1}
-	for i:= 0; i < 3; i++ {
-			refTag(tt, i)
-	}
-}
-
-func refTag(tt TagType, ix int) {
-	ttType := reflect.TypeOf(tt)
-	ixField := ttType.Field(ix)
-	fmt.Printf("%v\n", ixField.Tag)
-}
-/* Output:
-An important answer
-The name of the thing
-How much there are
-*/
+package main
+
+import (
+	"fmt"
+	"reflect"
+)
+
+type TagType struct { //  tags
+	field1 bool   "An important answer"
+	field2 string "The name of the thing"
+	field3 int    "How much there are"
+}
+
+func main() {
+	tt := TagType{true, "Barak Obama", 1}
+	for i := 0; i < 3; i++ {
+		refTag(tt, i)
+	}
+}
+
+func refTag(tt TagType, ix int) {
+	ttType := reflect.TypeOf(tt)
+	ixField := ttType.Field(ix)
+	fmt.Printf("%v\n", ixField.Tag)
+}
+
+/* Output:
+An important answer
+The name of the thing
+How much there are
+*/

eBook/examples/chapter_10/structs_anonymous_fields.go

@@ -1,34 +1,34 @@
-package main
-
-import "fmt"
-
-type innerS struct {
-	in1  int
-	in2  int
-}
-
-type outerS struct {
-	b   int
-	c   float32
-	int    // anonymous field
-	innerS // anonymous field
-}
-
-func main() {
-	outer := new(outerS)
-	outer.b = 6
-	outer.c = 7.5
-	outer.int = 60
-	outer.in1 = 5
-	outer.in2 = 10
-
-	fmt.Printf("outer.b is: %d\n", outer.b)
-	fmt.Printf("outer.c is: %f\n", outer.c)
-	fmt.Printf("outer.int is: %d\n", outer.int)
-	fmt.Printf("outer.in1 is: %d\n", outer.in1)
-	fmt.Printf("outer.in2 is: %d\n", outer.in2)
-	// with a struct-literal:
-	outer2 := outerS{6, 7.5, 60, innerS{5, 10}}
-	fmt.Println("outer2 is: ", outer2)
-
-}
+package main
+
+import "fmt"
+
+type innerS struct {
+	in1 int
+	in2 int
+}
+
+type outerS struct {
+	b      int
+	c      float32
+	int    // anonymous field
+	innerS // anonymous field
+}
+
+func main() {
+	outer := new(outerS)
+	outer.b = 6
+	outer.c = 7.5
+	outer.int = 60
+	outer.in1 = 5
+	outer.in2 = 10
+
+	fmt.Printf("outer.b is: %d\n", outer.b)
+	fmt.Printf("outer.c is: %f\n", outer.c)
+	fmt.Printf("outer.int is: %d\n", outer.int)
+	fmt.Printf("outer.in1 is: %d\n", outer.in1)
+	fmt.Printf("outer.in2 is: %d\n", outer.in2)
+	// with a struct-literal:
+	outer2 := outerS{6, 7.5, 60, innerS{5, 10}}
+	fmt.Println("outer2 is: ", outer2)
+
+}

eBook/examples/chapter_10/structs_fields.go

@@ -1,23 +1,23 @@
-package main
-
-import "fmt"
-
-type struct1 struct {
-	i1   int
-	f1   float32
-	str  string
-}
-
-func main() {
-	// var ms *struct1 = new(struct1)
-	// better:
-	ms := new(struct1)
-	ms.i1 = 10
-	ms.f1 = 15.5
-	ms.str = "Chris"
-	// ms := &struct1{10, 15.5, "Chris"}
-	fmt.Printf("The int is: %d\n", ms.i1)
-	fmt.Printf("The float is: %f\n", ms.f1)
-	fmt.Printf("The string is: %s\n", ms.str)
-	fmt.Println(ms) // output: &{10 15.5 Chris}
-}
+package main
+
+import "fmt"
+
+type struct1 struct {
+	i1  int
+	f1  float32
+	str string
+}
+
+func main() {
+	// var ms *struct1 = new(struct1)
+	// better:
+	ms := new(struct1)
+	ms.i1 = 10
+	ms.f1 = 15.5
+	ms.str = "Chris"
+	// ms := &struct1{10, 15.5, "Chris"}
+	fmt.Printf("The int is: %d\n", ms.i1)
+	fmt.Printf("The float is: %f\n", ms.f1)
+	fmt.Printf("The string is: %s\n", ms.str)
+	fmt.Println(ms) // output: &{10 15.5 Chris}
+}

eBook/examples/chapter_10/use_person2.go

@@ -1,14 +1,14 @@
-package main
-
-import (
-	"fmt"
-	"./person"
-)
-
-func main() {
-	p := new(person.Person)
-	// error: p.firstName undefined (cannot refer to unexported field or method firstName)
-	// p.firstName = "Eric"
-	p.SetFirstName("Eric")
-	fmt.Println(p.FirstName()) // Output: Eric
-}
+package main
+
+import (
+	"./person"
+	"fmt"
+)
+
+func main() {
+	p := new(person.Person)
+	// error: p.firstName undefined (cannot refer to unexported field or method firstName)
+	// p.firstName = "Eric"
+	p.SetFirstName("Eric")
+	fmt.Println(p.FirstName()) // Output: Eric
+}

eBook/examples/chapter_11/cars.go

@@ -1,95 +1,94 @@
-// cars.go
-package main
-
-import (
-	"fmt"
-)
-
-
-type Any interface{}
-type Car struct {
-	Model   	string
-	Manufacturer	string
-	BuildYear	int
-    // ...
-}
-type Cars []*Car
-
-func main() {
-	// make some cars:
-	ford := &Car{"Fiesta","Ford", 2008}
-	bmw  := &Car{"XL 450", "BMW", 2011}
-	merc := &Car{"D600", "Mercedes", 2009}
-	bmw2 := &Car{"X 800", "BMW", 2008}
-	// query:
-	allCars := Cars([]*Car{ford, bmw, merc, bmw2})
-	allNewBMWs := allCars.FindAll(func(car *Car) bool {
-      return (car.Manufacturer == "BMW") && (car.BuildYear > 2010)
-	})
-	fmt.Println("AllCars: ", allCars)
-	fmt.Println("New BMWs: ", allNewBMWs)
-	//
-	manufacturers := []string{"Ford", "Aston Martin", "Land Rover", "BMW", "Jaguar"}
-	sortedAppender, sortedCars := MakeSortedAppender(manufacturers)
-	allCars.Process(sortedAppender)
-	fmt.Println("Map sortedCars: ", sortedCars)
-    BMWCount := len(sortedCars["BMW"])
-	fmt.Println("We have ", BMWCount, " BMWs")
-}
-
-// Process all cars with the given function f:
-func (cs Cars) Process(f func(car *Car)) {
-     for _, c := range cs {
-         f(c)
-     }
-}
-
-// Find all cars matching a given criteria.
-func (cs Cars) FindAll(f func(car *Car) bool) Cars {
-    cars := make([]*Car, 0)
-
-    cs.Process(func(c *Car) {
-        if f(c) {
-            cars = append(cars, c)
-        }
-    })
-    return cars
-}
-
-// Process cars and create new data.
-func (cs Cars) Map(f func(car *Car) Any) []Any {
-       result := make([]Any, 0)
-       ix := 0
-       cs.Process(func(c *Car) {
-           result[ix] = f(c)
-           ix++
-       })
-       return result
-}
-
-func MakeSortedAppender(manufacturers []string) (func(car *Car), map[string]Cars) {
-     // Prepare maps of sorted cars.
-       sortedCars := make(map[string]Cars)
-   
-       for _, m := range manufacturers {
-           sortedCars[m] = make([]*Car, 0)
-       }
-       sortedCars["Default"] = make([]*Car, 0)
-   
-       // Prepare appender function:
-       appender := func(c *Car) {
-           if _, ok := sortedCars[c.Manufacturer]; ok {
-               sortedCars[c.Manufacturer] = append(sortedCars[c.Manufacturer], c)
-           } else {
-               sortedCars["Default"] = append(sortedCars["Default"], c)
-           }
-       }
-       return appender, sortedCars
-}
-
-/* Output:
-AllCars:  [0xf8400038a0 0xf840003bd0 0xf840003ba0 0xf840003b70]
-New BMWs:  [0xf840003bd0]
-Map sortedCars:  map[Default:[0xf840003ba0] Jaguar:[] Land Rover:[] BMW:[0xf840003bd0 0xf840003b70] Aston Martin:[] Ford:[0xf8400038a0]]
-We have  2  BMWs
-*/
+// cars.go
+package main
+
+import (
+	"fmt"
+)
+
+type Any interface{}
+type Car struct {
+	Model        string
+	Manufacturer string
+	BuildYear    int
+	// ...
+}
+type Cars []*Car
+
+func main() {
+	// make some cars:
+	ford := &Car{"Fiesta", "Ford", 2008}
+	bmw := &Car{"XL 450", "BMW", 2011}
+	merc := &Car{"D600", "Mercedes", 2009}
+	bmw2 := &Car{"X 800", "BMW", 2008}
+	// query:
+	allCars := Cars([]*Car{ford, bmw, merc, bmw2})
+	allNewBMWs := allCars.FindAll(func(car *Car) bool {
+		return (car.Manufacturer == "BMW") && (car.BuildYear > 2010)
+	})
+	fmt.Println("AllCars: ", allCars)
+	fmt.Println("New BMWs: ", allNewBMWs)
+	//
+	manufacturers := []string{"Ford", "Aston Martin", "Land Rover", "BMW", "Jaguar"}
+	sortedAppender, sortedCars := MakeSortedAppender(manufacturers)
+	allCars.Process(sortedAppender)
+	fmt.Println("Map sortedCars: ", sortedCars)
+	BMWCount := len(sortedCars["BMW"])
+	fmt.Println("We have ", BMWCount, " BMWs")
+}
+
+// Process all cars with the given function f:
+func (cs Cars) Process(f func(car *Car)) {
+	for _, c := range cs {
+		f(c)
+	}
+}
+
+// Find all cars matching a given criteria.
+func (cs Cars) FindAll(f func(car *Car) bool) Cars {
+	cars := make([]*Car, 0)
+
+	cs.Process(func(c *Car) {
+		if f(c) {
+			cars = append(cars, c)
+		}
+	})
+	return cars
+}
+
+// Process cars and create new data.
+func (cs Cars) Map(f func(car *Car) Any) []Any {
+	result := make([]Any, 0)
+	ix := 0
+	cs.Process(func(c *Car) {
+		result[ix] = f(c)
+		ix++
+	})
+	return result
+}
+
+func MakeSortedAppender(manufacturers []string) (func(car *Car), map[string]Cars) {
+	// Prepare maps of sorted cars.
+	sortedCars := make(map[string]Cars)
+
+	for _, m := range manufacturers {
+		sortedCars[m] = make([]*Car, 0)
+	}
+	sortedCars["Default"] = make([]*Car, 0)
+
+	// Prepare appender function:
+	appender := func(c *Car) {
+		if _, ok := sortedCars[c.Manufacturer]; ok {
+			sortedCars[c.Manufacturer] = append(sortedCars[c.Manufacturer], c)
+		} else {
+			sortedCars["Default"] = append(sortedCars["Default"], c)
+		}
+	}
+	return appender, sortedCars
+}
+
+/* Output:
+AllCars:  [0xf8400038a0 0xf840003bd0 0xf840003ba0 0xf840003b70]
+New BMWs:  [0xf840003bd0]
+Map sortedCars:  map[Default:[0xf840003ba0] Jaguar:[] Land Rover:[] BMW:[0xf840003bd0 0xf840003b70] Aston Martin:[] Ford:[0xf8400038a0]]
+We have  2  BMWs
+*/

eBook/examples/chapter_11/duck_dance.go

@@ -1,32 +1,32 @@
-package main
-
-import "fmt"
-
-type IDuck interface {
-	Quack()
-	Walk()
-}
-
-func DuckDance(duck IDuck) {
-	for i := 1; i <= 3; i++ {
-		duck.Quack()
-		duck.Walk()
-	}
-}
-
-type Bird struct {
-	// ...
-}
-
-func (b *Bird) Quack() {
-	fmt.Println("I am quacking!")
-}
-
-func (b *Bird) Walk()  {
-	fmt.Println("I am walking!")
-}
-
-func main() {
-	b := new(Bird)
-	DuckDance(b)
-}
+package main
+
+import "fmt"
+
+type IDuck interface {
+	Quack()
+	Walk()
+}
+
+func DuckDance(duck IDuck) {
+	for i := 1; i <= 3; i++ {
+		duck.Quack()
+		duck.Walk()
+	}
+}
+
+type Bird struct {
+	// ...
+}
+
+func (b *Bird) Quack() {
+	fmt.Println("I am quacking!")
+}
+
+func (b *Bird) Walk() {
+	fmt.Println("I am walking!")
+}
+
+func main() {
+	b := new(Bird)
+	DuckDance(b)
+}

eBook/examples/chapter_11/empty_interface.go

@@ -1,38 +1,38 @@
-package main
-
-import "fmt"
-
-var i = 5
-var str = "ABC"
-
-type Person struct {
-	name string
-	age	int
-}
-
-type Any interface{}
-
-func main() {
-	var val Any
-	val = 5
-	fmt.Printf("val has the value: %v\n", val)
-	val = str
-	fmt.Printf("val has the value: %v\n", val)
-	pers1 := new(Person)
-	pers1.name = "Rob Pike"
-	pers1.age = 55
-	val = pers1
-	fmt.Printf("val has the value: %v\n", val)
-	switch t := val.(type) {
-		case int:
-			fmt.Printf("Type int %T\n", t)
-		case string:
-			fmt.Printf("Type string %T\n", t)
-		case bool:
-   			fmt.Printf("Type boolean %T\n", t)
-		case *Person:
-   			fmt.Printf("Type pointer to Person %T\n", *t)
-		default:
-   			fmt.Printf("Unexpected type %T", t)
-	}
-}
+package main
+
+import "fmt"
+
+var i = 5
+var str = "ABC"
+
+type Person struct {
+	name string
+	age  int
+}
+
+type Any interface{}
+
+func main() {
+	var val Any
+	val = 5
+	fmt.Printf("val has the value: %v\n", val)
+	val = str
+	fmt.Printf("val has the value: %v\n", val)
+	pers1 := new(Person)
+	pers1.name = "Rob Pike"
+	pers1.age = 55
+	val = pers1
+	fmt.Printf("val has the value: %v\n", val)
+	switch t := val.(type) {
+	case int:
+		fmt.Printf("Type int %T\n", t)
+	case string:
+		fmt.Printf("Type string %T\n", t)
+	case bool:
+		fmt.Printf("Type boolean %T\n", t)
+	case *Person:
+		fmt.Printf("Type pointer to Person %T\n", *t)
+	default:
+		fmt.Printf("Unexpected type %T", t)
+	}
+}

eBook/examples/chapter_11/emptyint_switch.go

@@ -29,4 +29,5 @@ func TypeSwitch() {
 func main() {
 	TypeSwitch()
 }
+
 // Output:  any hello is a special String!

eBook/examples/chapter_11/interfaces.go

@@ -1,30 +1,31 @@
-package main
-
-import "fmt"
-
-type Shaper interface {
-	Area() float32
-	// Perimeter() float32
-}
-
-type Square struct {
-	side float32
-}
-
-func (sq *Square) Area() float32 {
-	return sq.side * sq.side
-}
-
-func main() {
-	sq1 := new(Square)
-	sq1.side = 5
-
-	// var areaIntf Shaper
-	// areaIntf = sq1
-	// shorter, without separate declaration:
-	// areaIntf := Shaper(sq1) 
-	// or even:
-	areaIntf := sq1
-	fmt.Printf("The square has area: %f\n", areaIntf.Area())
-}
-// The square has area: 25.000000
+package main
+
+import "fmt"
+
+type Shaper interface {
+	Area() float32
+	// Perimeter() float32
+}
+
+type Square struct {
+	side float32
+}
+
+func (sq *Square) Area() float32 {
+	return sq.side * sq.side
+}
+
+func main() {
+	sq1 := new(Square)
+	sq1.side = 5
+
+	// var areaIntf Shaper
+	// areaIntf = sq1
+	// shorter, without separate declaration:
+	// areaIntf := Shaper(sq1)
+	// or even:
+	areaIntf := sq1
+	fmt.Printf("The square has area: %f\n", areaIntf.Area())
+}
+
+// The square has area: 25.000000

eBook/examples/chapter_11/interfaces_poly.go

@@ -1,45 +1,43 @@
-// interfaces_poly.go
-package main
-
-import "fmt"
-
-type Shaper interface {
-	Area() float32
-}
-
-type Square struct {
-	side float32
-}
-
-func (sq *Square) Area() float32 {
-	return sq.side * sq.side
-}
-
-type Rectangle struct {
-   length, width float32
-}
-
-func (r Rectangle) Area() float32 {
-   return r.length * r.width
-}
-
-func main() {
-   r := Rectangle{5, 3} // Area() of Rectangle needs a value
-   q := &Square{5}      // Area() of Square needs a pointer
-   shapes := []Shaper{r, q}
-   fmt.Println("Looping through shapes for area ...")
-   for n, _ := range shapes {
-       fmt.Println("Shape details: ", shapes[n])
-       fmt.Println("Area of this shape is: ", shapes[n].Area())
-   }
-}
-/* Output:
-Looping through shapes for area ...
-Shape details:  {5 3}
-Area of this shape is:  15
-Shape details:  &{5}
-Area of this shape is:  25
-*/
-
-
-
+// interfaces_poly.go
+package main
+
+import "fmt"
+
+type Shaper interface {
+	Area() float32
+}
+
+type Square struct {
+	side float32
+}
+
+func (sq *Square) Area() float32 {
+	return sq.side * sq.side
+}
+
+type Rectangle struct {
+	length, width float32
+}
+
+func (r Rectangle) Area() float32 {
+	return r.length * r.width
+}
+
+func main() {
+	r := Rectangle{5, 3} // Area() of Rectangle needs a value
+	q := &Square{5}      // Area() of Square needs a pointer
+	shapes := []Shaper{r, q}
+	fmt.Println("Looping through shapes for area ...")
+	for n := range shapes {
+		fmt.Println("Shape details: ", shapes[n])
+		fmt.Println("Area of this shape is: ", shapes[n].Area())
+	}
+}
+
+/* Output:
+Looping through shapes for area ...
+Shape details:  {5 3}
+Area of this shape is:  15
+Shape details:  &{5}
+Area of this shape is:  25
+*/

eBook/examples/chapter_11/methodset2.go

@@ -1,48 +1,49 @@
-// methodset2.go
-package main
-
-import (
-	"fmt"
-)
-
-type List []int
-func (l List) Len() int { return len(l) }
-func (l *List) Append(val int) { *l = append(*l, val) }
-
-type Appender interface {
-        Append(int)
-}
-
-func CountInto(a Appender, start, end int) {
-        for i := start; i <= end; i++ {
-                a.Append(i)
-        }
-}
-
-type Lener interface {
-        Len() int
-}
-
-func LongEnough(l Lener) bool {
-        return l.Len()*10 > 42
-}
-
-func main() {
-		// A bare value
-        var lst List
-		// compiler error:
-		// cannot use lst (type List) as type Appender in function argument:
-		// List does not implement Appender (Append method requires pointer receiver)
-        // CountInto(lst, 1, 10) // INVALID: Append has a pointer receiver
-		
-        if LongEnough(lst) {  // VALID: Identical receiver type
-                fmt.Printf(" - lst is long enough")
-        }
-
-        // A pointer value
-        plst := new(List)
-        CountInto(plst, 1, 10) // VALID: Identical receiver type
-        if LongEnough(plst) {  // VALID: a *List can be dereferenced for the receiver
-                fmt.Printf(" - plst is long enough")  //  - plst is long enoug
-        }      
-}
+// methodset2.go
+package main
+
+import (
+	"fmt"
+)
+
+type List []int
+
+func (l List) Len() int        { return len(l) }
+func (l *List) Append(val int) { *l = append(*l, val) }
+
+type Appender interface {
+	Append(int)
+}
+
+func CountInto(a Appender, start, end int) {
+	for i := start; i <= end; i++ {
+		a.Append(i)
+	}
+}
+
+type Lener interface {
+	Len() int
+}
+
+func LongEnough(l Lener) bool {
+	return l.Len()*10 > 42
+}
+
+func main() {
+	// A bare value
+	var lst List
+	// compiler error:
+	// cannot use lst (type List) as type Appender in function argument:
+	// List does not implement Appender (Append method requires pointer receiver)
+	// CountInto(lst, 1, 10) // INVALID: Append has a pointer receiver
+
+	if LongEnough(lst) { // VALID: Identical receiver type
+		fmt.Printf(" - lst is long enough")
+	}
+
+	// A pointer value
+	plst := new(List)
+	CountInto(plst, 1, 10) // VALID: Identical receiver type
+	if LongEnough(plst) {  // VALID: a *List can be dereferenced for the receiver
+		fmt.Printf(" - plst is long enough") //  - plst is long enoug
+	}
+}

eBook/examples/chapter_11/multi_interfaces_poly.go

@@ -1,65 +1,66 @@
-//multi_interfaces_poly.go
-package main
-
-import "fmt"
-
-type Shaper interface {
-	Area() float32
-}
-
-type TopologicalGenus interface {
-	Rank() int
-}
-
-type Square struct {
-	side float32
-}
-
-func (sq *Square) Area() float32 {
-	return sq.side * sq.side
-}
-
-func (sq *Square) Rank() int {
-	return 1
-}
-
-type Rectangle struct {
-	length, width float32
-}
-
-func (r Rectangle) Area() float32 {
-	return r.length * r.width
-}
-
-func (r Rectangle) Rank() int {
-	return 2
-}
-
-func main() {
-	r := Rectangle{5, 3} // Area() of Rectangle needs a value
-	q := &Square{5}      // Area() of Square needs a pointer
-	shapes := []Shaper{r, q}
-	fmt.Println("Looping through shapes for area ...")
-	for n, _ := range shapes {
-		fmt.Println("Shape details: ", shapes[n])
-		fmt.Println("Area of this shape is: ", shapes[n].Area())
-	}
-	topgen := []TopologicalGenus{r, q}
-	fmt.Println("Looping through topgen for rank ...")
-	for n, _ := range topgen {
-		fmt.Println("Shape details: ", topgen[n])
-		fmt.Println("Topological Genus of this shape is: ", topgen[n].Rank())
-	}
-}
-/* Output:
-Looping through shapes for area ...
-Shape details:  {5 3}
-Area of this shape is:  15
-Shape details:  &{5}
-Area of this shape is:  25
-Looping through topgen for rank ...
-Shape details:  {5 3}
-Topological Genus of this shape is:  2
-Shape details:  &{5}
-Topological Genus of this shape is:  1
-*/
+//multi_interfaces_poly.go
+package main
+
+import "fmt"
+
+type Shaper interface {
+	Area() float32
+}
+
+type TopologicalGenus interface {
+	Rank() int
+}
+
+type Square struct {
+	side float32
+}
+
+func (sq *Square) Area() float32 {
+	return sq.side * sq.side
+}
+
+func (sq *Square) Rank() int {
+	return 1
+}
+
+type Rectangle struct {
+	length, width float32
+}
+
+func (r Rectangle) Area() float32 {
+	return r.length * r.width
+}
+
+func (r Rectangle) Rank() int {
+	return 2
+}
+
+func main() {
+	r := Rectangle{5, 3} // Area() of Rectangle needs a value
+	q := &Square{5}      // Area() of Square needs a pointer
+	shapes := []Shaper{r, q}
+	fmt.Println("Looping through shapes for area ...")
+	for n := range shapes {
+		fmt.Println("Shape details: ", shapes[n])
+		fmt.Println("Area of this shape is: ", shapes[n].Area())
+	}
+	topgen := []TopologicalGenus{r, q}
+	fmt.Println("Looping through topgen for rank ...")
+	for n := range topgen {
+		fmt.Println("Shape details: ", topgen[n])
+		fmt.Println("Topological Genus of this shape is: ", topgen[n].Rank())
+	}
+}
+
+/* Output:
+Looping through shapes for area ...
+Shape details:  {5 3}
+Area of this shape is:  15
+Shape details:  &{5}
+Area of this shape is:  25
+Looping through topgen for rank ...
+Shape details:  {5 3}
+Topological Genus of this shape is:  2
+Shape details:  &{5}
+Topological Genus of this shape is:  1
+*/

eBook/examples/chapter_11/node_structures.go

@@ -1,31 +1,31 @@
-// node_structures.go
-package main
-
-import "fmt"
-
-type Node struct {
-	le    *Node
-	data  interface{}
-	ri    *Node
-}
-
-func NewNode(left, right *Node) *Node {
-	return &Node{left, nil, right}
-}
-
-func (n *Node) SetData(data interface{}) {
-	n.data = data
-}
-
-func main() {
-	root := NewNode(nil,nil)
-	root.SetData("root node")
-	// make child (leaf) nodes:
-	a := NewNode(nil,nil)
-	a.SetData("left node")
-	b := NewNode(nil,nil)
-	b.SetData("right node")
-	root.le = a
-	root.ri = b
-	fmt.Printf("%v\n", root) // Output: &{0x125275f0 root node 0x125275e0}
-}
+// node_structures.go
+package main
+
+import "fmt"
+
+type Node struct {
+	le   *Node
+	data interface{}
+	ri   *Node
+}
+
+func NewNode(left, right *Node) *Node {
+	return &Node{left, nil, right}
+}
+
+func (n *Node) SetData(data interface{}) {
+	n.data = data
+}
+
+func main() {
+	root := NewNode(nil, nil)
+	root.SetData("root node")
+	// make child (leaf) nodes:
+	a := NewNode(nil, nil)
+	a.SetData("left node")
+	b := NewNode(nil, nil)
+	b.SetData("right node")
+	root.le = a
+	root.ri = b
+	fmt.Printf("%v\n", root) // Output: &{0x125275f0 root node 0x125275e0}
+}

eBook/examples/chapter_11/print.go

@@ -1,43 +1,50 @@
-// print.go
-package main
-
-import (
-	"os"
-	"strconv"
-)
-
-type Stringer interface {
-	String() string
-}
-
-type Celsius float64
-
-func (c Celsius) String() string {
-	return strconv.FormatFloat(float64(c),'f', 1, 64) + " °C"
-}
-
-type Day int
-
-var dayName = []string{"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"}
-
-func (day Day) String() string {
-	return dayName[day]
-}
-
-func print(args ...interface{}) {
-	for i, arg := range args {
-		if i > 0 {os.Stdout.WriteString(" ")}
-		switch a := arg.(type) { // type switch
-			case Stringer:	os.Stdout.WriteString(a.String())
-			case int:		os.Stdout.WriteString(strconv.Itoa(a))
-			case string:	os.Stdout.WriteString(a)
-			// more types
-			default:		os.Stdout.WriteString("???")
-		}
-	}
-}
-
-func main() {
-	print(Day(1), "was", Celsius(18.36))  // Tuesday was 18.4 °C
-}
-// Tuesday was 18.4 °C
+// print.go
+package main
+
+import (
+	"os"
+	"strconv"
+)
+
+type Stringer interface {
+	String() string
+}
+
+type Celsius float64
+
+func (c Celsius) String() string {
+	return strconv.FormatFloat(float64(c), 'f', 1, 64) + " °C"
+}
+
+type Day int
+
+var dayName = []string{"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"}
+
+func (day Day) String() string {
+	return dayName[day]
+}
+
+func print(args ...interface{}) {
+	for i, arg := range args {
+		if i > 0 {
+			os.Stdout.WriteString(" ")
+		}
+		switch a := arg.(type) { // type switch
+		case Stringer:
+			os.Stdout.WriteString(a.String())
+		case int:
+			os.Stdout.WriteString(strconv.Itoa(a))
+		case string:
+			os.Stdout.WriteString(a)
+		// more types
+		default:
+			os.Stdout.WriteString("???")
+		}
+	}
+}
+
+func main() {
+	print(Day(1), "was", Celsius(18.36)) // Tuesday was 18.4 °C
+}
+
+// Tuesday was 18.4 °C

eBook/examples/chapter_11/reflect1.go

@@ -1,32 +1,33 @@
-// reflect1.go
-// blog: Laws of Reflection
-package main
-
-import (
-	"fmt"
-	"reflect"
-)
-
-func main() {
-	var x float64 = 3.4
-	fmt.Println("type:", reflect.TypeOf(x))
-	v := reflect.ValueOf(x)
-	fmt.Println("value:", v)
-	fmt.Println("type:", v.Type())
-	fmt.Println("kind:", v.Kind())
-	fmt.Println("value:", v.Float())
-	fmt.Println(v.Interface())
-	fmt.Printf("value is %5.2e\n", v.Interface())
-	y := v.Interface().(float64)
-	fmt.Println(y)
-}
-/* output: 
-type: float64
-value: <float64 Value>
-type: float64
-kind: float64
-value: 3.4
-3.4
-value is 3.40e+00
-3.4
-*/
+// reflect1.go
+// blog: Laws of Reflection
+package main
+
+import (
+	"fmt"
+	"reflect"
+)
+
+func main() {
+	var x float64 = 3.4
+	fmt.Println("type:", reflect.TypeOf(x))
+	v := reflect.ValueOf(x)
+	fmt.Println("value:", v)
+	fmt.Println("type:", v.Type())
+	fmt.Println("kind:", v.Kind())
+	fmt.Println("value:", v.Float())
+	fmt.Println(v.Interface())
+	fmt.Printf("value is %5.2e\n", v.Interface())
+	y := v.Interface().(float64)
+	fmt.Println(y)
+}
+
+/* output:
+type: float64
+value: <float64 Value>
+type: float64
+kind: float64
+value: 3.4
+3.4
+value is 3.40e+00
+3.4
+*/

eBook/examples/chapter_11/reflect2.go

@@ -1,33 +1,34 @@
-// reflect2.go
-package main
-
-import (
-	"fmt"
-	"reflect"
-)
-
-func main() {
-	var x float64 = 3.4
-	v := reflect.ValueOf(x)
-	// setting a value:
-	// v.SetFloat(3.1415) // Error: will panic: reflect.Value.SetFloat using unaddressable value
-	fmt.Println("settability of v:", v.CanSet())
-	v = reflect.ValueOf(&x) // Note: take the address of x.
-	fmt.Println("type of v:", v.Type())
-	fmt.Println("settability of v:", v.CanSet())
-	v = v.Elem()
-	fmt.Println("The Elem of v is: ", v)
-	fmt.Println("settability of v:", v.CanSet())
-	v.SetFloat(3.1415) // this works!
-	fmt.Println(v.Interface())
-	fmt.Println(v)
-}
-/* Output:
-settability of v: false
-type of v: *float64
-settability of v: false
-The Elem of v is:  <float64 Value>
-settability of v: true
-3.1415
-<float64 Value>
-*/
+// reflect2.go
+package main
+
+import (
+	"fmt"
+	"reflect"
+)
+
+func main() {
+	var x float64 = 3.4
+	v := reflect.ValueOf(x)
+	// setting a value:
+	// v.SetFloat(3.1415) // Error: will panic: reflect.Value.SetFloat using unaddressable value
+	fmt.Println("settability of v:", v.CanSet())
+	v = reflect.ValueOf(&x) // Note: take the address of x.
+	fmt.Println("type of v:", v.Type())
+	fmt.Println("settability of v:", v.CanSet())
+	v = v.Elem()
+	fmt.Println("The Elem of v is: ", v)
+	fmt.Println("settability of v:", v.CanSet())
+	v.SetFloat(3.1415) // this works!
+	fmt.Println(v.Interface())
+	fmt.Println(v)
+}
+
+/* Output:
+settability of v: false
+type of v: *float64
+settability of v: false
+The Elem of v is:  <float64 Value>
+settability of v: true
+3.1415
+<float64 Value>
+*/

eBook/examples/chapter_11/reflect_struct.go

@@ -1,47 +1,48 @@
-// reflect.go
-package main
-
-import (
-	"fmt"
-	"reflect"
-)
-
-type NotknownType struct {
-	s1, s2, s3	string
-}
-
-func (n NotknownType) String() string {
-	return n.s1 + " - " + n.s2 + " - " + n.s3
-}
-
-// variable to investigate:
-var secret interface {} = NotknownType{"Ada", "Go", "Oberon"}
-
-func main() {
-	value := reflect.ValueOf(secret)  // <main.NotknownType Value>
-	typ := reflect.TypeOf(secret)   // main.NotknownType
-	// alternative:
-	//typ := value.Type()  // main.NotknownType
-	fmt.Println(typ)
-	knd := value.Kind()  // struct
-	fmt.Println(knd)
-
-	// iterate through the fields of the struct:
-	for i:= 0; i < value.NumField(); i++ {
-		fmt.Printf("Field %d: %v\n", i, value.Field(i))
-		// error: panic: reflect.Value.SetString using value obtained using unexported field
-		//value.Field(i).SetString("C#") 
-	}
-	
-	// call the first method, which is String():
-	results := value.Method(0).Call(nil)
-	fmt.Println(results)  // [Ada - Go - Oberon]
-}
-/* Output:
-main.NotknownType
-struct
-Field 0: Ada
-Field 1: Go
-Field 2: Oberon
-[Ada - Go - Oberon]
-*/
+// reflect.go
+package main
+
+import (
+	"fmt"
+	"reflect"
+)
+
+type NotknownType struct {
+	s1, s2, s3 string
+}
+
+func (n NotknownType) String() string {
+	return n.s1 + " - " + n.s2 + " - " + n.s3
+}
+
+// variable to investigate:
+var secret interface{} = NotknownType{"Ada", "Go", "Oberon"}
+
+func main() {
+	value := reflect.ValueOf(secret) // <main.NotknownType Value>
+	typ := reflect.TypeOf(secret)    // main.NotknownType
+	// alternative:
+	//typ := value.Type()  // main.NotknownType
+	fmt.Println(typ)
+	knd := value.Kind() // struct
+	fmt.Println(knd)
+
+	// iterate through the fields of the struct:
+	for i := 0; i < value.NumField(); i++ {
+		fmt.Printf("Field %d: %v\n", i, value.Field(i))
+		// error: panic: reflect.Value.SetString using value obtained using unexported field
+		//value.Field(i).SetString("C#")
+	}
+
+	// call the first method, which is String():
+	results := value.Method(0).Call(nil)
+	fmt.Println(results) // [Ada - Go - Oberon]
+}
+
+/* Output:
+main.NotknownType
+struct
+Field 0: Ada
+Field 1: Go
+Field 2: Oberon
+[Ada - Go - Oberon]
+*/

eBook/examples/chapter_11/reflect_struct2.go

@@ -1,31 +1,32 @@
-// reflect_struct2.go
-package main
-
-import (
-	"fmt"
-	"reflect"
-)
-
-type T struct {
-	A int
-	B string
-}
-
-func main() {
-	t := T{23, "skidoo"}
-	s := reflect.ValueOf(&t).Elem()
-	typeOfT := s.Type()
-	for i := 0; i < s.NumField(); i++ {
-		f := s.Field(i)
-		fmt.Printf("%d: %s %s = %v\n", i,
-			typeOfT.Field(i).Name, f.Type(), f.Interface())
-	}
-	s.Field(0).SetInt(77)
-	s.Field(1).SetString("Sunset Strip")
-	fmt.Println("t is now", t)
-}
-/* Output:
-0: A int = 23
-1: B string = skidoo
-t is now {77 Sunset Strip}
-*/
+// reflect_struct2.go
+package main
+
+import (
+	"fmt"
+	"reflect"
+)
+
+type T struct {
+	A int
+	B string
+}
+
+func main() {
+	t := T{23, "skidoo"}
+	s := reflect.ValueOf(&t).Elem()
+	typeOfT := s.Type()
+	for i := 0; i < s.NumField(); i++ {
+		f := s.Field(i)
+		fmt.Printf("%d: %s %s = %v\n", i,
+			typeOfT.Field(i).Name, f.Type(), f.Interface())
+	}
+	s.Field(0).SetInt(77)
+	s.Field(1).SetString("Sunset Strip")
+	fmt.Println("t is now", t)
+}
+
+/* Output:
+0: A int = 23
+1: B string = skidoo
+t is now {77 Sunset Strip}
+*/

eBook/examples/chapter_11/sort/sort.go

@@ -1,58 +1,60 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-// Sorting using a general interface
-package sort
-
-// Sorting interface
-type Interface interface {
-	Len() int
-	Less(i, j int) bool
-	Swap(i, j int)
-}
-
-// General sort function
-func Sort(data Interface) {
-	for i := 1; i < data.Len(); i++ {
-		for j := i; j > 0 && data.Less(j, j-1); j-- {
-			data.Swap(j, j-1)
-		}
-	}
-}
-
-// Test if data is sorted
-func IsSorted(data Interface) bool {
-	n := data.Len()
-	for i := n - 1; i > 0; i-- {
-		if data.Less(i, i-1) {
-			return false
-		}
-	}
-	return true
-}
-
-// Convenience types for common cases: IntArray
-type IntArray []int
-
-func (p IntArray) Len() int           { return len(p) }
-func (p IntArray) Less(i, j int) bool { return p[i] < p[j] }
-func (p IntArray) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
-
-type Float64Array []float64
-func (p Float64Array) Len() int           { return len(p) }
-func (p Float64Array) Less(i, j int) bool { return p[i] < p[j] }
-func (p Float64Array) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
-
-type StringArray []string
-func (p StringArray) Len() int           { return len(p) }
-func (p StringArray) Less(i, j int) bool { return p[i] < p[j] }
-func (p StringArray) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
-
-// Convenience wrappers for common cases
-func SortInts(a []int)         { Sort(IntArray(a)) }
-func SortFloat64s(a []float64) { Sort(Float64Array(a)) }
-func SortStrings(a []string)   { Sort(StringArray(a)) }
-
-func IntsAreSorted(a []int) bool         { return IsSorted(IntArray(a)) }
-func Float64sAreSorted(a []float64) bool { return IsSorted(Float64Array(a)) }
-func StringsAreSorted(a []string) bool   { return IsSorted(StringArray(a)) }
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+// Sorting using a general interface
+package sort
+
+// Sorting interface
+type Interface interface {
+	Len() int
+	Less(i, j int) bool
+	Swap(i, j int)
+}
+
+// General sort function
+func Sort(data Interface) {
+	for i := 1; i < data.Len(); i++ {
+		for j := i; j > 0 && data.Less(j, j-1); j-- {
+			data.Swap(j, j-1)
+		}
+	}
+}
+
+// Test if data is sorted
+func IsSorted(data Interface) bool {
+	n := data.Len()
+	for i := n - 1; i > 0; i-- {
+		if data.Less(i, i-1) {
+			return false
+		}
+	}
+	return true
+}
+
+// Convenience types for common cases: IntArray
+type IntArray []int
+
+func (p IntArray) Len() int           { return len(p) }
+func (p IntArray) Less(i, j int) bool { return p[i] < p[j] }
+func (p IntArray) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
+
+type Float64Array []float64
+
+func (p Float64Array) Len() int           { return len(p) }
+func (p Float64Array) Less(i, j int) bool { return p[i] < p[j] }
+func (p Float64Array) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
+
+type StringArray []string
+
+func (p StringArray) Len() int           { return len(p) }
+func (p StringArray) Less(i, j int) bool { return p[i] < p[j] }
+func (p StringArray) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
+
+// Convenience wrappers for common cases
+func SortInts(a []int)         { Sort(IntArray(a)) }
+func SortFloat64s(a []float64) { Sort(Float64Array(a)) }
+func SortStrings(a []string)   { Sort(StringArray(a)) }
+
+func IntsAreSorted(a []int) bool         { return IsSorted(IntArray(a)) }
+func Float64sAreSorted(a []float64) bool { return IsSorted(Float64Array(a)) }
+func StringsAreSorted(a []string) bool   { return IsSorted(StringArray(a)) }

eBook/examples/chapter_11/sortmain.go

@@ -1,82 +1,81 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This package gives an example of how to use a custom package with interfaces   	
-package main
-     	
-import (
-     	"fmt"
-     	"./sort"
-)
-    	
-// sorting of slice of integers
-func ints() {
-    	data := []int{74, 59, 238, -784, 9845, 959, 905, 0, 0, 42, 7586, -5467984, 7586}
-    	a := sort.IntArray(data)  //conversion to type IntArray
-    	sort.Sort(a)
-    	if !sort.IsSorted(a) {
-    			panic("fail")
-    	}
-	    fmt.Printf("The sorted array is: %v\n", a)
-}
-    	
-// sorting of slice of strings
-func strings() {
-    	data := []string{"monday", "friday", "tuesday", "wednesday", "sunday","thursday", "", "saturday"}
-    	a := sort.StringArray(data)
-    	sort.Sort(a)
-    	if !sort.IsSorted(a) {
-    			panic("fail")
-		}
-	    fmt.Printf("The sorted array is: %v\n", a)
-}
-    	
-// a type which describes a day of the week
-type day struct {
-    	num        int
-    	shortName  string
-    	longName   string
-}
-    	
-type dayArray struct {
-    	data []*day
-}
-    	
-func (p *dayArray) Len() int            { return len(p.data) }
-func (p *dayArray) Less(i, j int) bool  { return p.data[i].num < p.data[j].num }
-func (p *dayArray) Swap(i, j int)       { p.data[i], p.data[j] = p.data[j], p.data[i] }
-    	
-// sorting of custom type day
-func days() {
-    	Sunday :=    day{0, "SUN", "Sunday"}
-    	Monday :=    day{1, "MON", "Monday"}
-    	Tuesday :=   day{2, "TUE", "Tuesday"}
-    	Wednesday := day{3, "WED", "Wednesday"}
-    	Thursday :=  day{4, "THU", "Thursday"}
-    	Friday :=    day{5, "FRI", "Friday"}
-    	Saturday :=  day{6, "SAT", "Saturday"}
-    	data := []*day{&Tuesday, &Thursday, &Wednesday, &Sunday, &Monday, &Friday, &Saturday}
-    	a := dayArray{data}
-    	sort.Sort(&a)
-    	if !sort.IsSorted(&a) {
-    			panic("fail")
-    	}
-    	for _, d := range data {
-    			fmt.Printf("%s ", d.longName)
-    	}
-    	fmt.Printf("\n")
-}
-    	
-    	
-func main() {
-    ints()
-    strings()
-    days()
-}
-
-/* Output:
-The sorted array is: [-5467984 -784 0 0 42 59 74 238 905 959 7586 7586 9845]
-The sorted array is: [ friday monday saturday sunday thursday tuesday wednesday]
-Sunday Monday Tuesday Wednesday Thursday Friday Saturday 
-*/
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This package gives an example of how to use a custom package with interfaces
+package main
+
+import (
+	"./sort"
+	"fmt"
+)
+
+// sorting of slice of integers
+func ints() {
+	data := []int{74, 59, 238, -784, 9845, 959, 905, 0, 0, 42, 7586, -5467984, 7586}
+	a := sort.IntArray(data) //conversion to type IntArray
+	sort.Sort(a)
+	if !sort.IsSorted(a) {
+		panic("fail")
+	}
+	fmt.Printf("The sorted array is: %v\n", a)
+}
+
+// sorting of slice of strings
+func strings() {
+	data := []string{"monday", "friday", "tuesday", "wednesday", "sunday", "thursday", "", "saturday"}
+	a := sort.StringArray(data)
+	sort.Sort(a)
+	if !sort.IsSorted(a) {
+		panic("fail")
+	}
+	fmt.Printf("The sorted array is: %v\n", a)
+}
+
+// a type which describes a day of the week
+type day struct {
+	num       int
+	shortName string
+	longName  string
+}
+
+type dayArray struct {
+	data []*day
+}
+
+func (p *dayArray) Len() int           { return len(p.data) }
+func (p *dayArray) Less(i, j int) bool { return p.data[i].num < p.data[j].num }
+func (p *dayArray) Swap(i, j int)      { p.data[i], p.data[j] = p.data[j], p.data[i] }
+
+// sorting of custom type day
+func days() {
+	Sunday := day{0, "SUN", "Sunday"}
+	Monday := day{1, "MON", "Monday"}
+	Tuesday := day{2, "TUE", "Tuesday"}
+	Wednesday := day{3, "WED", "Wednesday"}
+	Thursday := day{4, "THU", "Thursday"}
+	Friday := day{5, "FRI", "Friday"}
+	Saturday := day{6, "SAT", "Saturday"}
+	data := []*day{&Tuesday, &Thursday, &Wednesday, &Sunday, &Monday, &Friday, &Saturday}
+	a := dayArray{data}
+	sort.Sort(&a)
+	if !sort.IsSorted(&a) {
+		panic("fail")
+	}
+	for _, d := range data {
+		fmt.Printf("%s ", d.longName)
+	}
+	fmt.Printf("\n")
+}
+
+func main() {
+	ints()
+	strings()
+	days()
+}
+
+/* Output:
+The sorted array is: [-5467984 -784 0 0 42 59 74 238 905 959 7586 7586 9845]
+The sorted array is: [ friday monday saturday sunday thursday tuesday wednesday]
+Sunday Monday Tuesday Wednesday Thursday Friday Saturday
+*/

eBook/examples/chapter_11/static.go

@@ -1,23 +1,23 @@
-// static.go
-package main
-
-import (
-	"io"
-	"os"
-	"bufio"
-	"bytes"
-	"fmt"
-)
-
-var r io.Reader
-
-func main() {
-	r = os.Stdin
-	r = bufio.NewReader(r)
-	r = new(bytes.Buffer)
-	f, _ := os.Open("test.txt")
-	r = bufio.NewReader(f)
-	var s *bytes.Buffer = new(bytes.Buffer)
-	r = s
-	fmt.Println(s)
-}
+// static.go
+package main
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"io"
+	"os"
+)
+
+var r io.Reader
+
+func main() {
+	r = os.Stdin
+	r = bufio.NewReader(r)
+	r = new(bytes.Buffer)
+	f, _ := os.Open("test.txt")
+	r = bufio.NewReader(f)
+	var s *bytes.Buffer = new(bytes.Buffer)
+	r = s
+	fmt.Println(s)
+}

eBook/examples/chapter_11/tideland-cgl.googlecode.com/hg/cgl.go

@@ -43,8 +43,8 @@ package cgl
 import (
 	"bytes"
 	"crypto/rand"
-	"fmt"
 	"encoding/hex"
+	"fmt"
 	"io"
 	"log"
 	"reflect"
@@ -120,7 +120,7 @@ func (uuid UUID) String() string {
 // MORE ID FUNCTIONS
 //--------------------
 
-// LimitedSepIdentifier builds an identifier out of multiple parts, 
+// LimitedSepIdentifier builds an identifier out of multiple parts,
 // all as lowercase strings and concatenated with the separator
 // Non letters and digits are exchanged with dashes and
 // reduced to a maximum of one each. If limit is true only
@@ -173,8 +173,8 @@ func Identifier(parts ...interface{}) string {
 	return SepIdentifier(":", parts...)
 }
 
-// TypeAsIdentifierPart transforms the name of the arguments type into 
-// a part for identifiers. It's splitted at each uppercase char, 
+// TypeAsIdentifierPart transforms the name of the arguments type into
+// a part for identifiers. It's splitted at each uppercase char,
 // concatenated with dashes and transferred to lowercase.
 func TypeAsIdentifierPart(i interface{}) string {
 	var buf bytes.Buffer

eBook/examples/chapter_11/tideland-cgl.googlecode.com/hg/cglmon.go

@@ -151,7 +151,7 @@ func (sm *SystemMonitor) MeasuringPointsMap(f func(*MeasuringPoint) interface{})
 	return resp.([]interface{})
 }
 
-// MeasuringPointsDo performs the function f for 
+// MeasuringPointsDo performs the function f for
 // all measuring points.
 func (sm *SystemMonitor) MeasuringPointsDo(f func(*MeasuringPoint)) {
 	cmd := &command{cmdMeasuringPointsDo, f, nil}
@@ -450,7 +450,7 @@ type Measuring struct {
 	endTime       int64
 }
 
-// EndMEasuring ends a measuring and passes it to the 
+// EndMEasuring ends a measuring and passes it to the
 // measuring server in the background.
 func (m *Measuring) EndMeasuring() int64 {
 	m.endTime = time.Nanoseconds()

eBook/examples/chapter_11/type_interfaces.go

@@ -1,62 +1,62 @@
-package main
-
-import (
-	"fmt"
-	"math"
-)
-
-type Square struct {
-	side float32
-}
-
-type Circle struct {
-	radius float32
-}
-
-type Shaper interface {
-	Area() float32
-}
-
-func main() {
-	var areaIntf Shaper
-	sq1 := new(Square)
-	sq1.side = 5
-
-	areaIntf = sq1
-	// Is Square the type of areaIntf ?
-	if t, ok := areaIntf.(*Square); ok {
-		fmt.Printf("The type of areaIntf is: %T\n", t)
-	}
-	if u, ok := areaIntf.(*Circle); ok {
-		fmt.Printf("The type of areaIntf is: %T\n", u)
-	} else {
-		fmt.Println("areaIntf does not contain a variable of type Circle")
-	}
-	// testing with switch:
-	switch t := areaIntf.(type) {
-		case *Square:
-			fmt.Printf("Type Square %T with value %v\n", t, t)
-		case *Circle:
-			fmt.Printf("Type Circle %T with value %v\n", t, t)
-		/* 
-		case bool:
-   			fmt.Printf("Type boolean %t\n", t)
-		case int:
-   			fmt.Printf("Type int %d\n", t)
-		case *bool:
-   			fmt.Printf("Type pointer to boolean %t\n", *t)
-		case *int:
-   			fmt.Printf("Type pointer to int %d\n", *t)
-		*/
-		default:
-   			fmt.Printf("Unexpected type %T", t)
-	}
-}
-
-func (sq *Square) Area() float32 {
-	return sq.side * sq.side
-}
-
-func (ci *Circle) Area() float32 {
-	return ci.radius * ci.radius * math.Pi
-}
+package main
+
+import (
+	"fmt"
+	"math"
+)
+
+type Square struct {
+	side float32
+}
+
+type Circle struct {
+	radius float32
+}
+
+type Shaper interface {
+	Area() float32
+}
+
+func main() {
+	var areaIntf Shaper
+	sq1 := new(Square)
+	sq1.side = 5
+
+	areaIntf = sq1
+	// Is Square the type of areaIntf ?
+	if t, ok := areaIntf.(*Square); ok {
+		fmt.Printf("The type of areaIntf is: %T\n", t)
+	}
+	if u, ok := areaIntf.(*Circle); ok {
+		fmt.Printf("The type of areaIntf is: %T\n", u)
+	} else {
+		fmt.Println("areaIntf does not contain a variable of type Circle")
+	}
+	// testing with switch:
+	switch t := areaIntf.(type) {
+	case *Square:
+		fmt.Printf("Type Square %T with value %v\n", t, t)
+	case *Circle:
+		fmt.Printf("Type Circle %T with value %v\n", t, t)
+	/*
+				case bool:
+		   			fmt.Printf("Type boolean %t\n", t)
+				case int:
+		   			fmt.Printf("Type int %d\n", t)
+				case *bool:
+		   			fmt.Printf("Type pointer to boolean %t\n", *t)
+				case *int:
+		   			fmt.Printf("Type pointer to int %d\n", *t)
+	*/
+	default:
+		fmt.Printf("Unexpected type %T", t)
+	}
+}
+
+func (sq *Square) Area() float32 {
+	return sq.side * sq.side
+}
+
+func (ci *Circle) Area() float32 {
+	return ci.radius * ci.radius * math.Pi
+}

eBook/examples/chapter_12/cat.go

@@ -1,36 +1,35 @@
-package main
-
-import (
-	"os"
-	"io"
-	"fmt"
-	"bufio"
-	"flag"
-)
-
-func cat(r *bufio.Reader) {
-	for {
-		buf, err := r.ReadBytes('\n')
-		if err == io.EOF {
-			break
-		}
-		fmt.Fprintf(os.Stdout, "%s", buf)
-	}
-	return
-}
-
-func main() {
-	flag.Parse()
-	if flag.NArg() == 0 {
-		cat(bufio.NewReader(os.Stdin))
-	}
-	for i := 0; i < flag.NArg(); i++ {
-		f, err := os.Open(flag.Arg(i))
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "%s:error reading from %s: %s\n", os.Args[0], flag.Arg(i), err.Error())
-			continue
-		}
-		cat(bufio.NewReader(f))
-	}
-}
-
+package main
+
+import (
+	"bufio"
+	"flag"
+	"fmt"
+	"io"
+	"os"
+)
+
+func cat(r *bufio.Reader) {
+	for {
+		buf, err := r.ReadBytes('\n')
+		if err == io.EOF {
+			break
+		}
+		fmt.Fprintf(os.Stdout, "%s", buf)
+	}
+	return
+}
+
+func main() {
+	flag.Parse()
+	if flag.NArg() == 0 {
+		cat(bufio.NewReader(os.Stdin))
+	}
+	for i := 0; i < flag.NArg(); i++ {
+		f, err := os.Open(flag.Arg(i))
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "%s:error reading from %s: %s\n", os.Args[0], flag.Arg(i), err.Error())
+			continue
+		}
+		cat(bufio.NewReader(f))
+	}
+}

eBook/examples/chapter_12/cat2.go

@@ -1,41 +1,41 @@
-package main
-
-import (
-	"flag"
-	"fmt"
-	"os"
-)
-
-func cat(f *os.File) {
-	const NBUF = 512
-	var buf [NBUF]byte
-	for {
-		switch nr, err := f.Read(buf[:]); true {
-		case nr < 0:
-			fmt.Fprintf(os.Stderr, "cat: error reading: %s\n", err.Error())
-			os.Exit(1)
-		case nr == 0: // EOF
-			return
-		case nr > 0:
-			if nw, ew := os.Stdout.Write(buf[0:nr]); nw != nr {
-				fmt.Fprintf(os.Stderr, "cat: error writing: %s\n", ew.Error())
-			}
-		}
-	}
-}
-
-func main() {
-	flag.Parse() // Scans the arg list and sets up flags
-	if flag.NArg() == 0 {
-		cat(os.Stdin)
-	}
-	for i := 0; i < flag.NArg(); i++ {
-		f, err := os.Open(flag.Arg(i))
-		if f == nil {
-			fmt.Fprintf(os.Stderr, "cat: can't open %s: error %s\n", flag.Arg(i), err)
-			os.Exit(1)
-		}
-		cat(f)
-		f.Close()
-	}
-}
+package main
+
+import (
+	"flag"
+	"fmt"
+	"os"
+)
+
+func cat(f *os.File) {
+	const NBUF = 512
+	var buf [NBUF]byte
+	for {
+		switch nr, err := f.Read(buf[:]); true {
+		case nr < 0:
+			fmt.Fprintf(os.Stderr, "cat: error reading: %s\n", err.Error())
+			os.Exit(1)
+		case nr == 0: // EOF
+			return
+		case nr > 0:
+			if nw, ew := os.Stdout.Write(buf[0:nr]); nw != nr {
+				fmt.Fprintf(os.Stderr, "cat: error writing: %s\n", ew.Error())
+			}
+		}
+	}
+}
+
+func main() {
+	flag.Parse() // Scans the arg list and sets up flags
+	if flag.NArg() == 0 {
+		cat(os.Stdin)
+	}
+	for i := 0; i < flag.NArg(); i++ {
+		f, err := os.Open(flag.Arg(i))
+		if f == nil {
+			fmt.Fprintf(os.Stderr, "cat: can't open %s: error %s\n", flag.Arg(i), err)
+			os.Exit(1)
+		}
+		cat(f)
+		f.Close()
+	}
+}

eBook/examples/chapter_12/echo.go

@@ -1,29 +1,29 @@
-package main
-
-import (
-	"os"
-	"flag" // command line option parser
-)
-
-var NewLine = flag.Bool("n", false, "print newline") // echo -n flag, of type *bool
-
-const (
-	Space   = " "
-	Newline = "\n"
-)
-
-func main() {
-	flag.PrintDefaults()
-	flag.Parse() // Scans the arg list and sets up flags
-	var s string = ""
-	for i := 0; i < flag.NArg(); i++ {
-		if i > 0 {
-			s += " "
-			if *NewLine {  // -n is parsed, flag becomes true
-				s += Newline
-			}
-		}
-		s += flag.Arg(i)
-	}
-	os.Stdout.WriteString(s)
-}
+package main
+
+import (
+	"flag" // command line option parser
+	"os"
+)
+
+var NewLine = flag.Bool("n", false, "print newline") // echo -n flag, of type *bool
+
+const (
+	Space   = " "
+	Newline = "\n"
+)
+
+func main() {
+	flag.PrintDefaults()
+	flag.Parse() // Scans the arg list and sets up flags
+	var s string = ""
+	for i := 0; i < flag.NArg(); i++ {
+		if i > 0 {
+			s += " "
+			if *NewLine { // -n is parsed, flag becomes true
+				s += Newline
+			}
+		}
+		s += flag.Arg(i)
+	}
+	os.Stdout.WriteString(s)
+}

eBook/examples/chapter_12/filecopy.go

@@ -1,29 +1,29 @@
-// filecopy.go
-package main
-
-import (
-	"fmt"
-	"io"
-	"os"
-)
-
-func main() {
-	CopyFile("target.txt", "source.txt")
-	fmt.Println("Copy done!")
-}
-
-func CopyFile(dstName, srcName string) (written int64, err error) {
-	src, err := os.Open(srcName)
-	if err != nil {
-		return
-	}
-	defer src.Close()
-
-	dst, err := os.OpenFile(dstName, os.O_WRONLY|os.O_CREATE, 0644)
-	if err != nil {
-		return
-	}
-	defer dst.Close()
-
-	return io.Copy(dst, src)
-}
+// filecopy.go
+package main
+
+import (
+	"fmt"
+	"io"
+	"os"
+)
+
+func main() {
+	CopyFile("target.txt", "source.txt")
+	fmt.Println("Copy done!")
+}
+
+func CopyFile(dstName, srcName string) (written int64, err error) {
+	src, err := os.Open(srcName)
+	if err != nil {
+		return
+	}
+	defer src.Close()
+
+	dst, err := os.OpenFile(dstName, os.O_WRONLY|os.O_CREATE, 0644)
+	if err != nil {
+		return
+	}
+	defer dst.Close()
+
+	return io.Copy(dst, src)
+}

eBook/examples/chapter_12/fileinput.go

@@ -1,34 +1,34 @@
-package main
-
-import (
-	"bufio"
-	"fmt"
-	"io"
-	"os"
-)
-
-func main() {
-	// var inputFile *os.File
-	// var inputError, readerError os.Error
-	// var inputReader *bufio.Reader
-	// var inputString string
-
-	inputFile, inputError := os.Open("input.dat")
-	if inputError != nil {
-		fmt.Printf("An error occurred on opening the inputfile\n" + 
-		           "Does the file exist?\n" + 
-			       "Have you got acces to it?\n")
-		return // exit the function on error
-	}
-	defer inputFile.Close()
-
-	inputReader := bufio.NewReader(inputFile)
-
-	for {
-		inputString, readerError := inputReader.ReadString('\n')
-		if readerError == io.EOF {
-			return // error or EOF
-		}
-		fmt.Printf("The input was: %s", inputString)
-	}
-}
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"os"
+)
+
+func main() {
+	// var inputFile *os.File
+	// var inputError, readerError os.Error
+	// var inputReader *bufio.Reader
+	// var inputString string
+
+	inputFile, inputError := os.Open("input.dat")
+	if inputError != nil {
+		fmt.Printf("An error occurred on opening the inputfile\n" +
+			"Does the file exist?\n" +
+			"Have you got acces to it?\n")
+		return // exit the function on error
+	}
+	defer inputFile.Close()
+
+	inputReader := bufio.NewReader(inputFile)
+
+	for {
+		inputString, readerError := inputReader.ReadString('\n')
+		if readerError == io.EOF {
+			return // error or EOF
+		}
+		fmt.Printf("The input was: %s", inputString)
+	}
+}

eBook/examples/chapter_12/fileoutput.go

@@ -1,28 +1,28 @@
-package main
-
-import (
-	"os"
-	"bufio"
-	"fmt"
-)
-
-func main () {
-	// var outputWriter *bufio.Writer
-	// var outputFile *os.File
-	// var outputError os.Error
-	// var outputString string
-	outputFile, outputError := os.OpenFile("output.dat", os.O_WRONLY|os.O_CREATE, 0666)
-	if outputError != nil {
-		fmt.Printf("An error occurred with file opening or creation\n")
-		return  
-	}
-	defer outputFile.Close()
-
-	outputWriter := bufio.NewWriter(outputFile)
-	outputString := "hello world!\n"
-	
-	for i:=0; i<10; i++ {
-		outputWriter.WriteString(outputString)
-	}
-	outputWriter.Flush()
-}
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+)
+
+func main() {
+	// var outputWriter *bufio.Writer
+	// var outputFile *os.File
+	// var outputError os.Error
+	// var outputString string
+	outputFile, outputError := os.OpenFile("output.dat", os.O_WRONLY|os.O_CREATE, 0666)
+	if outputError != nil {
+		fmt.Printf("An error occurred with file opening or creation\n")
+		return
+	}
+	defer outputFile.Close()
+
+	outputWriter := bufio.NewWriter(outputFile)
+	outputString := "hello world!\n"
+
+	for i := 0; i < 10; i++ {
+		outputWriter.WriteString(outputString)
+	}
+	outputWriter.Flush()
+}

eBook/examples/chapter_12/filewrite.go

@@ -1,10 +1,10 @@
-package main
-
-import "os"
-
-func main() {
-	os.Stdout.WriteString("hello, world\n")
-	f, _ := os.OpenFile("test", os.O_CREATE|os.O_WRONLY, 0)
-	defer f.Close()
-	f.WriteString("hello, world in a file\n")
-}
+package main
+
+import "os"
+
+func main() {
+	os.Stdout.WriteString("hello, world\n")
+	f, _ := os.OpenFile("test", os.O_CREATE|os.O_WRONLY, 0)
+	defer f.Close()
+	f.WriteString("hello, world in a file\n")
+}

eBook/examples/chapter_12/gob1.go

@@ -1,41 +1,42 @@
-// gob1.go
-package main
-
-import (
-	"bytes"
-	"fmt"
-	"encoding/gob"
-	"log"
-)
-
-type P struct {
-	X, Y, Z int
-	Name    string
-}
-
-type Q struct {
-	X, Y *int32
-	Name string
-}
-
-func main() {
-	// Initialize the encoder and decoder.  Normally enc and dec would be      
-	// bound to network connections and the encoder and decoder would      
-	// run in different processes.      
-	var network bytes.Buffer   // Stand-in for a network connection      
-	enc := gob.NewEncoder(&network) // Will write to network.      
-	dec := gob.NewDecoder(&network)	// Will read from network.      
-	// Encode (send) the value.      
-	err := enc.Encode(P{3, 4, 5, "Pythagoras"})
-	if err != nil {
-		log.Fatal("encode error:", err)
-	}
-	// Decode (receive) the value.      
-	var q Q
-	err = dec.Decode(&q)
-	if err != nil {
-		log.Fatal("decode error:", err)
-	}
-	fmt.Printf("%q: {%d,%d}\n", q.Name, *q.X, *q.Y)
-}
-// Output:   "Pythagoras": {3,4}
+// gob1.go
+package main
+
+import (
+	"bytes"
+	"encoding/gob"
+	"fmt"
+	"log"
+)
+
+type P struct {
+	X, Y, Z int
+	Name    string
+}
+
+type Q struct {
+	X, Y *int32
+	Name string
+}
+
+func main() {
+	// Initialize the encoder and decoder.  Normally enc and dec would be
+	// bound to network connections and the encoder and decoder would
+	// run in different processes.
+	var network bytes.Buffer        // Stand-in for a network connection
+	enc := gob.NewEncoder(&network) // Will write to network.
+	dec := gob.NewDecoder(&network) // Will read from network.
+	// Encode (send) the value.
+	err := enc.Encode(P{3, 4, 5, "Pythagoras"})
+	if err != nil {
+		log.Fatal("encode error:", err)
+	}
+	// Decode (receive) the value.
+	var q Q
+	err = dec.Decode(&q)
+	if err != nil {
+		log.Fatal("decode error:", err)
+	}
+	fmt.Printf("%q: {%d,%d}\n", q.Name, *q.X, *q.Y)
+}
+
+// Output:   "Pythagoras": {3,4}

eBook/examples/chapter_12/gob2.go

@@ -1,39 +1,38 @@
-// gob2.go
-package main
-
-import (
-	"encoding/gob"
-	"log"
-	"os"
-)
-
-type Address struct {
-	Type             string
-	City             string
-	Country          string
-}
-
-type VCard struct {
-	FirstName	string
-	LastName	string
-	Addresses	[]*Address
-	Remark		string
-}
-
-var content	string
-
-func main() {
-	pa := &Address{"private", "Aartselaar","Belgium"}
-	wa := &Address{"work", "Boom", "Belgium"}
-	vc := VCard{"Jan", "Kersschot", []*Address{pa,wa}, "none"}
-	// fmt.Printf("%v: \n", vc) // {Jan Kersschot [0x126d2b80 0x126d2be0] none}: 
-	// using an encoder:
-	file, _ := os.OpenFile("vcard.gob", os.O_CREATE|os.O_WRONLY, 0666)
-	defer file.Close()
-	enc := gob.NewEncoder(file)
-	err := enc.Encode(vc)
-	if err != nil {
-		log.Println("Error in encoding gob")
-	}
-}
-
+// gob2.go
+package main
+
+import (
+	"encoding/gob"
+	"log"
+	"os"
+)
+
+type Address struct {
+	Type    string
+	City    string
+	Country string
+}
+
+type VCard struct {
+	FirstName string
+	LastName  string
+	Addresses []*Address
+	Remark    string
+}
+
+var content string
+
+func main() {
+	pa := &Address{"private", "Aartselaar", "Belgium"}
+	wa := &Address{"work", "Boom", "Belgium"}
+	vc := VCard{"Jan", "Kersschot", []*Address{pa, wa}, "none"}
+	// fmt.Printf("%v: \n", vc) // {Jan Kersschot [0x126d2b80 0x126d2be0] none}:
+	// using an encoder:
+	file, _ := os.OpenFile("vcard.gob", os.O_CREATE|os.O_WRONLY, 0666)
+	defer file.Close()
+	enc := gob.NewEncoder(file)
+	err := enc.Encode(vc)
+	if err != nil {
+		log.Println("Error in encoding gob")
+	}
+}

eBook/examples/chapter_12/gzipped.go

@@ -1,35 +1,35 @@
-// gzipped.go
-package main
-
-import (
-	"fmt"
-	"bufio"
-	"os"
-	"compress/gzip"
-)
-
-func main() {
-	fName := "MyFile.gz"
-	var r *bufio.Reader
-	fi, err := os.Open(fName)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "%v, Can't open %s: error: %s\n", os.Args[0], fName,
-			err)
-		os.Exit(1)
-	}
-	fz, err := gzip.NewReader(fi)
-	if err != nil {
-		r = bufio.NewReader(fi)
-	} else {
-		r = bufio.NewReader(fz)
-	}
-
-	for {
-		line, err := r.ReadString('\n')
-		if err != nil {
-			fmt.Println("Done reading file")
-			os.Exit(0)
-		}
-		fmt.Println(line)
-	}
-}
+// gzipped.go
+package main
+
+import (
+	"bufio"
+	"compress/gzip"
+	"fmt"
+	"os"
+)
+
+func main() {
+	fName := "MyFile.gz"
+	var r *bufio.Reader
+	fi, err := os.Open(fName)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "%v, Can't open %s: error: %s\n", os.Args[0], fName,
+			err)
+		os.Exit(1)
+	}
+	fz, err := gzip.NewReader(fi)
+	if err != nil {
+		r = bufio.NewReader(fi)
+	} else {
+		r = bufio.NewReader(fz)
+	}
+
+	for {
+		line, err := r.ReadString('\n')
+		if err != nil {
+			fmt.Println("Done reading file")
+			os.Exit(0)
+		}
+		fmt.Println(line)
+	}
+}

eBook/examples/chapter_12/hash_sha1.go

@@ -1,31 +1,32 @@
-// hash_sha1.go
-package main
-
-import (
-	"fmt"
-	"crypto/sha1"
-	"io"
-	"log"
-)
-
-func main() {
-	hasher := sha1.New()
-	io.WriteString(hasher, "test")
-	b := []byte{}
-	fmt.Printf("Result: %x\n", hasher.Sum(b))
-	fmt.Printf("Result: %d\n", hasher.Sum(b))
-	//
-	hasher.Reset()
-	data := []byte("We shall overcome!")
-	n, err := hasher.Write(data)
-	if n!=len(data) || err!=nil {
-		log.Printf("Hash write error: %v / %v", n, err)
-	}
-	checksum := hasher.Sum(b)
-	fmt.Printf("Result: %x\n", checksum)
-}
-/* Output: 
-Result: a94a8fe5ccb19ba61c4c0873d391e987982fbbd3
-Result: [169 74 143 229 204 177 155 166 28 76 8 115 211 145 233 135 152 47 187 211]
-Result: e2222bfc59850bbb00a722e764a555603bb59b2a
-*/
+// hash_sha1.go
+package main
+
+import (
+	"crypto/sha1"
+	"fmt"
+	"io"
+	"log"
+)
+
+func main() {
+	hasher := sha1.New()
+	io.WriteString(hasher, "test")
+	b := []byte{}
+	fmt.Printf("Result: %x\n", hasher.Sum(b))
+	fmt.Printf("Result: %d\n", hasher.Sum(b))
+	//
+	hasher.Reset()
+	data := []byte("We shall overcome!")
+	n, err := hasher.Write(data)
+	if n != len(data) || err != nil {
+		log.Printf("Hash write error: %v / %v", n, err)
+	}
+	checksum := hasher.Sum(b)
+	fmt.Printf("Result: %x\n", checksum)
+}
+
+/* Output:
+Result: a94a8fe5ccb19ba61c4c0873d391e987982fbbd3
+Result: [169 74 143 229 204 177 155 166 28 76 8 115 211 145 233 135 152 47 187 211]
+Result: e2222bfc59850bbb00a722e764a555603bb59b2a
+*/

eBook/examples/chapter_12/io_interfaces.go

@@ -1,18 +1,18 @@
-// interfaces being used in the GO-package fmt
-package main
-
-import (
-	"bufio"
-	"fmt"
-	"os"
-)
-
-func main() {
-	// unbuffered
-	fmt.Fprintf(os.Stdout, "%s\n", "hello world! - unbuffered")
-	// buffered: os.Stdout implements io.Writer
-	buf := bufio.NewWriter(os.Stdout)
-	// and now so does buf.
-	fmt.Fprintf(buf, "%s\n", "hello world! - buffered")
-	buf.Flush()
-}
+// interfaces being used in the GO-package fmt
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+)
+
+func main() {
+	// unbuffered
+	fmt.Fprintf(os.Stdout, "%s\n", "hello world! - unbuffered")
+	// buffered: os.Stdout implements io.Writer
+	buf := bufio.NewWriter(os.Stdout)
+	// and now so does buf.
+	fmt.Fprintf(buf, "%s\n", "hello world! - buffered")
+	buf.Flush()
+}

eBook/examples/chapter_12/json.go

@@ -1,40 +1,40 @@
-// json.go
-package main
-
-import (
-	"fmt"
-	"encoding/json"
-	"log"
-	"os"
-)
-
-type Address struct {
-	Type             string
-	City             string
-	Country          string
-}
-
-type VCard struct {
-	FirstName	string
-	LastName	string
-	Addresses	[]*Address
-	Remark		string
-}
-
-func main() {
-	pa := &Address{"private", "Aartselaar","Belgium"}
-	wa := &Address{"work", "Boom", "Belgium"}
-	vc := VCard{"Jan", "Kersschot", []*Address{pa,wa}, "none"}
-	// fmt.Printf("%v: \n", vc) // {Jan Kersschot [0x126d2b80 0x126d2be0] none}: 
-	// JSON format:
-	js, _ := json.Marshal(vc)
-	fmt.Printf("JSON format: %s", js)
-	// using an encoder:
-	file, _ := os.OpenFile("vcard.json", os.O_CREATE|os.O_WRONLY, 0)
-	defer file.Close()
-	enc := json.NewEncoder(file)
-	err := enc.Encode(vc)
-	if err != nil {
-		log.Println("Error in encoding json")
-	}
-}
+// json.go
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"log"
+	"os"
+)
+
+type Address struct {
+	Type    string
+	City    string
+	Country string
+}
+
+type VCard struct {
+	FirstName string
+	LastName  string
+	Addresses []*Address
+	Remark    string
+}
+
+func main() {
+	pa := &Address{"private", "Aartselaar", "Belgium"}
+	wa := &Address{"work", "Boom", "Belgium"}
+	vc := VCard{"Jan", "Kersschot", []*Address{pa, wa}, "none"}
+	// fmt.Printf("%v: \n", vc) // {Jan Kersschot [0x126d2b80 0x126d2be0] none}:
+	// JSON format:
+	js, _ := json.Marshal(vc)
+	fmt.Printf("JSON format: %s", js)
+	// using an encoder:
+	file, _ := os.OpenFile("vcard.json", os.O_CREATE|os.O_WRONLY, 0)
+	defer file.Close()
+	enc := json.NewEncoder(file)
+	err := enc.Encode(vc)
+	if err != nil {
+		log.Println("Error in encoding json")
+	}
+}

eBook/examples/chapter_12/json_xml_case.go

@@ -1,54 +1,55 @@
-// json_xml_case.go
-package main
-
-import (
-	"encoding/json"
-	"encoding/xml"
-	"fmt"
-	"log"
-	"strings"
-)
-
-type thing struct {
-	Field1 int
-	Field2 string
-}
-
-func main() {
-	x := `<x><field1>423</field1><field2>hello from xml</field2></x>`
-	j := `{"field1": 423, "field2": "hello from json"}`
-
-	tx := thing{}
-	if err := xml.Unmarshal(strings.NewReader(x), &tx); err != nil {
-		log.Fatalf("Error unmarshaling XML: %v", err)
-	}
-
-	tj := thing{}
-	if err := json.Unmarshal([]byte(j), &tj); err != nil {
-		log.Fatalf("Error unmarshaling JSON: %v", err)
-	}
-
-	fmt.Printf("From JSON: %#v\n", tj)
-	fmt.Printf("From XML: %#v\n", tx)
-
-}
-/* Output with
-type thing struct {
-	Field1 int
-	Field2 string
-}:
-
-From XML: main.thing{Field1:0, Field2:""}   // All matching is case sensitive! 
-From JSON: main.thing{Field1:423, Field2:"hello from json"}
-
-Output with
-type thing struct {
-	field1 int
-	field2 string
-}:
-
-2012/02/22 10:51:11 Error unmarshaling JSON: json: cannot unmarshal object
-field1" into unexported field field1 of type main.thing
-
-JSON uses reflection to unmarshal!
-*/
+// json_xml_case.go
+package main
+
+import (
+	"encoding/json"
+	"encoding/xml"
+	"fmt"
+	"log"
+	"strings"
+)
+
+type thing struct {
+	Field1 int
+	Field2 string
+}
+
+func main() {
+	x := `<x><field1>423</field1><field2>hello from xml</field2></x>`
+	j := `{"field1": 423, "field2": "hello from json"}`
+
+	tx := thing{}
+	if err := xml.Unmarshal(strings.NewReader(x), &tx); err != nil {
+		log.Fatalf("Error unmarshaling XML: %v", err)
+	}
+
+	tj := thing{}
+	if err := json.Unmarshal([]byte(j), &tj); err != nil {
+		log.Fatalf("Error unmarshaling JSON: %v", err)
+	}
+
+	fmt.Printf("From JSON: %#v\n", tj)
+	fmt.Printf("From XML: %#v\n", tx)
+
+}
+
+/* Output with
+type thing struct {
+	Field1 int
+	Field2 string
+}:
+
+From XML: main.thing{Field1:0, Field2:""}   // All matching is case sensitive!
+From JSON: main.thing{Field1:423, Field2:"hello from json"}
+
+Output with
+type thing struct {
+	field1 int
+	field2 string
+}:
+
+2012/02/22 10:51:11 Error unmarshaling JSON: json: cannot unmarshal object
+field1" into unexported field field1 of type main.thing
+
+JSON uses reflection to unmarshal!
+*/

eBook/examples/chapter_12/os_args.go

@@ -1,16 +1,16 @@
-// os_args.go
-package main
-
-import (
-	"fmt"
-	"os"
-	"strings"
-)
-
-func main() {
-	who := "Alice "
-	if len(os.Args) > 1 {
-		who += strings.Join(os.Args[1:], " ")
-	}
-	fmt.Println("Good Morning", who)
-}
+// os_args.go
+package main
+
+import (
+	"fmt"
+	"os"
+	"strings"
+)
+
+func main() {
+	who := "Alice "
+	if len(os.Args) > 1 {
+		who += strings.Join(os.Args[1:], " ")
+	}
+	fmt.Println("Good Morning", who)
+}

eBook/examples/chapter_12/read_file2.go

@@ -1,38 +1,39 @@
-// read_csvfile.go
-package main
-
-import (
-	"fmt"
-	"os"
-//	"io/ioutil"
-//	"strings"
-)
-
-func main() {
-	file, err := os.Open("products2.txt")
-	if err != nil {
-		panic(err)
-	}
-	defer file.Close()
-
-	var col1, col2, col3 []string
-	for {
-		var v1, v2, v3 string
-		_, err := fmt.Fscanln(file, &v1, &v2, &v3)
-		if err != nil {
-			break
-		}
-		col1 = append(col1, v1)
-		col2 = append(col2, v2)
-		col3 = append(col3, v3)
-	}
-
-	fmt.Println(col1)
-	fmt.Println(col2)
-	fmt.Println(col3)
-}
-/* Output:
-[ABC FUNC GO]
-[40 56 45]
-[150 280 356]
-*/
+// read_csvfile.go
+package main
+
+import (
+	"fmt"
+	"os"
+	//	"io/ioutil"
+	//	"strings"
+)
+
+func main() {
+	file, err := os.Open("products2.txt")
+	if err != nil {
+		panic(err)
+	}
+	defer file.Close()
+
+	var col1, col2, col3 []string
+	for {
+		var v1, v2, v3 string
+		_, err := fmt.Fscanln(file, &v1, &v2, &v3)
+		if err != nil {
+			break
+		}
+		col1 = append(col1, v1)
+		col2 = append(col2, v2)
+		col3 = append(col3, v3)
+	}
+
+	fmt.Println(col1)
+	fmt.Println(col2)
+	fmt.Println(col3)
+}
+
+/* Output:
+[ABC FUNC GO]
+[40 56 45]
+[150 280 356]
+*/

eBook/examples/chapter_12/read_files.go

@@ -1,30 +1,28 @@
-// read_files.go
-package main
-
-import (
-	"bufio"
-	"flag"
-	"fmt"
-	"io"
-	"os"
-)
-
-func main() {
-	fmt.Printf("Reading files...\n")
-	flag.Parse()
-
-	for i := 0; i < flag.NArg(); i++ {
-		fmt.Printf("[File: %v]\n", flag.Arg(i))
-		fin, err := os.Open(flag.Arg(i))
-		if err != nil {
-			fmt.Printf("The file %v does not exist!\n", flag.Arg(i))
-			break
-		}
-		r := bufio.NewReader(fin)
-		for line, _, err := r.ReadLine(); 
-		    err != io.EOF; 
-			line, _, err =	r.ReadLine() {
-				fmt.Printf("Lines: %v (error %v)\n", string(line), err)
-		}
-	}
-}
+// read_files.go
+package main
+
+import (
+	"bufio"
+	"flag"
+	"fmt"
+	"io"
+	"os"
+)
+
+func main() {
+	fmt.Printf("Reading files...\n")
+	flag.Parse()
+
+	for i := 0; i < flag.NArg(); i++ {
+		fmt.Printf("[File: %v]\n", flag.Arg(i))
+		fin, err := os.Open(flag.Arg(i))
+		if err != nil {
+			fmt.Printf("The file %v does not exist!\n", flag.Arg(i))
+			break
+		}
+		r := bufio.NewReader(fin)
+		for line, _, err := r.ReadLine(); err != io.EOF; line, _, err = r.ReadLine() {
+			fmt.Printf("Lines: %v (error %v)\n", string(line), err)
+		}
+	}
+}

eBook/examples/chapter_12/read_write_file1.go

@@ -1,21 +1,21 @@
-// read_write_file.go
-package main
-
-import (
-	"fmt"
-	"io/ioutil"
-)
-
-func main() {
-	inputFile := "products.txt"
-	outputFile := "products_copy.txt"
-	buf, err := ioutil.ReadFile(inputFile)
-	if err != nil {
-		panic(err.Error())
-	}
-	fmt.Printf("%s\n", string(buf))
-	err = ioutil.WriteFile(outputFile, buf, 0644) // oct, not hex
-	if err != nil {
-		panic(err.Error())
-	}
-}
+// read_write_file.go
+package main
+
+import (
+	"fmt"
+	"io/ioutil"
+)
+
+func main() {
+	inputFile := "products.txt"
+	outputFile := "products_copy.txt"
+	buf, err := ioutil.ReadFile(inputFile)
+	if err != nil {
+		panic(err.Error())
+	}
+	fmt.Printf("%s\n", string(buf))
+	err = ioutil.WriteFile(outputFile, buf, 0644) // oct, not hex
+	if err != nil {
+		panic(err.Error())
+	}
+}

eBook/examples/chapter_12/readinput1.go

@@ -1,24 +1,24 @@
-// read input from the console:
-package main
-
-import (
-	"fmt"
-)
-
-var (
-	firstName, lastName, s string
-	i int
-	f float32
-	input = "56.12 / 5212 / Go"
-	format = "%f / %d / %s"
-)
-
-func main() {
-	fmt.Println("Please enter your full name: ")
-	fmt.Scanln(&firstName, &lastName)
-	// fmt.Scanf("%s %s", &firstName, &lastName)
-	fmt.Printf("Hi %s %s!\n", firstName, lastName) // Hi Chris Naegels
-	
-	fmt.Sscanf(input, format, &f, &i, &s)
-	fmt.Println("From the string we read: ", f, i, s) // From the string we read:  56.12 5212 Go
-}
+// read input from the console:
+package main
+
+import (
+	"fmt"
+)
+
+var (
+	firstName, lastName, s string
+	i                      int
+	f                      float32
+	input                  = "56.12 / 5212 / Go"
+	format                 = "%f / %d / %s"
+)
+
+func main() {
+	fmt.Println("Please enter your full name: ")
+	fmt.Scanln(&firstName, &lastName)
+	// fmt.Scanf("%s %s", &firstName, &lastName)
+	fmt.Printf("Hi %s %s!\n", firstName, lastName) // Hi Chris Naegels
+
+	fmt.Sscanf(input, format, &f, &i, &s)
+	fmt.Println("From the string we read: ", f, i, s) // From the string we read:  56.12 5212 Go
+}

eBook/examples/chapter_12/readinput2.go

@@ -1,22 +1,22 @@
-// read input from the console:
-package main
-
-import (
-	"fmt"
-	"bufio"
-	"os"
-)
-
-var inputReader *bufio.Reader
-	var input string
-	var err error
-
-func main() {
-	inputReader = bufio.NewReader(os.Stdin)  // reader for input
-	fmt.Println("Please enter some input: ")
-	input, err = inputReader.ReadString('\n')
-
-	if err == nil {
-		fmt.Printf("The input was: %s\n", input)
-	}
-}
+// read input from the console:
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+)
+
+var inputReader *bufio.Reader
+var input string
+var err error
+
+func main() {
+	inputReader = bufio.NewReader(os.Stdin) // reader for input
+	fmt.Println("Please enter some input: ")
+	input, err = inputReader.ReadString('\n')
+
+	if err == nil {
+		fmt.Printf("The input was: %s\n", input)
+	}
+}

eBook/examples/chapter_12/switch_input.go

@@ -1,41 +1,51 @@
-package main
-
-import (
-	"fmt"
-	"os"
-	"bufio"
-)
-
-func main() {
-		inputReader := bufio.NewReader(os.Stdin)
-		fmt.Println("Please enter your name:")
-		input, err := inputReader.ReadString('\n')
-
-		if err != nil {
-			fmt.Println("There were errors reading, exiting program.")
-			return
-		}
-
-		fmt.Printf("Your name is %s", input)
-	 // For Unix: test with delimiter "\n", for Windows: test with "\r\n"
-		switch input {
-			case "Philip\r\n":	fmt.Println("Welcome Philip!")
-			case "Chris\r\n":	fmt.Println("Welcome Chris!")
-			case "Ivo\r\n":	    fmt.Println("Welcome Ivo!")
-			default: fmt.Printf("You are not welcome here! Goodbye!")
-		}
-
-	 // version 2:
-	    switch input {
-		    case "Philip\r\n":	fallthrough
-		    case "Ivo\r\n":	    fallthrough
-		    case "Chris\r\n":	fmt.Printf("Welcome %s\n", input)
-		    default: fmt.Printf("You are not welcome here! Goodbye!\n")
-	    }
-	
-	// version 3:
-	    switch input {
-	    	case "Philip\r\n", "Ivo\r\n":	fmt.Printf("Welcome %s\n", input)
-	    	default: fmt.Printf("You are not welcome here! Goodbye!\n")
-	    }
-}
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+)
+
+func main() {
+	inputReader := bufio.NewReader(os.Stdin)
+	fmt.Println("Please enter your name:")
+	input, err := inputReader.ReadString('\n')
+
+	if err != nil {
+		fmt.Println("There were errors reading, exiting program.")
+		return
+	}
+
+	fmt.Printf("Your name is %s", input)
+	// For Unix: test with delimiter "\n", for Windows: test with "\r\n"
+	switch input {
+	case "Philip\r\n":
+		fmt.Println("Welcome Philip!")
+	case "Chris\r\n":
+		fmt.Println("Welcome Chris!")
+	case "Ivo\r\n":
+		fmt.Println("Welcome Ivo!")
+	default:
+		fmt.Printf("You are not welcome here! Goodbye!")
+	}
+
+	// version 2:
+	switch input {
+	case "Philip\r\n":
+		fallthrough
+	case "Ivo\r\n":
+		fallthrough
+	case "Chris\r\n":
+		fmt.Printf("Welcome %s\n", input)
+	default:
+		fmt.Printf("You are not welcome here! Goodbye!\n")
+	}
+
+	// version 3:
+	switch input {
+	case "Philip\r\n", "Ivo\r\n":
+		fmt.Printf("Welcome %s\n", input)
+	default:
+		fmt.Printf("You are not welcome here! Goodbye!\n")
+	}
+}

eBook/examples/chapter_12/xml.go

@@ -1,49 +1,50 @@
-// xml.go
-package main
-
-import (
-	"fmt"
-	"strings"
-	"encoding/xml"
-)
-
-var t, token	xml.Token
-var	err			error
-
-func main() {
-	input := "<Person><FirstName>Laura</FirstName><LastName>Lynn</LastName></Person>"
-	inputReader := strings.NewReader(input)
-	p := xml.NewDecoder(inputReader)
-	
-	for t, err = p.Token(); err == nil; t, err = p.Token() {
-		switch token := t.(type) {
-			case xml.StartElement:
-				name := token.Name.Local
-				fmt.Printf("Token name: %s\n", name)
-				for _, attr := range token.Attr {
-					attrName := attr.Name.Local
-					attrValue := attr.Value
-					fmt.Printf("An attribute is: %s %s\n", attrName, attrValue)
-					// ...
-				}
-			case xml.EndElement:
-				fmt.Println("End of token")
-			case xml.CharData:
-				content := string([]byte(token))
-				fmt.Printf("This is the content: %v\n", content )
-				// ...
-			default:
-				// ...
-		}
-	}
-}
-/* Output:
-Token name: Person
-Token name: FirstName
-This is the content: Laura
-End of token
-Token name: LastName
-This is the content: Lynn
-End of token
-End of token
-*/
+// xml.go
+package main
+
+import (
+	"encoding/xml"
+	"fmt"
+	"strings"
+)
+
+var t, token xml.Token
+var err error
+
+func main() {
+	input := "<Person><FirstName>Laura</FirstName><LastName>Lynn</LastName></Person>"
+	inputReader := strings.NewReader(input)
+	p := xml.NewDecoder(inputReader)
+
+	for t, err = p.Token(); err == nil; t, err = p.Token() {
+		switch token := t.(type) {
+		case xml.StartElement:
+			name := token.Name.Local
+			fmt.Printf("Token name: %s\n", name)
+			for _, attr := range token.Attr {
+				attrName := attr.Name.Local
+				attrValue := attr.Value
+				fmt.Printf("An attribute is: %s %s\n", attrName, attrValue)
+				// ...
+			}
+		case xml.EndElement:
+			fmt.Println("End of token")
+		case xml.CharData:
+			content := string([]byte(token))
+			fmt.Printf("This is the content: %v\n", content)
+			// ...
+		default:
+			// ...
+		}
+	}
+}
+
+/* Output:
+Token name: Person
+Token name: FirstName
+This is the content: Laura
+End of token
+Token name: LastName
+This is the content: Lynn
+End of token
+End of token
+*/

eBook/examples/chapter_13/errors.go

@@ -1,14 +1,15 @@
-// errors.go
-package main
-
-import (
-	"errors"
-	"fmt"
-)
-
-var errNotFound error = errors.New("Not found error")
-
-func main() {
-	fmt.Printf("error: %v", errNotFound)
-}
-// error: Not found error
+// errors.go
+package main
+
+import (
+	"errors"
+	"fmt"
+)
+
+var errNotFound error = errors.New("Not found error")
+
+func main() {
+	fmt.Printf("error: %v", errNotFound)
+}
+
+// error: Not found error

eBook/examples/chapter_13/even/even/even.go

@@ -1,10 +1,10 @@
-// even.go
-package even
-
-func Even(i int) bool {		// Exported function
-	return i%2 == 0
-}
-
-func Odd(i int) bool {		// Exported function
-	return i%2 != 0
-}
+// even.go
+package even
+
+func Even(i int) bool { // Exported function
+	return i%2 == 0
+}
+
+func Odd(i int) bool { // Exported function
+	return i%2 != 0
+}

eBook/examples/chapter_13/even/even/oddeven_test.go

@@ -1,27 +1,27 @@
-// oddeven_test.go
-package even
-
-import "testing"
-	
-func TestEven(t *testing.T) {
-	if !Even(10) {
-		t.Log(" 10 must be even!")
-		t.Fail()
-	}
-	if Even(7) {
-		t.Log(" 7 is not even!")
-		t.Fail()
-	}
-
-}
-
-func TestOdd(t *testing.T) {
-	if !Odd(11) {
-		t.Log(" 11 must be odd!")
-		t.Fail()
-	}
-	if Odd(10) {
-		t.Log(" 10 is not odd!")
-		t.Fail()
-	}
-}
+// oddeven_test.go
+package even
+
+import "testing"
+
+func TestEven(t *testing.T) {
+	if !Even(10) {
+		t.Log(" 10 must be even!")
+		t.Fail()
+	}
+	if Even(7) {
+		t.Log(" 7 is not even!")
+		t.Fail()
+	}
+
+}
+
+func TestOdd(t *testing.T) {
+	if !Odd(11) {
+		t.Log(" 11 must be odd!")
+		t.Fail()
+	}
+	if Odd(10) {
+		t.Log(" 10 is not odd!")
+		t.Fail()
+	}
+}

eBook/examples/chapter_13/even/even_main/even_main.go

@@ -1,13 +1,13 @@
-// test_oddeven.go
-package main
-
-import (
-	"fmt"
-	"even/even"
-)
-
-func main() {
-	for i:=0; i<=100; i++ {
-		fmt.Printf("Is the integer %d even? %v\n", i, even.Even(i)) 
-	}
-}
+// test_oddeven.go
+package main
+
+import (
+	"even/even"
+	"fmt"
+)
+
+func main() {
+	for i := 0; i <= 100; i++ {
+		fmt.Printf("Is the integer %d even? %v\n", i, even.Even(i))
+	}
+}

eBook/examples/chapter_13/exec.go

@@ -1,61 +1,61 @@
-// exec.go
-package main
-import (
-	"fmt"
-    "os/exec" 
-	"os"
-)
-
-func main() {
-// 1) os.StartProcess //
-/*********************/
-/* Linux: */
-	env := os.Environ()
-	procAttr := &os.ProcAttr{
-   			Env: env,
-   			Files: []*os.File{
-   				os.Stdin,
-   				os.Stdout,
-   				os.Stderr,
-   			},
-   		}
-	// 1st example: list files 
-	pid, err := os.StartProcess("/bin/ls", []string{"ls", "-l"}, procAttr)  
-	if err != nil {
-			fmt.Printf("Error %v starting process!", err)  // 
-			os.Exit(1)
-	}
-	fmt.Printf("The process id is %v", pid) 
-	// 2nd example: show all processes
-	pid, err = os.StartProcess("/bin/ps", []string{"-e", "-opid,ppid,comm"}, procAttr)  
-	if err != nil {
-			fmt.Printf("Error %v starting process!", err)  // 
-			os.Exit(1)
-	}
-	fmt.Printf("The process id is %v", pid) 
-/* Output 1st:
-The process id is &{2054 0}total 2056
--rwxr-xr-x 1 ivo ivo 1157555 2011-07-04 16:48 Mieken_exec
--rw-r--r-- 1 ivo ivo    2124 2011-07-04 16:48 Mieken_exec.go
--rw-r--r-- 1 ivo ivo   18528 2011-07-04 16:48 Mieken_exec_go_.6
--rwxr-xr-x 1 ivo ivo  913920 2011-06-03 16:13 panic.exe
--rw-r--r-- 1 ivo ivo     180 2011-04-11 20:39 panic.go
-*/
-	
-// 2) exec.Run //
-/***************/
-// Linux:  OK, but not for ls ?
-// cmd := exec.Command("ls", "-l")  // no error, but doesn't show anything ?
-// cmd := exec.Command("ls")  		// no error, but doesn't show anything ?
-	cmd := exec.Command("gedit")  // this opens a gedit-window
-	err = cmd.Run()
-	if err != nil {
-		fmt.Printf("Error %v executing command!", err) 
-		os.Exit(1)
-	}
-	fmt.Printf("The command is %v", cmd)
-// The command is &{/bin/ls [ls -l] []  <nil> <nil> <nil> 0xf840000210 <nil> true [0xf84000ea50 0xf84000e9f0 0xf84000e9c0] [0xf84000ea50 0xf84000e9f0 0xf84000e9c0] [] [] 0xf8400128c0}
-}
-// in Windows: uitvoering: Error fork/exec /bin/ls: The system cannot find the path specified. starting process!
-	
-
+// exec.go
+package main
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+)
+
+func main() {
+	// 1) os.StartProcess //
+	/*********************/
+	/* Linux: */
+	env := os.Environ()
+	procAttr := &os.ProcAttr{
+		Env: env,
+		Files: []*os.File{
+			os.Stdin,
+			os.Stdout,
+			os.Stderr,
+		},
+	}
+	// 1st example: list files
+	pid, err := os.StartProcess("/bin/ls", []string{"ls", "-l"}, procAttr)
+	if err != nil {
+		fmt.Printf("Error %v starting process!", err) //
+		os.Exit(1)
+	}
+	fmt.Printf("The process id is %v", pid)
+	// 2nd example: show all processes
+	pid, err = os.StartProcess("/bin/ps", []string{"-e", "-opid,ppid,comm"}, procAttr)
+	if err != nil {
+		fmt.Printf("Error %v starting process!", err) //
+		os.Exit(1)
+	}
+	fmt.Printf("The process id is %v", pid)
+	/* Output 1st:
+	   The process id is &{2054 0}total 2056
+	   -rwxr-xr-x 1 ivo ivo 1157555 2011-07-04 16:48 Mieken_exec
+	   -rw-r--r-- 1 ivo ivo    2124 2011-07-04 16:48 Mieken_exec.go
+	   -rw-r--r-- 1 ivo ivo   18528 2011-07-04 16:48 Mieken_exec_go_.6
+	   -rwxr-xr-x 1 ivo ivo  913920 2011-06-03 16:13 panic.exe
+	   -rw-r--r-- 1 ivo ivo     180 2011-04-11 20:39 panic.go
+	*/
+
+	// 2) exec.Run //
+	/***************/
+	// Linux:  OK, but not for ls ?
+	// cmd := exec.Command("ls", "-l")  // no error, but doesn't show anything ?
+	// cmd := exec.Command("ls")  		// no error, but doesn't show anything ?
+	cmd := exec.Command("gedit") // this opens a gedit-window
+	err = cmd.Run()
+	if err != nil {
+		fmt.Printf("Error %v executing command!", err)
+		os.Exit(1)
+	}
+	fmt.Printf("The command is %v", cmd)
+	// The command is &{/bin/ls [ls -l] []  <nil> <nil> <nil> 0xf840000210 <nil> true [0xf84000ea50 0xf84000e9f0 0xf84000e9c0] [0xf84000ea50 0xf84000e9f0 0xf84000e9c0] [] [] 0xf8400128c0}
+}
+
+// in Windows: uitvoering: Error fork/exec /bin/ls: The system cannot find the path specified. starting process!

eBook/examples/chapter_13/panic.go

@@ -1,9 +1,9 @@
-package main
-
-import "fmt"
-
-func main() {
-	fmt.Println("Starting the program")
-	panic("A severe error occurred: stopping the program!")
-	fmt.Println("Ending the program")
-}
+package main
+
+import "fmt"
+
+func main() {
+	fmt.Println("Starting the program")
+	panic("A severe error occurred: stopping the program!")
+	fmt.Println("Ending the program")
+}

eBook/examples/chapter_13/panic_package.go

@@ -1,39 +1,40 @@
-// panic_package.go
-package main
-
-import (
-	"fmt"
-	"./parse/parse"
-)
-
-func main() {
-        var examples = []string{
-                "1 2 3 4 5",
-                "100 50 25 12.5 6.25",
-                "2 + 2 = 4",
-                "1st class",
-                "",
-        }
-
-        for _, ex := range examples {
-                fmt.Printf("Parsing %q:\n  ", ex)
-                nums, err := parse.Parse(ex)
-                if err != nil {
-                        fmt.Println(err) // here String() method from ParseError is used
-                        continue
-                }
-                fmt.Println(nums)
-        }
-}
-/* Output:
-Parsing "1 2 3 4 5":
-  [1 2 3 4 5]
-Parsing "100 50 25 12.5 6.25":
-  pkg parse: error parsing "12.5" as int
-Parsing "2 + 2 = 4":
-  pkg parse: error parsing "+" as int
-Parsing "1st class":
-  pkg parse: error parsing "1st" as int
-Parsing "":
-  pkg: no words to parse
-*/
+// panic_package.go
+package main
+
+import (
+	"./parse/parse"
+	"fmt"
+)
+
+func main() {
+	var examples = []string{
+		"1 2 3 4 5",
+		"100 50 25 12.5 6.25",
+		"2 + 2 = 4",
+		"1st class",
+		"",
+	}
+
+	for _, ex := range examples {
+		fmt.Printf("Parsing %q:\n  ", ex)
+		nums, err := parse.Parse(ex)
+		if err != nil {
+			fmt.Println(err) // here String() method from ParseError is used
+			continue
+		}
+		fmt.Println(nums)
+	}
+}
+
+/* Output:
+Parsing "1 2 3 4 5":
+  [1 2 3 4 5]
+Parsing "100 50 25 12.5 6.25":
+  pkg parse: error parsing "12.5" as int
+Parsing "2 + 2 = 4":
+  pkg parse: error parsing "+" as int
+Parsing "1st class":
+  pkg parse: error parsing "1st" as int
+Parsing "":
+  pkg: no words to parse
+*/

eBook/examples/chapter_13/panic_recover.go

@@ -1,32 +1,32 @@
-// panic_recover.go
-package main
-
-import (
-	"fmt"
-)
-
-func badCall() {
-	panic("bad end")
-}
-
-func test() {
-	defer func() {
-		if e := recover(); e != nil {
-			fmt.Printf("Panicing %s\r\n", e)
-		}
-	}()
-	badCall()
-	fmt.Printf("After bad call\r\n") // <-- wordt niet bereikt
-}
-
-func main() {
-	fmt.Printf("Calling test\r\n")
-	test()
-	fmt.Printf("Test completed\r\n")
-}
-
-/* Output:
-Calling test
-Panicing bad end
-Test completed
-*/
+// panic_recover.go
+package main
+
+import (
+	"fmt"
+)
+
+func badCall() {
+	panic("bad end")
+}
+
+func test() {
+	defer func() {
+		if e := recover(); e != nil {
+			fmt.Printf("Panicing %s\r\n", e)
+		}
+	}()
+	badCall()
+	fmt.Printf("After bad call\r\n") // <-- wordt niet bereikt
+}
+
+func main() {
+	fmt.Printf("Calling test\r\n")
+	test()
+	fmt.Printf("Test completed\r\n")
+}
+
+/* Output:
+Calling test
+Panicing bad end
+Test completed
+*/

eBook/examples/chapter_13/parse/parse.go

@@ -1,51 +1,51 @@
-// parse.go
-package parse
-
-import (
-	"fmt"
-	"strings"
-	"strconv"
-)
-
-// A ParseError indicates an error in converting a word into an integer.
-type ParseError struct {
-        Index int      // The index into the space-separated list of words.
-        Word  string   // The word that generated the parse error.
-        Err error // The raw error that precipitated this error, if any.
-}
-
-// String returns a human-readable error message.
-func (e *ParseError) String() string {
-        return fmt.Sprintf("pkg parse: error parsing %q as int", e.Word)
-}
-
-// Parse parses the space-separated words in in put as integers.
-func Parse(input string) (numbers []int, err error) {
-        defer func() {
-                if r := recover(); r != nil {
-                        var ok bool
-                        err, ok = r.(error)
-                        if !ok {
-                                err = fmt.Errorf("pkg: %v", r)
-                        }
-                }
-        }()
-
-        fields := strings.Fields(input)
-        numbers = fields2numbers(fields)
-        return
-}
-
-func fields2numbers(fields []string) (numbers []int) {
-        if len(fields) == 0 {
-                panic("no words to parse")
-        }
-        for idx, field := range fields {
-                num, err := strconv.Atoi(field)
-                if err != nil {
-                        panic(&ParseError{idx, field, err})
-                }
-                numbers = append(numbers, num)
-        }
-        return
-}
+// parse.go
+package parse
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// A ParseError indicates an error in converting a word into an integer.
+type ParseError struct {
+	Index int    // The index into the space-separated list of words.
+	Word  string // The word that generated the parse error.
+	Err   error  // The raw error that precipitated this error, if any.
+}
+
+// String returns a human-readable error message.
+func (e *ParseError) String() string {
+	return fmt.Sprintf("pkg parse: error parsing %q as int", e.Word)
+}
+
+// Parse parses the space-separated words in in put as integers.
+func Parse(input string) (numbers []int, err error) {
+	defer func() {
+		if r := recover(); r != nil {
+			var ok bool
+			err, ok = r.(error)
+			if !ok {
+				err = fmt.Errorf("pkg: %v", r)
+			}
+		}
+	}()
+
+	fields := strings.Fields(input)
+	numbers = fields2numbers(fields)
+	return
+}
+
+func fields2numbers(fields []string) (numbers []int) {
+	if len(fields) == 0 {
+		panic("no words to parse")
+	}
+	for idx, field := range fields {
+		num, err := strconv.Atoi(field)
+		if err != nil {
+			panic(&ParseError{idx, field, err})
+		}
+		numbers = append(numbers, num)
+	}
+	return
+}

eBook/examples/chapter_14/benchmark_channels.go

@@ -1,35 +1,35 @@
-package main
-
-import (
-	"fmt"
-	"testing"
-)
-
-func main() {
-	fmt.Println(" sync", testing.Benchmark(BenchmarkChannelSync).String())
-	fmt.Println("buffered",	testing.Benchmark(BenchmarkChannelBuffered).String())
-}
-
-func BenchmarkChannelSync(b *testing.B) {
-	ch := make(chan int)
-	go func() {
-		for i := 0; i < b.N; i++ {
-			ch <- i
-		}
-		close(ch)
-	}()
-	for _ = range ch {
-	}
-}
-
-func BenchmarkChannelBuffered(b *testing.B) {
-	ch := make(chan int, 128)
-	go func() {
-		for i := 0; i < b.N; i++ {
-			ch <- i
-		}
-		close(ch)
-	}()
-	for _ = range ch {
-	}
-}
+package main
+
+import (
+	"fmt"
+	"testing"
+)
+
+func main() {
+	fmt.Println(" sync", testing.Benchmark(BenchmarkChannelSync).String())
+	fmt.Println("buffered", testing.Benchmark(BenchmarkChannelBuffered).String())
+}
+
+func BenchmarkChannelSync(b *testing.B) {
+	ch := make(chan int)
+	go func() {
+		for i := 0; i < b.N; i++ {
+			ch <- i
+		}
+		close(ch)
+	}()
+	for range ch {
+	}
+}
+
+func BenchmarkChannelBuffered(b *testing.B) {
+	ch := make(chan int, 128)
+	go func() {
+		for i := 0; i < b.N; i++ {
+			ch <- i
+		}
+		close(ch)
+	}()
+	for range ch {
+	}
+}

eBook/examples/chapter_14/chaining.go

@@ -7,7 +7,7 @@ import (
 
 var ngoroutine = flag.Int("n", 100000, "how many goroutines")
 
-func f(left, right chan int) { left <- 1+<-right }
+func f(left, right chan int) { left <- 1 + <-right }
 
 func main() {
 	flag.Parse()
@@ -17,7 +17,7 @@ func main() {
 		left, right = right, make(chan int)
 		go f(left, right)
 	}
-	right <- 0      // bang!
-	x := <-leftmost // wait for completion
-	fmt.Println(x)  // 100000, ongeveer 1,5 s
+	right <- 0      // bang!
+	x := <-leftmost // wait for completion
+	fmt.Println(x)  // 100000, ongeveer 1,5 s
 }

eBook/examples/chapter_14/channel_block.go

@@ -1,16 +1,15 @@
-package main
-
-import "fmt"
-
-func main() {
-	ch1 := make(chan int)
-	go pump(ch1)       // pump hangs
-	fmt.Println(<-ch1) // prints only 0
-}
-
-func pump(ch chan int) {
-	for i := 0; ; i++ {
-		ch <- i
-	}
-}
-
+package main
+
+import "fmt"
+
+func main() {
+	ch1 := make(chan int)
+	go pump(ch1)       // pump hangs
+	fmt.Println(<-ch1) // prints only 0
+}
+
+func pump(ch chan int) {
+	for i := 0; ; i++ {
+		ch <- i
+	}
+}

eBook/examples/chapter_14/channel_block2.go

@@ -1,25 +1,25 @@
-package main
-
-import (
-	"fmt"
-	"time"
-)
-
-func main() {
-	ch1 := make(chan int)
-	go pump(ch1)
-	go suck(ch1) // tons of numbers appear 
-	time.Sleep(1e9)
-}
-
-func pump(ch chan int) {
-	for i := 0; ; i++ {
-		ch <- i
-	}
-}
-
-func suck(ch chan int) {
-	for {
-		fmt.Println(<-ch)
-	}
-}
+package main
+
+import (
+	"fmt"
+	"time"
+)
+
+func main() {
+	ch1 := make(chan int)
+	go pump(ch1)
+	go suck(ch1) // tons of numbers appear
+	time.Sleep(1e9)
+}
+
+func pump(ch chan int) {
+	for i := 0; ; i++ {
+		ch <- i
+	}
+}
+
+func suck(ch chan int) {
+	for {
+		fmt.Println(<-ch)
+	}
+}

eBook/examples/chapter_14/channel_idiom2.go

@@ -1,29 +1,29 @@
-package main
-
-import (
-	"fmt"
-	"time"
-)
-
-func main() {
-	suck(pump())
-	time.Sleep(1e9)
-}
-
-func pump() chan int {
-	ch := make(chan int)
-	go func() {
-		for i := 0; ; i++ {
-			ch <- i
-		}
-	}()
-	return ch
-}
-
-func suck(ch chan int) {
-	go func() {
-		for v := range ch {
-			fmt.Println(v)
-		}
-	}()
-}
+package main
+
+import (
+	"fmt"
+	"time"
+)
+
+func main() {
+	suck(pump())
+	time.Sleep(1e9)
+}
+
+func pump() chan int {
+	ch := make(chan int)
+	go func() {
+		for i := 0; ; i++ {
+			ch <- i
+		}
+	}()
+	return ch
+}
+
+func suck(ch chan int) {
+	go func() {
+		for v := range ch {
+			fmt.Println(v)
+		}
+	}()
+}

eBook/examples/chapter_14/conc_access.go

@@ -1,54 +1,55 @@
-// conc_access.go
-package main
-
-import (
-	"fmt"
-	"strconv"
-)
-
-type Person struct {
-	Name   string
-	salary float64
-	chF    chan func()
-}
-
-func NewPerson(name string, salary float64) *Person {
-	p := &Person{name, salary, make(chan func())}
-	go p.backend()
-	return p
-}
-
-func (p *Person) backend() {
-	for f := range p.chF {
-		f()
-	}
-}
-
-// Set salary.
-func (p *Person) SetSalary(sal float64) {
-	p.chF <- func() { p.salary = sal }
-}
-
-// Retrieve salary.
-func (p *Person) Salary() float64 {
-	fChan := make(chan float64)
-	p.chF <- func() { fChan <- p.salary }
-	return <-fChan
-}
-
-func (p *Person) String() string {
-	return "Person - name is: " + p.Name + " - salary is: " + strconv.FormatFloat(p.Salary(), 'f', 2, 64)
-}
-
-func main() {
-	bs := NewPerson("Smith Bill", 2500.5)
-	fmt.Println(bs)
-	bs.SetSalary(4000.25)
-	fmt.Println("Salary changed:")
-	fmt.Println(bs)
-}
-/* Output:
-Person - name is: Smith Bill - salary is: 2500.50
-Salary changed:
-Person - name is: Smith Bill - salary is: 4000.25
-*/
+// conc_access.go
+package main
+
+import (
+	"fmt"
+	"strconv"
+)
+
+type Person struct {
+	Name   string
+	salary float64
+	chF    chan func()
+}
+
+func NewPerson(name string, salary float64) *Person {
+	p := &Person{name, salary, make(chan func())}
+	go p.backend()
+	return p
+}
+
+func (p *Person) backend() {
+	for f := range p.chF {
+		f()
+	}
+}
+
+// Set salary.
+func (p *Person) SetSalary(sal float64) {
+	p.chF <- func() { p.salary = sal }
+}
+
+// Retrieve salary.
+func (p *Person) Salary() float64 {
+	fChan := make(chan float64)
+	p.chF <- func() { fChan <- p.salary }
+	return <-fChan
+}
+
+func (p *Person) String() string {
+	return "Person - name is: " + p.Name + " - salary is: " + strconv.FormatFloat(p.Salary(), 'f', 2, 64)
+}
+
+func main() {
+	bs := NewPerson("Smith Bill", 2500.5)
+	fmt.Println(bs)
+	bs.SetSalary(4000.25)
+	fmt.Println("Salary changed:")
+	fmt.Println(bs)
+}
+
+/* Output:
+Person - name is: Smith Bill - salary is: 2500.50
+Salary changed:
+Person - name is: Smith Bill - salary is: 4000.25
+*/

eBook/examples/chapter_14/general_lazy_evalution1.go

@@ -1,57 +1,58 @@
-package main
-
-import (
-	"fmt"
-)
-
-type Any interface{}
-type EvalFunc func(Any) (Any, Any)
-
-func main() {
-	evenFunc := func(state Any) (Any, Any) {
-		os := state.(int)
-		ns := os + 2
-		return os, ns
-	}
-	even := BuildLazyIntEvaluator(evenFunc, 0)
-
-	for i := 0; i < 10; i++ {
-		fmt.Printf("%vth even: %v\n", i, even())
-	}
-}
-
-func BuildLazyEvaluator(evalFunc EvalFunc, initState Any) func() Any {
-	retValChan := make(chan Any)
-	loopFunc := func() {
-		var actState Any = initState
-		var retVal Any
-		for {
-			retVal, actState = evalFunc(actState)
-			retValChan <- retVal
-		}
-	}
-	retFunc := func() Any {
-		return <-retValChan
-	}
-	go loopFunc()
-	return retFunc
-}
-
-func BuildLazyIntEvaluator(evalFunc EvalFunc, initState Any) func() int {
-	ef := BuildLazyEvaluator(evalFunc, initState)
-	return func() int {
-		return ef().(int)
-	}
-}
-/* Output:
-0th even: 0
-1th even: 2
-2th even: 4
-3th even: 6
-4th even: 8
-5th even: 10
-6th even: 12
-7th even: 14
-8th even: 16
-9th even: 18
-*/
+package main
+
+import (
+	"fmt"
+)
+
+type Any interface{}
+type EvalFunc func(Any) (Any, Any)
+
+func main() {
+	evenFunc := func(state Any) (Any, Any) {
+		os := state.(int)
+		ns := os + 2
+		return os, ns
+	}
+	even := BuildLazyIntEvaluator(evenFunc, 0)
+
+	for i := 0; i < 10; i++ {
+		fmt.Printf("%vth even: %v\n", i, even())
+	}
+}
+
+func BuildLazyEvaluator(evalFunc EvalFunc, initState Any) func() Any {
+	retValChan := make(chan Any)
+	loopFunc := func() {
+		var actState Any = initState
+		var retVal Any
+		for {
+			retVal, actState = evalFunc(actState)
+			retValChan <- retVal
+		}
+	}
+	retFunc := func() Any {
+		return <-retValChan
+	}
+	go loopFunc()
+	return retFunc
+}
+
+func BuildLazyIntEvaluator(evalFunc EvalFunc, initState Any) func() int {
+	ef := BuildLazyEvaluator(evalFunc, initState)
+	return func() int {
+		return ef().(int)
+	}
+}
+
+/* Output:
+0th even: 0
+1th even: 2
+2th even: 4
+3th even: 6
+4th even: 8
+5th even: 10
+6th even: 12
+7th even: 14
+8th even: 16
+9th even: 18
+*/

eBook/examples/chapter_14/goroutine1.go

@@ -1,29 +1,29 @@
-package main
-
-import (
-	"fmt"
-	"time"
-)
-
-func main() {
-	fmt.Println("In main()")
-	// longWait()
-	go longWait()
-	// shortWait()
-	go shortWait()
-	fmt.Println("About to sleep in main()")
-	time.Sleep(10 * 1e9) // sleep works with a Duration in nanoseconds (ns) !
-	fmt.Println("At the end of main()")
-}
-
-func longWait() {
-	fmt.Println("Beginning longWait()")
-	time.Sleep(5 * 1e9) // sleep for 5 seconds
-	fmt.Println("End of longWait()")
-}
-
-func shortWait() {
-	fmt.Println("Beginning shortWait()")
-	time.Sleep(2 * 1e9) // sleep for 2 seconds
-	fmt.Println("End of shortWait()")
-}
+package main
+
+import (
+	"fmt"
+	"time"
+)
+
+func main() {
+	fmt.Println("In main()")
+	// longWait()
+	go longWait()
+	// shortWait()
+	go shortWait()
+	fmt.Println("About to sleep in main()")
+	time.Sleep(10 * 1e9) // sleep works with a Duration in nanoseconds (ns) !
+	fmt.Println("At the end of main()")
+}
+
+func longWait() {
+	fmt.Println("Beginning longWait()")
+	time.Sleep(5 * 1e9) // sleep for 5 seconds
+	fmt.Println("End of longWait()")
+}
+
+func shortWait() {
+	fmt.Println("Beginning shortWait()")
+	time.Sleep(2 * 1e9) // sleep for 2 seconds
+	fmt.Println("End of shortWait()")
+}

eBook/examples/chapter_14/goroutine2.go

@@ -1,33 +1,34 @@
-package main
-
-import (
-	"fmt"
-	"time"
-)
-
-func main() {
-	ch := make(chan string)
-
-	go sendData(ch)
-	go getData(ch)  
-
-	time.Sleep(1e9)
-}
-
-func sendData(ch chan string) {
-	ch <- "Washington"
-	ch <- "Tripoli"
-	ch <- "London"
-	ch <- "Beijing"
-	ch <- "Tokio"
-}
-
-func getData(ch chan string) {
-	var input string
-	// time.Sleep(1e9)
-	for {
-		input = <-ch
-		fmt.Printf("%s ", input)
-	}
-}
-// Washington Tripoli London Beijing Tokio
+package main
+
+import (
+	"fmt"
+	"time"
+)
+
+func main() {
+	ch := make(chan string)
+
+	go sendData(ch)
+	go getData(ch)
+
+	time.Sleep(1e9)
+}
+
+func sendData(ch chan string) {
+	ch <- "Washington"
+	ch <- "Tripoli"
+	ch <- "London"
+	ch <- "Beijing"
+	ch <- "Tokio"
+}
+
+func getData(ch chan string) {
+	var input string
+	// time.Sleep(1e9)
+	for {
+		input = <-ch
+		fmt.Printf("%s ", input)
+	}
+}
+
+// Washington Tripoli London Beijing Tokio

eBook/examples/chapter_14/goroutine3.go

@@ -1,29 +1,30 @@
-package main
-
-import "fmt"
-
-func main() {
-	ch := make(chan string)
-	go sendData(ch)
-	getData(ch)
-}
-
-func sendData(ch chan string) {
-	ch <- "Washington"
-	ch <- "Tripoli"
-	ch <- "London"
-	ch <- "Beijing"
-	ch <- "Tokio"
-	close(ch)
-}
-
-func getData(ch chan string) {
-	for {
-		input, open := <-ch
-		if !open {
-			break
-		}
-		fmt.Printf("%s ", input)
-	}
-}
-// Washington Tripoli London Beijing Tokio 
+package main
+
+import "fmt"
+
+func main() {
+	ch := make(chan string)
+	go sendData(ch)
+	getData(ch)
+}
+
+func sendData(ch chan string) {
+	ch <- "Washington"
+	ch <- "Tripoli"
+	ch <- "London"
+	ch <- "Beijing"
+	ch <- "Tokio"
+	close(ch)
+}
+
+func getData(ch chan string) {
+	for {
+		input, open := <-ch
+		if !open {
+			break
+		}
+		fmt.Printf("%s ", input)
+	}
+}
+
+// Washington Tripoli London Beijing Tokio

eBook/examples/chapter_14/goroutine_select.go

@@ -1,40 +1,40 @@
-package main
-
-import (
-	"fmt"
-	"time"
-)
-
-func main() {
-	ch1 := make(chan int)
-	ch2 := make(chan int)
-
-	go pump1(ch1)
-	go pump2(ch2)
-	go suck(ch1, ch2)
-
-	time.Sleep(1e9)
-}
-
-func pump1(ch chan int) {
-	for i := 0; ; i++ {
-		ch <- i * 2
-	}
-}
-
-func pump2(ch chan int) {
-	for i := 0; ; i++ {
-		ch <- i + 5
-	}
-}
-
-func suck(ch1, ch2 chan int) {
-	for {
-		select {
-		case v := <-ch1:
-			fmt.Printf("Received on channel 1: %d\n", v)
-		case v := <-ch2:
-			fmt.Printf("Received on channel 2: %d\n", v)
-		}
-	}
-}
+package main
+
+import (
+	"fmt"
+	"time"
+)
+
+func main() {
+	ch1 := make(chan int)
+	ch2 := make(chan int)
+
+	go pump1(ch1)
+	go pump2(ch2)
+	go suck(ch1, ch2)
+
+	time.Sleep(1e9)
+}
+
+func pump1(ch chan int) {
+	for i := 0; ; i++ {
+		ch <- i * 2
+	}
+}
+
+func pump2(ch chan int) {
+	for i := 0; ; i++ {
+		ch <- i + 5
+	}
+}
+
+func suck(ch1, ch2 chan int) {
+	for {
+		select {
+		case v := <-ch1:
+			fmt.Printf("Received on channel 1: %d\n", v)
+		case v := <-ch2:
+			fmt.Printf("Received on channel 2: %d\n", v)
+		}
+	}
+}

eBook/examples/chapter_14/goroutine_select2.go

@@ -1,49 +1,47 @@
-package main
-
-import (
-	"fmt"
-	"time"
-	"runtime"
-)
-
-func main() {
-	// setting GOMAXPROCS to 2 gives +- 22% performance increase, 
-	// but increasing the number doesn't increase the performance
-	// without GOMAXPROCS: +- 86000
-	// setting GOMAXPROCS to 2: +- 105000
-	// setting GOMAXPROCS to 3: +- 94000
-	runtime.GOMAXPROCS(2)
-	ch1 := make(chan int)
-	ch2 := make(chan int)
-	
-	go pump1(ch1)
-	go pump2(ch2)
-	go suck(ch1, ch2)
-	
-	time.Sleep(1e9)
-}
-
-func pump1(ch chan int) {
-	for i:=0; ; i++ {
-		ch <- i*2
-	}
-}
-
-func pump2(ch chan int) {
-	for i:=0; ; i++ {
-		ch <- i+5
-	}
-}
-
-func suck(ch1,ch2 chan int) {
-	for i := 0; ; i++ {
-		select {
-			case v := <- ch1:
-				fmt.Printf("%d - Received on channel 1: %d\n", i, v)
-			case v := <- ch2:
-				fmt.Printf("%d - Received on channel 2: %d\n", i, v)
-		}
-	}
-}
-
-
+package main
+
+import (
+	"fmt"
+	"runtime"
+	"time"
+)
+
+func main() {
+	// setting GOMAXPROCS to 2 gives +- 22% performance increase,
+	// but increasing the number doesn't increase the performance
+	// without GOMAXPROCS: +- 86000
+	// setting GOMAXPROCS to 2: +- 105000
+	// setting GOMAXPROCS to 3: +- 94000
+	runtime.GOMAXPROCS(2)
+	ch1 := make(chan int)
+	ch2 := make(chan int)
+
+	go pump1(ch1)
+	go pump2(ch2)
+	go suck(ch1, ch2)
+
+	time.Sleep(1e9)
+}
+
+func pump1(ch chan int) {
+	for i := 0; ; i++ {
+		ch <- i * 2
+	}
+}
+
+func pump2(ch chan int) {
+	for i := 0; ; i++ {
+		ch <- i + 5
+	}
+}
+
+func suck(ch1, ch2 chan int) {
+	for i := 0; ; i++ {
+		select {
+		case v := <-ch1:
+			fmt.Printf("%d - Received on channel 1: %d\n", i, v)
+		case v := <-ch2:
+			fmt.Printf("%d - Received on channel 2: %d\n", i, v)
+		}
+	}
+}

eBook/examples/chapter_14/lazy_evaluation.go

@@ -1,30 +1,30 @@
-// lazy_evaluation.go
-package main
-
-import (
-	"fmt"
-)
-
-var resume chan int
-
-func integers() chan int {
-    yield := make (chan int)
-    count := 0
-    go func () {
-        for {
-            yield <- count
-            count++
-        }
-    } ()
-    return yield
-}
-
-func generateInteger() int {
-    return <-resume
-}
-func main() {
-	resume = integers()
-	fmt.Println(generateInteger()) //=> 0
-	fmt.Println(generateInteger()) //=> 1
-	fmt.Println(generateInteger()) //=> 2
-}
+// lazy_evaluation.go
+package main
+
+import (
+	"fmt"
+)
+
+var resume chan int
+
+func integers() chan int {
+	yield := make(chan int)
+	count := 0
+	go func() {
+		for {
+			yield <- count
+			count++
+		}
+	}()
+	return yield
+}
+
+func generateInteger() int {
+	return <-resume
+}
+func main() {
+	resume = integers()
+	fmt.Println(generateInteger()) //=> 0
+	fmt.Println(generateInteger()) //=> 1
+	fmt.Println(generateInteger()) //=> 2
+}

eBook/examples/chapter_14/max_tasks.go

@@ -1,31 +1,32 @@
-package main
-
-const MAXREQS = 50
-var sem = make(chan int, MAXREQS)
-
-type Request struct {
-	a, b   int
-	replyc chan int
-}
-
-func process(r *Request) {
-	// do something
-}
-
-func handle(r *Request) {
-   sem <- 1    // doesn't matter what we put in it
-   process(r)  
-   <-sem       // one empty place in the buffer: the next request can start 
-}
-
-func server(service chan *Request) {
-   for {
-       request := <-service
-       go handle(request) 
-   }
-}
-
-func main() {
-	service := make(chan *Request)
-	go server(service)
-}
+package main
+
+const MAXREQS = 50
+
+var sem = make(chan int, MAXREQS)
+
+type Request struct {
+	a, b   int
+	replyc chan int
+}
+
+func process(r *Request) {
+	// do something
+}
+
+func handle(r *Request) {
+	sem <- 1 // doesn't matter what we put in it
+	process(r)
+	<-sem // one empty place in the buffer: the next request can start
+}
+
+func server(service chan *Request) {
+	for {
+		request := <-service
+		go handle(request)
+	}
+}
+
+func main() {
+	service := make(chan *Request)
+	go server(service)
+}

eBook/examples/chapter_14/multiplex_server.go

@@ -1,53 +1,53 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-package main
-
-import "fmt"
-
-type Request struct {
-	a, b   int
-	replyc chan int // reply channel inside the Request
-}
-
-type binOp func(a, b int) int
-
-func run(op binOp, req *Request) {
-	req.replyc <- op(req.a, req.b)
-}
-
-func server(op binOp, service chan *Request) {
-	for {
-		req := <-service // requests arrive here
-		// start goroutine for request:
-		go run(op, req) // don't wait for op
-	}
-}
-
-func startServer(op binOp) chan *Request {
-	reqChan := make(chan *Request)
-	go server(op, reqChan)
-	return reqChan
-}
-
-func main() {
-	adder := startServer(func(a, b int) int { return a + b })
-	const N = 100
-	var reqs [N]Request
-	for i := 0; i < N; i++ {
-		req := &reqs[i]
-		req.a = i
-		req.b = i + N
-		req.replyc = make(chan int)
-		adder <- req
-	}
-	// checks:
-	for i := N - 1; i >= 0; i-- { // doesn't matter what order
-		if <-reqs[i].replyc != N+2*i {
-			fmt.Println("fail at", i)
-		} else {
-			fmt.Println("Request ", i, " is ok!")
-		}
-	}
-	fmt.Println("done")
-}
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+package main
+
+import "fmt"
+
+type Request struct {
+	a, b   int
+	replyc chan int // reply channel inside the Request
+}
+
+type binOp func(a, b int) int
+
+func run(op binOp, req *Request) {
+	req.replyc <- op(req.a, req.b)
+}
+
+func server(op binOp, service chan *Request) {
+	for {
+		req := <-service // requests arrive here
+		// start goroutine for request:
+		go run(op, req) // don't wait for op
+	}
+}
+
+func startServer(op binOp) chan *Request {
+	reqChan := make(chan *Request)
+	go server(op, reqChan)
+	return reqChan
+}
+
+func main() {
+	adder := startServer(func(a, b int) int { return a + b })
+	const N = 100
+	var reqs [N]Request
+	for i := 0; i < N; i++ {
+		req := &reqs[i]
+		req.a = i
+		req.b = i + N
+		req.replyc = make(chan int)
+		adder <- req
+	}
+	// checks:
+	for i := N - 1; i >= 0; i-- { // doesn't matter what order
+		if <-reqs[i].replyc != N+2*i {
+			fmt.Println("fail at", i)
+		} else {
+			fmt.Println("Request ", i, " is ok!")
+		}
+	}
+	fmt.Println("done")
+}

eBook/examples/chapter_14/multiplex_server2.go

@@ -1,58 +1,58 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-package main
-
-import "fmt"
-
-type Request struct {
-	a, b   int
-	replyc chan int // reply channel inside the Request
-}
-
-type binOp func(a, b int) int
-
-func run(op binOp, req *Request) {
-	req.replyc <- op(req.a, req.b)
-}
-
-func server(op binOp, service chan *Request, quit chan bool) {
-	for {
-		select {
-			case req := <-service:
-				go run(op, req) 
-			case <-quit:
-				return
-		}
-	}
-}
-
-func startServer(op binOp) (service chan *Request, quit chan bool) {
-	service = make(chan *Request)
-	quit = make(chan bool)
-	go server(op, service, quit)
-	return service, quit
-}
-
-func main() {
-	adder, quit := startServer(func(a, b int) int { return a + b })
-	const N = 100
-	var reqs [N]Request
-	for i := 0; i < N; i++ {
-		req := &reqs[i]
-		req.a = i
-		req.b = i + N
-		req.replyc = make(chan int)
-		adder <- req
-	}
-	// checks:
-	for i := N - 1; i >= 0; i-- { // doesn't matter what order
-		if <-reqs[i].replyc != N+2*i {
-			fmt.Println("fail at", i)
-		} else {
-			fmt.Println("Request ", i, " is ok!")
-		}
-	}
-	quit <- true
-	fmt.Println("done")
-}
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+package main
+
+import "fmt"
+
+type Request struct {
+	a, b   int
+	replyc chan int // reply channel inside the Request
+}
+
+type binOp func(a, b int) int
+
+func run(op binOp, req *Request) {
+	req.replyc <- op(req.a, req.b)
+}
+
+func server(op binOp, service chan *Request, quit chan bool) {
+	for {
+		select {
+		case req := <-service:
+			go run(op, req)
+		case <-quit:
+			return
+		}
+	}
+}
+
+func startServer(op binOp) (service chan *Request, quit chan bool) {
+	service = make(chan *Request)
+	quit = make(chan bool)
+	go server(op, service, quit)
+	return service, quit
+}
+
+func main() {
+	adder, quit := startServer(func(a, b int) int { return a + b })
+	const N = 100
+	var reqs [N]Request
+	for i := 0; i < N; i++ {
+		req := &reqs[i]
+		req.a = i
+		req.b = i + N
+		req.replyc = make(chan int)
+		adder <- req
+	}
+	// checks:
+	for i := N - 1; i >= 0; i-- { // doesn't matter what order
+		if <-reqs[i].replyc != N+2*i {
+			fmt.Println("fail at", i)
+		} else {
+			fmt.Println("Request ", i, " is ok!")
+		}
+	}
+	quit <- true
+	fmt.Println("done")
+}

eBook/examples/chapter_14/sieve1.go

@@ -1,37 +1,37 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.package main
-package main
-
-import "fmt"
-
-// Send the sequence 2, 3, 4, ... to channel 'ch'.
-func generate(ch chan int) {
-	for i := 2; ; i++ {
-		ch <- i // Send 'i' to channel 'ch'.
-	}
-}
-
-// Copy the values from channel 'in' to channel 'out',
-// removing those divisible by 'prime'.
-func filter(in, out chan int, prime int) {
-	for {
-		i := <-in // Receive value of new variable 'i' from 'in'.
-		if i%prime != 0 {
-			out <- i // Send 'i' to channel 'out'.
-		}
-	}
-}
-
-// The prime sieve: Daisy-chain filter processes together.
-func main() {
-	ch := make(chan int) // Create a new channel.
-	go generate(ch)      // Start generate() as a goroutine.
-	for {
-		prime := <-ch
-		fmt.Print(prime, " ")
-		ch1 := make(chan int)
-		go filter(ch, ch1, prime)
-		ch = ch1
-	}
-}
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.package main
+package main
+
+import "fmt"
+
+// Send the sequence 2, 3, 4, ... to channel 'ch'.
+func generate(ch chan int) {
+	for i := 2; ; i++ {
+		ch <- i // Send 'i' to channel 'ch'.
+	}
+}
+
+// Copy the values from channel 'in' to channel 'out',
+// removing those divisible by 'prime'.
+func filter(in, out chan int, prime int) {
+	for {
+		i := <-in // Receive value of new variable 'i' from 'in'.
+		if i%prime != 0 {
+			out <- i // Send 'i' to channel 'out'.
+		}
+	}
+}
+
+// The prime sieve: Daisy-chain filter processes together.
+func main() {
+	ch := make(chan int) // Create a new channel.
+	go generate(ch)      // Start generate() as a goroutine.
+	for {
+		prime := <-ch
+		fmt.Print(prime, " ")
+		ch1 := make(chan int)
+		go filter(ch, ch1, prime)
+		ch = ch1
+	}
+}

eBook/examples/chapter_14/sieve2.go

@@ -1,53 +1,53 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main
-
-import (
-	"fmt"
-)
-
-// Send the sequence 2, 3, 4, ... to returned channel 
-func generate() chan int {
-	ch := make(chan int)
-	go func() {
-		for i := 2; ; i++ {
-			ch <- i
-		}
-	}()
-	return ch
-}
-
-// Filter out input values divisible by 'prime', send rest to returned channel
-func filter(in chan int, prime int) chan int {
-	out := make(chan int)
-	go func() {
-		for {
-			if i := <-in; i%prime != 0 {
-				out <- i
-			}
-		}
-	}()
-	return out
-}
-
-func sieve() chan int {
-	out := make(chan int)
-	go func() {
-		ch := generate()
-		for {
-			prime := <-ch
-			ch = filter(ch, prime)
-			out <- prime
-		}
-	}()
-	return out
-}
-
-func main() {
-	primes := sieve()
-	for {
-		fmt.Println(<-primes)
-	}
-}
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+	"fmt"
+)
+
+// Send the sequence 2, 3, 4, ... to returned channel
+func generate() chan int {
+	ch := make(chan int)
+	go func() {
+		for i := 2; ; i++ {
+			ch <- i
+		}
+	}()
+	return ch
+}
+
+// Filter out input values divisible by 'prime', send rest to returned channel
+func filter(in chan int, prime int) chan int {
+	out := make(chan int)
+	go func() {
+		for {
+			if i := <-in; i%prime != 0 {
+				out <- i
+			}
+		}
+	}()
+	return out
+}
+
+func sieve() chan int {
+	out := make(chan int)
+	go func() {
+		ch := generate()
+		for {
+			prime := <-ch
+			ch = filter(ch, prime)
+			out <- prime
+		}
+	}()
+	return out
+}
+
+func main() {
+	primes := sieve()
+	for {
+		fmt.Println(<-primes)
+	}
+}

eBook/examples/chapter_14/timer_goroutine.go

@@ -1,42 +1,43 @@
-// default.go
-package main
-
-import (
-	"fmt"
-	"time"
-)
-
-func main() {
-	tick := time.Tick(1e8)
-	boom := time.After(5e8)
-	for {
-		select {
-		case <-tick:
-			fmt.Println("tick.")
-		case <-boom:
-			fmt.Println("BOOM!")
-			return
-		default:
-			fmt.Println("    .")
-			time.Sleep(5e7)
-		}
-	}
-}
-/* Output:
-    .
-    .
-tick.
-    .
-    .
-tick.
-    .
-    .
-tick.
-    .
-    .
-tick.
-    .
-    .
-tick.
-BOOM!
-*/
+// default.go
+package main
+
+import (
+	"fmt"
+	"time"
+)
+
+func main() {
+	tick := time.Tick(1e8)
+	boom := time.After(5e8)
+	for {
+		select {
+		case <-tick:
+			fmt.Println("tick.")
+		case <-boom:
+			fmt.Println("BOOM!")
+			return
+		default:
+			fmt.Println("    .")
+			time.Sleep(5e7)
+		}
+	}
+}
+
+/* Output:
+    .
+    .
+tick.
+    .
+    .
+tick.
+    .
+    .
+tick.
+    .
+    .
+tick.
+    .
+    .
+tick.
+BOOM!
+*/

eBook/examples/chapter_16/closures_goroutines.go

@@ -1,47 +1,48 @@
-// closures_goroutines.go
-package main
-
-import (
-	"fmt"
-	"time"
-)
-
-var values = [5]int{10, 11, 12, 13, 14}
-
-func main() {
-	// version A:
-	for ix := range values {  // ix is index!
-		func() {			   
-			fmt.Print(ix, " ")
-		}()					   // call closure, prints each index 
-	}
-	fmt.Println()
-	// version B: same as A, but call closure as a goroutine
-	for ix := range values {
-		go func() {
-			fmt.Print(ix, " ")
-		}()
-	}
-	time.Sleep(1e9)
-	// version C: the right way
-	for ix := range values {
-    	go func(ix interface{}) {
-        	fmt.Print(ix, " ")
-    	}(ix)
-	}
-	time.Sleep(1e9)
-	// version D: print out the values:
-	for ix := range values {
-    	val := values[ix]
-    	go func() {
-       		fmt.Print(val, " ")
-    	}()
-	}
-	time.Sleep(1e9)
-}
-/* Output:
-0 1 2 3 4 
-4 4 4 4 4 
-1 0 3 4 2 
-0 1 2 4 3  
-*/
+// closures_goroutines.go
+package main
+
+import (
+	"fmt"
+	"time"
+)
+
+var values = [5]int{10, 11, 12, 13, 14}
+
+func main() {
+	// version A:
+	for ix := range values { // ix is index!
+		func() {
+			fmt.Print(ix, " ")
+		}() // call closure, prints each index
+	}
+	fmt.Println()
+	// version B: same as A, but call closure as a goroutine
+	for ix := range values {
+		go func() {
+			fmt.Print(ix, " ")
+		}()
+	}
+	time.Sleep(1e9)
+	// version C: the right way
+	for ix := range values {
+		go func(ix interface{}) {
+			fmt.Print(ix, " ")
+		}(ix)
+	}
+	time.Sleep(1e9)
+	// version D: print out the values:
+	for ix := range values {
+		val := values[ix]
+		go func() {
+			fmt.Print(val, " ")
+		}()
+	}
+	time.Sleep(1e9)
+}
+
+/* Output:
+0 1 2 3 4
+4 4 4 4 4
+1 0 3 4 2
+0 1 2 4 3
+*/

eBook/examples/chapter_16/pointer_interface.go

@@ -1,31 +1,30 @@
-// nexter.go
-package main
-
-import (
-	"fmt"
-)
-
-type nexter interface {
-    next() byte
-}
-
-
-func nextFew1(n nexter, num int) []byte {
-	var b []byte
-	for i:=0; i < num; i++ {
-		b[i] = n.next()
-	}
-	return b
-}
-
-func nextFew2(n *nexter, num int) []byte {
-	var b []byte
-	for i:=0; i < num; i++ {
-		b[i] = n.next() // compile error:  n.next undefined (type *nexter has no field or method next)
-	}
-	return b
-}
-
-func main() {
-	fmt.Println("Hello World!")
-}
+// nexter.go
+package main
+
+import (
+	"fmt"
+)
+
+type nexter interface {
+	next() byte
+}
+
+func nextFew1(n nexter, num int) []byte {
+	var b []byte
+	for i := 0; i < num; i++ {
+		b[i] = n.next()
+	}
+	return b
+}
+
+func nextFew2(n *nexter, num int) []byte {
+	var b []byte
+	for i := 0; i < num; i++ {
+		b[i] = n.next() // compile error:  n.next undefined (type *nexter has no field or method next)
+	}
+	return b
+}
+
+func main() {
+	fmt.Println("Hello World!")
+}

eBook/examples/chapter_19/goto_v1/main.go

@@ -11,6 +11,7 @@ URL: <input type="text" name="url">
 <input type="submit" value="Add">
 </form>
 `
+
 var store = NewURLStore()
 
 func main() {
@@ -29,7 +30,6 @@ func Redirect(w http.ResponseWriter, r *http.Request) {
 	http.Redirect(w, r, url, http.StatusFound)
 }
 
-
 func Add(w http.ResponseWriter, r *http.Request) {
 	url := r.FormValue("url")
 	if url == "" {

eBook/examples/chapter_19/goto_v1/store.go

@@ -3,8 +3,8 @@ package main
 import "sync"
 
 type URLStore struct {
-	urls  map[string]string
-	mu    sync.RWMutex
+	urls map[string]string
+	mu   sync.RWMutex
 }
 
 func NewURLStore() *URLStore {

eBook/examples/chapter_19/goto_v2/main.go

@@ -23,7 +23,6 @@ func Redirect(w http.ResponseWriter, r *http.Request) {
 	http.Redirect(w, r, url, http.StatusFound)
 }
 
-
 func Add(w http.ResponseWriter, r *http.Request) {
 	url := r.FormValue("url")
 	if url == "" {

eBook/examples/chapter_19/goto_v2/store.go

@@ -9,9 +9,9 @@ import (
 )
 
 type URLStore struct {
-	urls     map[string]string
-	mu       sync.RWMutex
-	file     *os.File
+	urls map[string]string
+	mu   sync.RWMutex
+	file *os.File
 }
 
 type record struct {
@@ -70,7 +70,7 @@ func (s *URLStore) load() error {
 	if _, err := s.file.Seek(0, 0); err != nil {
 		return err
 	}
-	d := gob.NewDecoder(s.file) 
+	d := gob.NewDecoder(s.file)
 	var err error
 	for err == nil {
 		var r record

eBook/examples/chapter_19/goto_v3/store.go

@@ -1,7 +1,7 @@
 package main
 
 import (
-//	"bufio"
+	//	"bufio"
 	"encoding/gob"
 	"io"
 	"log"
@@ -12,9 +12,9 @@ import (
 const saveQueueLength = 1000
 
 type URLStore struct {
-	urls  map[string]string
-	mu    sync.RWMutex
-	save  chan record
+	urls map[string]string
+	mu   sync.RWMutex
+	save chan record
 }
 
 type record struct {
@@ -74,9 +74,9 @@ func (s *URLStore) load(filename string) error {
 	}
 	defer f.Close()
 	// buffered reading:
-	// b := bufio.NewReader(f)  
-	// d := gob.NewDecoder(b) 
-	d := gob.NewDecoder(f)  
+	// b := bufio.NewReader(f)
+	// d := gob.NewDecoder(b)
+	d := gob.NewDecoder(f)
 	for err == nil {
 		var r record
 		if err = d.Decode(&r); err == nil {
@@ -97,13 +97,13 @@ func (s *URLStore) saveLoop(filename string) {
 		log.Fatal("Error opening URLStore: ", err)
 	}
 	defer f.Close()
-	e := gob.NewEncoder(f) 
+	e := gob.NewEncoder(f)
 	// buffered encoding:
-	// b := bufio.NewWriter(f)   
+	// b := bufio.NewWriter(f)
 	// e := gob.NewEncoder(b)
 	// defer b.Flush()
 	for {
-		r := <-s.save  // takes a record from the channel
+		r := <-s.save // takes a record from the channel
 		if err := e.Encode(r); err != nil {
 			log.Println("Error saving to URLStore: ", err)
 		}

eBook/examples/chapter_19/goto_v4/store.go

@@ -11,9 +11,9 @@ import (
 const saveQueueLength = 1000
 
 type URLStore struct {
-	urls  map[string]string
-	mu    sync.RWMutex
-	save  chan record
+	urls map[string]string
+	mu   sync.RWMutex
+	save chan record
 }
 
 type record struct {
@@ -72,7 +72,7 @@ func (s *URLStore) load(filename string) error {
 		return err
 	}
 	defer f.Close()
-	d := json.NewDecoder(f)  
+	d := json.NewDecoder(f)
 	for err == nil {
 		var r record
 		if err = d.Decode(&r); err == nil {
@@ -93,9 +93,9 @@ func (s *URLStore) saveLoop(filename string) {
 		log.Fatal("Error opening URLStore: ", err)
 	}
 	defer f.Close()
-	e := json.NewEncoder(f) 
+	e := json.NewEncoder(f)
 	for {
-		r := <-s.save  // takes a record from the channel
+		r := <-s.save // takes a record from the channel
 		if err := e.Encode(r); err != nil {
 			log.Println("Error saving to URLStore: ", err)
 		}