Functions & Packages

Want to jump straight to the finished code? Run this in your terminal: git checkout 07-functions-and-packages-finish

1. Master Go Functions

Every basic Go function follows this exact blueprint: func name(parameters) returnType.

• Pro Tip: Notice a, b int? When neighboring parameters share the exact same type, you only have to write the type once at the end. It saves you from writing a int, b int.

Returning Multiple Values

Unlike many programming languages, Go functions can throw back more than one value at the same time. This is used everywhere in Go—especially for error handling.

Let's look at a function that calculates an average, but might fail if you give it no numbers:

When you call a function that returns multiple things, you catch them all at once using :=:

The Most Common Pattern in Go: The if err != nil check is the golden rule of Go. If a function might fail, it gives you a result and an error. If err is nil, everything went perfectly. If err is not nil, something broke, the result is junk, and you need to handle the issue.

What if I want to ignore a return value?

If you pass no inputs to Average(), it triggers an error. Because the calculated number is meaningless during an error, we can throw it away using the blank identifier (_):

Named Returns (Self-Documenting Code)

You can also give your return values actual names directly inside the function signature:

• Why do this? It instantly documents your code. Anyone looking at (min, max int) knows exactly what those two returned numbers represent without reading the actual logic.
• Note on "Bare" Returns: Named returns technically allow you to just type return without specifying variables. However, unless the function is tiny, it's always clearer to explicitly write return min, max.

Variadic Parameters (Infinite Arguments)

Look closely at the nums ...int parameter inside MinMax and Average. Those three dots (...) mean: "Accept as many arguments as the user wants to pass!"

You can call it with five numbers, zero numbers, or a hundred numbers:

Inside the function, Go automatically packages those inputs up into a standard slice ([]int) for you to loop through.

• Have an existing slice you want to pass? Simply add ... to the end of your slice variable to unpack it: mathx.MinMax(mySlice...).

2. Organizing Code with Packages

Think of a package as a labeled storage box. Everything inside that box can see and share code freely, but outside code can only use what the box explicitly allows.

The Golden Package Rules:

1. One Folder = One Package: Every single .go file sitting inside the same folder must declare the exact same package name at the top of the file.
2. Matching Names: While not a strict compiler rule, keeping your folder name and your package name identical (e.g., the mathx/ folder contains package mathx) makes your project incredibly easy to navigate.

Project Layout

Here is how our project directories are structured:

• package main is special. It tells Go that this isn't just a library—it's the entry point where the program executes func main().

Linking Packages Together

To map your packages, Go relies on two pieces of information:

To use your custom libraries inside main.go, point your import blocks directly to their Import Paths:

Once imported, call their functions by prefixing them with the package name:

3. Visibility: The Capitalization Rule

Go completely skips keywords like public or private. Instead, access control comes down to a single visual rule:

• Capital Letter = Exported (Public). Other packages are allowed to use it.

• Lowercase Letter = Unexported (Private). Only files inside the same package can use it.

Visibility Breakdown

This rule is universal across Go. It applies to variables, functions, types, constants, and custom fields.

Let's look at textx/format.go to see this in action:

• Label can call squeeze easily because they both live inside the textx package box.
• If you try to run textx.squeeze() inside main.go, Go will throw a compilation error because it starts with a lowercase letter.

4. Using External Dependencies

While Go has an incredible built-in standard library (like "strings" and "errors"), you will eventually want to use code written by other developers.

For instance, the built-in strings.Title was deprecated in Go 1.18 because it didn't handle non-ASCII characters well. The Go team provides a superior tool inside the external package golang.org/x/text.

How to Install External Code:

Open your terminal and run go get followed by the package path:

Running these commands does two things automatically:

1. go.mod Updates: Adds a require tracking line showing the exact version downloaded.
2. go.sum Creation: Generates a file containing secure cryptographic checksums to guarantee your downloads are safe and haven't been modified maliciously.

Note: Both of these files are managed by Go. Always commit them to version control, and never edit them by hand.

Implementing the Library

Now we can use the advanced casing library securely inside textx/format.go:

5. Running the Complete App

Now that our code is neatly split across main, mathx, and textx, run your application:

Expected Output

Look at how beautifully it works! Our empty Average() call safely surfaces our sentinel package error (mathx: no numbers given), and our Label call elegantly cleans up the messy spaced string into a clean title.

What's Next?

Now that you know how to package code and handle errors, we are ready to dive into control flow: if, for, and switch statements. Since you have already practiced the if err != nil pattern, the next chapter will feel like a natural next step!