Challenge 3 — Solution

Task: Using the Stack[T any] type from this chapter, create a
Stack[string], push 3 names onto it, then pop and print all 3 (which
should come back out in reverse order).

package main

import "fmt"

type Stack[T any] struct {
	items []T
}

func (s *Stack[T]) Push(item T) {
	s.items = append(s.items, item)
}

func (s *Stack[T]) Pop() T {
	last := s.items[len(s.items)-1]
	s.items = s.items[:len(s.items)-1]
	return last
}

func main() {
	names := &Stack[string]{}

	names.Push("Alice")
	names.Push("Bob")
	names.Push("Carl")

	fmt.Println(names.Pop())
	fmt.Println(names.Pop())
	fmt.Println(names.Pop())
}


Expected output:

Carl
Bob
Alice

Notes:
- A stack is "last in, first out" — Carl was pushed last, so Carl is
  popped first; this is why the output comes back in the REVERSE
  order the names were pushed.
- &Stack[string]{} creates a pointer to a new Stack, needed because
  Push and Pop both use pointer receivers (*Stack[T]) so they can
  actually modify the underlying items slice.
- Stack[string] fixes T as string for this particular stack — a
  separate Stack[int] would be a completely different, equally
  type-safe instantiation of the same generic type.