Data Modeling Practice

Build a small contact list application that puts slices, maps, structs, and functions together into a working program.

8 min readProgramming Foundations (Go)Code

Design the Model

A contact list needs to store people, look them up by name or email, and list all entries. We will model this with a struct for a contact, a slice for ordering, and a map for fast lookup.

Gocontact-and-addressbook-types.go

34 linesLn 1, Col 1Go

The struct holds the slice for ordered storage and the map for O(1) email lookup. `New()` is a constructor function — a common Go pattern when zero values are not sufficient (the map would be nil without initialization).

Add and Lookup

Adding a contact inserts it into the slice and records its index in the lookup map. Duplicate emails are an error — the comma-ok idiom detects them in constant time.

Goadd-and-find-methods.go

59 linesLn 1, Col 1Go

Normalizing email to lowercase on entry means lookups are case-insensitive without any extra logic. Storing the slice index in the map means `Find` is O(1) — no linear scan needed.

Listing and Filtering

A List method returns all contacts in insertion order. A FindByTag method shows how to filter with a higher-order function — accept a predicate and apply it to every contact.

Golist-and-tag-filtering.go

70 linesLn 1, Col 1Go

`Filter` accepts any `func(Contact) bool` function — you can pass an anonymous function or a named predicate. This pattern is a lightweight alternative to query languages for small data sets.

Table-Driven Examples

Table-driven tests are the Go standard for verifying behaviour across many input/output pairs. Each row of the table is one scenario — the test loop runs them all automatically.

Gotable-driven-verification.go

68 linesLn 1, Col 1Go

Each test case captures one scenario — the email to look up, the expected error, and the expected name. The loop runs all three with zero duplication. This is the pattern you will use in `_test.go` files with `testing.T`.

What you built

The AddressBook combines every composite type from this module: a struct to model a contact, a slice to maintain insertion order, a map for O(1) lookup, and functions to add, retrieve, filter, and test behaviour. This is the Go way of building domain models — simple types, composed.

Mark this lesson complete to store local progress and unlock a cleaner resume path the next time you visit.

Stage 1 · Code

Functions & Composite Types