Stage 1 · Code

Functions & Composite Types

Defining Functions

Write functions that take inputs, produce outputs, and keep your code organized into reusable, readable pieces.

6 min readProgramming Foundations (Go)Code

Function Syntax

A function bundles a sequence of statements under a name so you can reuse them. In Go, every function starts with the func keyword, followed by the name, parameters in parentheses, optional return types, and a body in braces.

Goanatomy-of-a-go-function.go

14 linesLn 1, Col 1Go

The function name comes first, then the parameter list, then the return type. The body is everything inside the braces. `return` exits the function and sends the value back to the caller.

Functions are the primary unit of abstraction

In Go there are no classes. Functions, methods on types, and interfaces are how you organize behaviour. Start with plain functions; add methods and interfaces when the design calls for them.

Parameters and Arguments

Parameters are the names declared in the function signature. Arguments are the values passed in at the call site. Go passes all basic types and structs by value — the function gets a copy, not the original.

Goparameters,-types,-and-shorthand.go

27 linesLn 1, Col 1Go

Consecutive parameters of the same type share one annotation: `a, b int`. Variadic parameters (`...int`) collect all trailing arguments into a slice. Use `slice...` to spread a slice into a variadic call.

Return Values

A function with no return type returns nothing — it is called for its side effects. A function can return early from any point in its body, not only at the end.

Goearly-return-and-void-functions.go

25 linesLn 1, Col 1Go

Returning early for error or edge cases keeps the happy path at the outermost indent level, making functions easier to read from top to bottom.

Package-Level Visibility

In Go, capitalized names are exported (visible outside the package). Lowercase names are unexported (package-private). This rule applies to functions, types, variables, and constants.

Name	Visible from	Example
Exported	Any package that imports this one	`func Connect(...)` — public API
Unexported	Only within the same package	`func dial(...)` — implementation detail

Goexported-vs-unexported.go

15 linesLn 1, Col 1Go

Keeping implementation details unexported makes it safe to change them later without breaking other packages. Only expose what callers actually need.

Functions as Values

Functions in Go are first-class values. You can assign a function to a variable, pass it as an argument, or return it from another function. This enables flexible patterns like callbacks and middleware.

Gofunctions-stored-and-passed.go

20 linesLn 1, Col 1Go

The `func(int) int` type annotation in `apply`'s signature describes a function that takes an int and returns an int. Anonymous functions can capture variables from their enclosing scope — they are closures.

Keep functions small and focused

A function should do one thing and do it clearly. If you find yourself writing a long comment to explain what a function does, that is usually a signal to split it into smaller functions with self-documenting names.

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