feat: maps

Author: ADGEfficiency

languages/go.md

@@ -257,6 +257,18 @@ Deleting from a map:
 delete()
 ```
 
+Never initialize a nil map - writing to a nil map will cause runtime panic.  This is because the variable `m` is initialized to `nil`:
+
+```go
+var m map[string]string
+```
+
+Instead initialize an empty map:
+
+```go
+m := make(map[string]string)
+```
+
 ## Iteration
 
 There are only `for` loops in Go (no `while`).

learn-go-with-tests/7-maps/dict.go

@@ -0,0 +1,54 @@
+package dict
+
+const (
+	ErrNotFound         = DictionaryError("could not find the word you were looking for")
+	ErrWordExists       = DictionaryError("word already exists")
+	ErrWordDoesNotExist = DictionaryError("word doesn't exist")
+)
+
+type DictionaryError string
+
+func (e DictionaryError) Error() string {
+	return string(e)
+}
+
+type Dictionary map[string]string
+
+func (d Dictionary) Search(word string) (string, error) {
+	definition, ok := d[word]
+	if !ok {
+		return "", ErrNotFound
+	}
+	return definition, nil
+}
+
+func (d Dictionary) Add(word, definition string) error {
+	_, err := d.Search(word)
+
+	switch err {
+	case ErrNotFound:
+		d[word] = definition
+	case nil:
+		return ErrWordExists
+	default:
+		return err
+	}
+	return nil
+}
+
+func (d Dictionary) Update(word, definition string) error {
+	_, err := d.Search(word)
+	switch err {
+	case ErrNotFound:
+		return ErrWordDoesNotExist
+	case nil:
+		d[word] = definition
+	default:
+		return err
+	}
+	return nil
+}
+
+func (d Dictionary) Delete(word string) {
+	delete(d, word)
+}

learn-go-with-tests/7-maps/dict_test.go

@@ -0,0 +1,88 @@
+package dict
+
+import "testing"
+
+func assertString(t *testing.T, got, want string) {
+	if got != want {
+		t.Errorf("got %q want %q", got, want)
+	}
+}
+
+func assertError(t *testing.T, got, want error) {
+	if got != want {
+		t.Errorf("got %q want %q", got, want)
+	}
+}
+
+func TestSearch(t *testing.T) {
+
+	dict := Dictionary{"test": "a test"}
+	t.Run("known word", func(t *testing.T) {
+		got, _ := dict.Search("test")
+		want := "a test"
+		assertString(t, got, want)
+	})
+
+	t.Run("unknown word", func(t *testing.T) {
+		_, err := dict.Search("unknown")
+		if err == nil {
+			t.Fatal("expected to get an error")
+		}
+		assertError(t, err, ErrNotFound)
+	})
+}
+
+func TestAdd(t *testing.T) {
+	t.Run("new word", func(t *testing.T) {
+		dict := Dictionary{}
+		dict.Add("neu", "word")
+		want := "word"
+		got, err := dict.Search("neu")
+		if err != nil {
+			t.Fatal("should find added word: ", err)
+		}
+		assertString(t, want, got)
+	})
+
+	t.Run("existing word", func(t *testing.T) {
+		dict := Dictionary{}
+		dict.Add("neu", "word")
+		got, _ := dict.Search("neu")
+		err := dict.Add("neu", "word again")
+
+		assertString(t, got, "word")
+		assertError(t, err, ErrWordExists)
+	})
+}
+
+func TestUpdate(t *testing.T) {
+	t.Run("existing word", func(t *testing.T) {
+		word := "test"
+		dict := Dictionary{}
+		dict.Add(word, "definition")
+		dict.Update(word, "new definition")
+		got, _ := dict.Search(word)
+		assertString(t, got, "new definition")
+	})
+
+	t.Run("new word", func(t *testing.T) {
+		word := "test"
+		dict := Dictionary{}
+		err := dict.Update(word, "new definition")
+		assertError(t, err, ErrWordDoesNotExist)
+	})
+}
+
+func TestDelete(t *testing.T) {
+	t.Run("existing word", func(t *testing.T) {
+		word := "test"
+		dict := Dictionary{}
+		dict.Add(word, "definition")
+		dict.Delete(word)
+		_, err := dict.Search(word)
+		if err == nil {
+			t.Fatal("expected to get an error")
+		}
+		assertError(t, err, ErrNotFound)
+	})
+}