Rework maps section

Closes #267

Author: jcbwlkr

topics/go/language/maps/README.md

@@ -5,8 +5,11 @@ Maps provide a data structure that allow for the storage and management of key/v
 ## Notes
 
 * Maps provide a way to store and retrieve key/value pairs.
-* The map key must be a value that can be used in an assignment statement.
+* Reading an absent key returns the zero value for the map's value type.
 * Iterating over a map is always random.
+* The map key must be a value that is comparable.
+* Elements in a map are not addressable.
+* Maps are a reference type.
 
 ## Links
 
@@ -17,10 +20,14 @@ http://www.goinggo.net/2013/12/macro-view-of-map-internals-in-go.html
 
 ## Code Review
 
-[Declare, initialize and iterate](example1/example1.go) ([Go Playground](https://play.golang.org/p/xMpg8hv_1pD))  
-[Map literals and delete](example2/example2.go) ([Go Playground](https://play.golang.org/p/exyL4z8STLt))  
-[Map key restrictions](example3/example3.go) ([Go Playground](https://play.golang.org/p/j7Rrqn4XiBR))  
-[Sorting maps by key](example4/example4.go) ([Go Playground](https://play.golang.org/p/fkr0722d-eg))  
+TODO renumber
+[Declare, write, read, and delete](example1/example1.go) ([Go Playground](https://play.golang.org/p/3w6zgywPD3w))  
+[Absent keys](example2/example2.go) ([Go Playground](https://play.golang.org/p/5KHMfmL2SyA))  
+[Map key restrictions](example3/example3.go) ([Go Playground](https://play.golang.org/p/lfl967ocaKv))  
+[Map literals and range](example4/example4.go) ([Go Playground](https://play.golang.org/p/0KFlxby2a0z))  
+[Sorting maps by key](example5/example5.go) ([Go Playground](https://play.golang.org/p/XADXCQqn2pJ))  
+[Taking an element's address](example6/example6.go) ([Go Playground](https://play.golang.org/p/4phv1S1wZWh))  
+[Maps are Reference Types](example7/example7.go) ([Go Playground](https://play.golang.org/p/7jEDn1yhg5v))  
 
 ## Exercises
 

topics/go/language/maps/example1/example1.go

@@ -1,13 +1,13 @@
 // All material is licensed under the Apache License Version 2.0, January 2004
 // http://www.apache.org/licenses/LICENSE-2.0
 
-// Sample program to show how to declare, initialize and iterate
-// over a map. Shows how iterating over a map is random.
+// Sample program to show how to initialize a map, write to
+// it, then read and delete from it.
 package main
 
 import "fmt"
 
-// user defines a user in the program.
+// user represents someone using the program.
 type user struct {
 	name    string
 	surname string
@@ -25,16 +25,25 @@ func main() {
 	users["Mouse"] = user{"Mickey", "Mouse"}
 	users["Jackson"] = user{"Michael", "Jackson"}
 
-	// Iterate over the map.
-	for key, value := range users {
-		fmt.Println(key, value)
-	}
+	// Read the value at a specific key.
+	mouse := users["Mouse"]
 
-	fmt.Println()
+	fmt.Printf("%+v\n", mouse)
 
-	// Iterate over the map and notice the
-	// results are different.
-	for key := range users {
-		fmt.Println(key)
-	}
+	// Replace the value at the Mouse key.
+	users["Mouse"] = user{"Jerry", "Mouse"}
+
+	// Read the Mouse key again.
+	fmt.Printf("%+v\n", users["Mouse"])
+
+	// Delete the value at a specific key.
+	delete(users, "Roy")
+
+	// Check the length of the map. There are only 3 elements.
+	fmt.Println(len(users))
+
+	// It is safe to delete an absent key.
+	delete(users, "Roy")
+
+	fmt.Println("Goodbye.")
 }

topics/go/language/maps/example2/example2.go

@@ -1,41 +1,41 @@
 // All material is licensed under the Apache License Version 2.0, January 2004
 // http://www.apache.org/licenses/LICENSE-2.0
 
-// Sample program to show how to declare and initialize a map
-// using a map literal and delete a key.
+// Sample program to show how maps behave when you read an
+// absent key.
 package main
 
 import "fmt"
 
-// user defines a user in the program.
-type user struct {
-	name    string
-	surname string
-}
-
 func main() {
 
-	// Declare and initialize the map with values.
-	users := map[string]user{
-		"Roy":     {"Rob", "Roy"},
-		"Ford":    {"Henry", "Ford"},
-		"Mouse":   {"Mickey", "Mouse"},
-		"Jackson": {"Michael", "Jackson"},
-	}
+	// Create a map to track scores for players in a game.
+	scores := make(map[string]int)
 
-	// Iterate over the map.
-	for key, value := range users {
-		fmt.Println(key, value)
-	}
+	// Read the element at key "anna". It is absent so we get
+	// the zero-value for this map's value type.
+	score := scores["anna"]
 
-	// Delete the Roy key.
-	delete(users, "Roy")
+	fmt.Println("Score:", score)
 
-	fmt.Println("=================")
+	// If we need to check for the presence of a key we use
+	// a 2 variable assignment. The 2nd variable is a bool.
+	score, ok := scores["anna"]
 
-	// Find the Roy key.
-	u, found := users["Roy"]
+	fmt.Println("Score:", score, "Present:", ok)
+
+	// We can leverage the zero-value behavior to write
+	// convenient code like this:
+	scores["anna"]++
+
+	// Without this behavior we would have to code in a
+	// defensive way like this:
+	if n, ok := scores["anna"]; ok {
+		scores["anna"] = n + 1
+	} else {
+		scores["anna"] = 1
+	}
 
-	// Display the value and found flag.
-	fmt.Println("Roy", found, u)
+	score, ok = scores["anna"]
+	fmt.Println("Score:", score, "Present:", ok)
 }

topics/go/language/maps/example3/example3.go

@@ -7,18 +7,18 @@ package main
 
 import "fmt"
 
-// user defines a user in the program.
+// user represents someone using the program.
 type user struct {
 	name    string
 	surname string
 }
 
-// users define a set of users.
+// users defines a set of users.
 type users []user
 
 func main() {
 
-	// Declare and make a map uses a slice of users as the key.
+	// Declare and make a map that uses a slice as the key.
 	u := make(map[users]int)
 
 	// ./example3.go:22: invalid map key type users

topics/go/language/maps/example4/example4.go

@@ -1,15 +1,13 @@
 // All material is licensed under the Apache License Version 2.0, January 2004
 // http://www.apache.org/licenses/LICENSE-2.0
 
-// Sample program to show how to walk through a map by alphabetical key order.
+// Sample program to show how to declare, initialize and iterate
+// over a map. Shows how iterating over a map is random.
 package main
 
-import (
-	"fmt"
-	"sort"
-)
+import "fmt"
 
-// user defines a user in the program.
+// user represents someone using the program.
 type user struct {
 	name    string
 	surname string
@@ -25,17 +23,16 @@ func main() {
 		"Jackson": {"Michael", "Jackson"},
 	}
 
-	// Pull the keys from the map.
-	var keys []string
-	for key := range users {
-		keys = append(keys, key)
+	// Iterate over the map printing each key and value.
+	for key, value := range users {
+		fmt.Println(key, value)
 	}
 
-	// Sort the keys alphabetically.
-	sort.Strings(keys)
+	fmt.Println()
 
-	// Walk through the keys and pull each value from the map.
-	for _, key := range keys {
-		fmt.Println(key, users[key])
+	// Iterate over the map printing just the keys.
+	// Notice the results are different.
+	for key := range users {
+		fmt.Println(key)
 	}
 }

topics/go/language/maps/example5/example5.go

@@ -0,0 +1,42 @@
+// All material is licensed under the Apache License Version 2.0, January 2004
+// http://www.apache.org/licenses/LICENSE-2.0
+
+// Sample program to show how to walk through a map by
+// alphabetical key order.
+package main
+
+import (
+	"fmt"
+	"sort"
+)
+
+// user represents someone using the program.
+type user struct {
+	name    string
+	surname string
+}
+
+func main() {
+
+	// Declare and initialize the map with values.
+	users := map[string]user{
+		"Roy":     {"Rob", "Roy"},
+		"Ford":    {"Henry", "Ford"},
+		"Mouse":   {"Mickey", "Mouse"},
+		"Jackson": {"Michael", "Jackson"},
+	}
+
+	// Pull the keys from the map.
+	var keys []string
+	for key := range users {
+		keys = append(keys, key)
+	}
+
+	// Sort the keys alphabetically.
+	sort.Strings(keys)
+
+	// Walk through the keys and pull each value from the map.
+	for _, key := range keys {
+		fmt.Println(key, users[key])
+	}
+}

topics/go/language/maps/example6/example6.go

@@ -0,0 +1,32 @@
+// All material is licensed under the Apache License Version 2.0, January 2004
+// http://www.apache.org/licenses/LICENSE-2.0
+
+// Sample program to show that you cannot take the address
+// of an element in a map.
+package main
+
+// player represents someone playing our game.
+type player struct {
+	name  string
+	score int
+}
+
+func main() {
+
+	// Declare a map with initial values using a map literal.
+	players := map[string]player{
+		"anna":  {"Anna", 42},
+		"jacob": {"Jacob", 21},
+	}
+
+	// Trying to take the address of a map element fails.
+	anna := &players["anna"]
+	anna.score++
+
+	// ./example4.go:23:10: cannot take the address of players["anna"]
+
+	// Instead take the element, modify it, and put it back.
+	player := players["anna"]
+	player.score++
+	players["anna"] = player
+}

topics/go/language/maps/example7/example7.go

@@ -0,0 +1,28 @@
+// All material is licensed under the Apache License Version 2.0, January 2004
+// http://www.apache.org/licenses/LICENSE-2.0
+
+// Sample program to show how maps are reference types.
+package main
+
+import "fmt"
+
+func main() {
+
+	// Initialize a map with values.
+	scores := map[string]int{
+		"anna":  21,
+		"jacob": 12,
+	}
+
+	// Pass the map to a function to perform some mutation.
+	double(scores, "anna")
+
+	// See the change is visible in our map.
+	fmt.Println("Score:", scores["anna"])
+}
+
+// double finds the score for a specific player and
+// multiplies it by 2.
+func double(scores map[string]int, player string) {
+	scores[player] = scores[player] * 2
+}