update book code

eBook/examples/chapter_10/embed_func1.go

@@ -0,0 +1,43 @@
+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

@@ -0,0 +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!}
+*/

eBook/examples/chapter_10/embedd_struct.go

@@ -0,0 +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)
+}

eBook/examples/chapter_10/main.go

@@ -0,0 +1,16 @@
+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

eBook/examples/chapter_10/method1.go

@@ -0,0 +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
+}

eBook/examples/chapter_10/method2.go

@@ -0,0 +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
+}

eBook/examples/chapter_10/method3.go

@@ -0,0 +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
+}

eBook/examples/chapter_10/method4.go

@@ -0,0 +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
+}

eBook/examples/chapter_10/method_on_time.go

@@ -0,0 +1,25 @@
+// 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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,22 @@
+// 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

@@ -0,0 +1,34 @@
+// 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

@@ -0,0 +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"
+}

eBook/examples/chapter_10/person.go

@@ -0,0 +1,41 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,28 @@
+// 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

@@ -0,0 +1,24 @@
+// 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

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

eBook/examples/chapter_10/struct_tag.go

@@ -0,0 +1,30 @@
+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

@@ -0,0 +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)
+
+}

eBook/examples/chapter_10/structs_fields.go

@@ -0,0 +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}
+}

eBook/examples/chapter_10/use_person2.go

@@ -0,0 +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
+}

eBook/examples/chapter_10/vcard.json

@@ -0,0 +1 @@
+{"FirstName":"Jan","LastName":"Kersschot","Addresses":[{"Type":"private","City":"Aartselaar","Country":"Belgium"},{"Type":"work","City":"Boom","Country":"Belgium"}],"Remark":"none"}

eBook/examples/chapter_11/cars.go

@@ -0,0 +1,95 @@
+// 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

@@ -0,0 +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)
+}

eBook/examples/chapter_11/empty_interface.go

@@ -0,0 +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)
+	}
+}

eBook/examples/chapter_11/emptyint_switch.go

@@ -0,0 +1,32 @@
+package main
+
+import "fmt"
+
+type specialString string
+
+var whatIsThis specialString = "hello"
+
+func TypeSwitch() {
+	testFunc := func(any interface{}) {
+		switch v := any.(type) {
+		case bool:
+			fmt.Printf("any %v is a bool type", v)
+		case int:
+			fmt.Printf("any %v is an int type", v)
+		case float32:
+			fmt.Printf("any %v is a float32 type", v)
+		case string:
+			fmt.Printf("any %v is a string type", v)
+		case specialString:
+			fmt.Printf("any %v is a special String!", v)
+		default:
+			fmt.Println("unknown type!")
+		}
+	}
+	testFunc(whatIsThis)
+}
+
+func main() {
+	TypeSwitch()
+}
+// Output:  any hello is a special String!

eBook/examples/chapter_11/interfaces.go

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,45 @@
+// 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

@@ -0,0 +1,48 @@
+// 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

@@ -0,0 +1,65 @@
+//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

@@ -0,0 +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}
+}

eBook/examples/chapter_11/print.go

@@ -0,0 +1,43 @@
+// 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

@@ -0,0 +1,32 @@
+// 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

@@ -0,0 +1,33 @@
+// 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

@@ -0,0 +1,47 @@
+// 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

@@ -0,0 +1,31 @@
+// 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

@@ -0,0 +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.
+// 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

@@ -0,0 +1,82 @@
+// 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 
+*/

eBook/examples/chapter_11/static.go

@@ -0,0 +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)
+}

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

@@ -0,0 +1 @@
+default

eBook/examples/chapter_11/tideland-cgl.googlecode.com/hg/.hg/branchheads.cache

@@ -0,0 +1,2 @@
+0e0559350cc3c90b3a51dd98ac3ba577db027317 95
+0e0559350cc3c90b3a51dd98ac3ba577db027317 default

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

@@ -0,0 +1,2 @@
+[paths]
+default = https://tideland-cgl.googlecode.com/hg

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

@@ -0,0 +1,4 @@
+revlogv1
+store
+fncache
+dotencode