1. Maps

Maps are similar to JavaScript objects, Python dictionaries, and Ruby hashes. Maps are a data structure that provides key->value mapping.

The zero value of a map is nil.

We can create a map by using a literal or by using the make() function:

example.go

ages := make(map[string]int)
ages["John"] = 37
ages["Mary"] = 24
ages["Mary"] = 21 // overwrites 24

literal.go

ages = map[string]int{
  "John": 37,
  "Mary": 21,
}

The len() function works on a map, it returns the total number of key/value pairs.

len.go

ages = map[string]int{
  "John": 37,
  "Mary": 21,
}
fmt.Println(len(ages)) // 2

Assignment

We can speed up our contact-info lookups by using a map!

• Key-based map lookup: O(1)

• Slice brute-force search: O(n)

Complete the getUserMap function. It takes a slice of names and a slice of phone numbers, and returns a map of name -> user structs and an error. A user struct just contains a user's name and phone number. The first element in the names slice pairs with the first phone number, and so on.

If the length of names and phoneNumbers is not equal, return an error with the string "invalid sizes".

Solution

func getUserMap(names []string, phoneNumbers []int) (map[string]user, error) {
    // Step 1: Create empty map (name -> user struct)
    result := make(map[string]user)
    
    // Step 2: Validation - check if arrays are same length
    if len(names) != len(phoneNumbers) {
        return nil, errors.New("invalid sizes")  // Return error, no map
    }
    
    // Step 3: Loop through names (i gives us index to match phone numbers)
    for i, name := range names {
        // Step 4: Create a user struct with both name and phone
        result[name] = user{
            name:        name,                // The name
            phoneNumber: phoneNumbers[i],     // The matching phone number
        }
    }
    
    // Step 5: Return the completed map and nil (no error)
    return result, nil
}

You need to create a user struct that contains both the name and phone number:

result[pair] = user{
    name:        pair,
    phoneNumber: phoneNumbers[i],
}

Understanding the User Struct

type user struct {
    name        string
    phoneNumber int
}

Think of this like a Python class:

class User:
    def __init__(self, name, phone_number):
        self.name = name
        self.phone_number = phone_number

To create a new user in Go:

newUser := user{
    name:        "John",
    phoneNumber: 1234567,
}

The Corrected Solution

func getUserMap(names []string, phoneNumbers []int) (map[string]user, error) {
    result := make(map[string]user)
    
    if len(names) != len(phoneNumbers) {
        return nil, errors.New("invalid sizes")
    }
    
    for i, name := range names {
        result[name] = user{
            name:        name,
            phoneNumber: phoneNumbers[i],
        }
    }
    
    return result, nil
}

1

Step-by-step algorithm

• Create an empty map: result := make(map[string]user)

• If the lengths differ, return nil and errors.New("invalid sizes")

• Loop over names with index i; for each name create a user with name and phoneNumbers[i]

• Assign into the map: result[name] = user{...}

• Return result, nil

2

Example trace

Given:

names = ["Alice", "Bob"]
phoneNumbers = [1234, 5678]

Iteration 1 (i=0, name="Alice"):

result["Alice"] = user{
    name:        "Alice",
    phoneNumber: 1234,
}

After iteration 1:

result = {
    "Alice": user{name: "Alice", phoneNumber: 1234}
}

Iteration 2 (i=1, name="Bob"):

result["Bob"] = user{
    name:        "Bob",
    phoneNumber: 5678,
}

After iteration 2:

result = {
    "Alice": user{name: "Alice", phoneNumber: 1234},
    "Bob":   user{name: "Bob", phoneNumber: 5678},
}

Return: result, nil

Python Comparison

Go:

result := make(map[string]user)
result["Alice"] = user{
    name:        "Alice",
    phoneNumber: 1234,
}

Python equivalent:

result = {}
result["Alice"] = User(
    name="Alice",
    phone_number=1234
)

# Or with a dict instead of a class:
result["Alice"] = {
    "name": "Alice",
    "phone_number": 1234
}

Understanding Maps in Go

Creating a Map

Method 1: Using make

myMap := make(map[string]int)
myMap["key1"] = 10
myMap["key2"] = 20

Method 2: Using a literal

myMap := map[string]int{
    "key1": 10,
    "key2": 20,
}

Python equivalent:

my_map = {
    "key1": 10,
    "key2": 20
}

Accessing Map Values

value := myMap["key1"]  // Gets the value

Python:

value = my_map["key1"]

Adding/Updating Map Values

myMap["key3"] = 30  // Adds new key-value pair
myMap["key1"] = 15  // Updates existing value

Python:

my_map["key3"] = 30
my_map["key1"] = 15

Why Return nil for the Map?

When there's an error, you return:

return nil, errors.New("invalid sizes")

• nil is Go's equivalent of Python's None

• Since we can't create a valid map, we return nil (nothing)

• The caller will check the error and won't use the map if there's an error

Python equivalent:

return None, Exception("invalid sizes")

Complete Annotated Solution

func getUserMap(names []string, phoneNumbers []int) (map[string]user, error) {
    // Step 1: Create empty map (name -> user struct)
    result := make(map[string]user)
    
    // Step 2: Validation - check if arrays are same length
    if len(names) != len(phoneNumbers) {
        return nil, errors.New("invalid sizes")  // Return error, no map
    }
    
    // Step 3: Loop through names (i gives us index to match phone numbers)
    for i, name := range names {
        // Step 4: Create a user struct with both name and phone
        result[name] = user{
            name:        name,                // The name
            phoneNumber: phoneNumbers[i],     // The matching phone number
        }
    }
    
    // Step 5: Return the completed map and nil (no error)
    return result, nil
}

Key Takeaway

When your map's value is a struct, you need to create the whole struct:

// ❌ Wrong: trying to assign just an int
result[name] = phoneNumbers[i]

// ✅ Correct: creating a complete user struct
result[name] = user{
    name:        name,
    phoneNumber: phoneNumbers[i],
}

Further Explanation

result = The Container (The Dictionary Itself)

result := make(map[string]user)
^^^^^^^
   |
   └─ This is a VARIABLE NAME (you chose this name)
      It holds the entire map/dictionary

Python equivalent:

result = {}
^^^^^^^
   |
   └─ Variable name for your dictionary

user = The Type of Data Being Stored (What Goes IN the Dictionary)

map[string]user
           ^^^^
             |
             └─ This is a TYPE (defined by the assignment)
                It describes what kind of values the map holds

Python equivalent:

result: dict[str, User] = {}
                  ^^^^
                    |
                    └─ The type of values in the dict

Visual Breakdown

result := make(map[string]user)
^^^^^^         ^^^^^^^^^^^^^^^^
  |                   |
  |                   └─ The TYPE of the map
  |                      "a map with string keys and user values"
  |
  └─ The VARIABLE NAME
     "I'm calling this map 'result'"

Concrete Example with Different Names

// The struct type (defined once)
type user struct {
    name        string
    phoneNumber int
}

// Now create a map with ANY name you want:
phoneBook := make(map[string]user)
^^^^^^^^^^                     ^^^^
    |                            |
 variable name              value type (must be user)


// Or call it something else:
contacts := make(map[string]user)
^^^^^^^^^                   ^^^^
    |                        |
variable name           value type (must be user)


// Or even:
myAwesomeMap := make(map[string]user)
^^^^^^^^^^^^^                   ^^^^
    |                            |
variable name              value type (must be user)

The variable name (result, phoneBook, contacts) is YOUR choice. The type (user) is REQUIRED by the map definition.

Putting It All Together

result[name] = user{
^^^^^^         ^^^^
  |              |
  |              └─ TYPE: Creating a new instance of type "user"
  |
  └─ VARIABLE: The map we're adding to

This is like:

result[name] = user{...}
     ^         ^
     |         |
     |         └─ "Create a user object"
     |
     └─ "Put it in the result map"

Python Analogy

Python with a class:

class User:
    def __init__(self, name, phone_number):
        self.name = name
        self.phone_number = phone_number

# result = the dictionary variable
result = {}

# User = the class type
result["Alice"] = User(name="Alice", phone_number=1234)
^^^^^^^           ^^^^
   |                |
variable name    class name (type)

Python with just dicts (simpler):

result = {}
^^^^^^^
   |
   └─ Variable: the dictionary

result["Alice"] = {"name": "Alice", "phone": 1234}
                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
                              |
                         A dictionary value

In Go, you can't just use {"name": "Alice", "phone": 1234} directly. You need to define a struct type first (user), then create instances of it.

Side-by-Side Comparison

Concept	In Your Code	What It Is
Variable name	result	The map/dictionary you're building
Key type	string	Names are strings
Value type	user	Each value is a user struct
Creating a value	user{...}	Making a new user to put in the map

Another Example to Clarify

// Define a type called "car"
type car struct {
    make  string
    model string
    year  int
}

// Create a map (dictionary) called "garage"
garage := make(map[string]car)
^^^^^^^                    ^^^
   |                        |
variable name          value type

// Add cars to the garage
garage["slot1"] = car{
^^^^^^^           ^^^
   |               |
the map          create a car object

• garage = your variable (the dictionary)

• car = the type of things you're storing in it

• car{...} = creating a new car object

Key Takeaway

result := make(map[string]user)
^^^^^^^                     ^^^^
   |                          |
YOU chose this name      ASSIGNMENT requires this type
(could be anything)      (must match the struct)

result["Alice"] = user{name: "Alice", phoneNumber: 1234}
^^^^^^^           ^^^^
   |               |
Variable          Type (constructor)

• result is like saying "the notebook" - it's the container

• user is like saying "a person entry" - it's what you write in the notebook