Reading files requires checking most calls for errors. This helper will streamline our error checks below.

We can define methods on generic types just like we do on regular types, but we have to keep the type parameters in place. The type is `List[T]`, not

We'll be testing this simple implementation of an integer minimum. Typically, the code we're testing would be in a source file named something like `i

Here's a function that will take an arbitrary number of `int`s as arguments.

All returns an _iterator_, which in Go is a function with a [special signature](https://pkg.go.dev/iter#Seq).

Adding this `Error` method makes `argError` implement the `error` interface.

As an example of a generic function, `SlicesIndex` takes a slice of any `comparable` type and an element of that type and returns the index of the fir

Sometimes it's useful to know the runtime type of an interface value. One option is using a *type assertion* as shown here; another is a [type `switch

This function `intSeq` returns another function, which we define anonymously in the body of `intSeq`. The returned function _closes over_ the variable

If a variable has an interface type, then we can call methods that are in the named interface. Here's a generic `measure` function taking advantage of

transition emulates a state transition for a server; it takes the existing state and returns a new state.

The `(int, int)` in this function signature shows that the function returns 2 `int`s.

AllElements returns all the List elements as a slice. In the next example we'll see a more idiomatic way of iterating over all elements of custom type

This `area` method has a _receiver type_ of `*rect`.

By convention, errors are the last return value and have type `error`, a built-in interface.

This `fact` function calls itself until it reaches the base case of `fact(0)`.

Iteration doesn't require an underlying data structure, and doesn't even have to be finite! Here's a function returning an iterator over Fibonacci num

guessContentType guesses the HTTP content type appropriate for the given filename.

`handleConnection` handles a single client connection, reading one line of text from the client and returning a response.

This function panics.

`newPerson` constructs a new person struct with the given name.

Methods can be defined for either pointer or value receiver types. Here's an example of a value receiver.

This `ping` function only accepts a channel for sending values. It would be a compile-time error to try to receive on this channel.

Here's a function that takes two `int`s and returns their sum as an `int`.

When you have multiple consecutive parameters of the same type, you may omit the type name for the like-typed parameters up to the final parameter tha

The `pong` function accepts one channel for receives (`pings`) and a second for sends (`pongs`).

Here's the worker, of which we'll run several concurrent instances. These workers will receive work on the `jobs` channel and send the corresponding r

This is the function we'll run in every goroutine.

This is the function we'll run in a goroutine. The `done` channel will be used to notify another goroutine that this function's work is done.

`zeroptr` in contrast has an `*int` parameter, meaning that it takes an `int` pointer. The `*iptr` code in the function body then _dereferences_ the p

We'll show how pointers work in contrast to values with 2 functions: `zeroval` and `zeroptr`. `zeroval` has an `int` parameter, so arguments will be p

Benchmark tests typically go in `_test.go` files and are named beginning with `Benchmark`. Any code that's required for the benchmark to run but shoul

A test is created by writing a function with a name beginning with `Test`.

Writing tests can be repetitive, so it's idiomatic to use a *table-driven style*, where test inputs and expected outputs are listed in a table and a s

To implement an interface in Go, we just need to implement all the methods in the interface. Here we implement `geometry` on `rect`s.

The implementation for `circle`s.

A fundamental concept in `net/http` servers is *handlers*. A handler is an object implementing the `http.Handler` interface. A common way to write a h