Chapter 3: Functions and Methods

Defining Functions in Go

In Go, functions are defined using the func keyword, followed by the function name, parameters (if any), return type (if any), and the function body enclosed in curly braces {}. Here’s an example:

go

package main

import "fmt"

// Function definition with parameters and return type
func add(a, b int) int {
	return a + b
}

// Function definition with multiple return values
func divide(dividend, divisor float64) (float64, error) {
	if divisor == 0 {
		return 0, fmt.Errorf("division by zero error")
	}
	return dividend / divisor, nil
}

func main() {
	// Calling the add function
	sum := add(10, 20)
	fmt.Println("Sum:", sum)

	// Calling the divide function
	result, err := divide(100, 0)
	if err != nil {
		fmt.Println("Error:", err)
	} else {
		fmt.Println("Result:", result)
	}
}

Explanation:
- Function add: Defined with two parameters a and b of type int and returns their sum as an int.
- Function divide: Takes two parameters dividend and divisor of type float64. It returns a float64 result of the division and an error if divisor is zero.
- Function main: Entry point of the program. Calls add and divide functions and prints their results.

Calling Functions in Go

Functions in Go are called using their name followed by parentheses (), optionally passing arguments inside the parentheses if the function expects parameters. Here’s how you call functions in Go:

go

package main

import "fmt"

func main() {
	// Example 1: Calling a function with parameters and return value
	sum := add(10, 20)
	fmt.Println("Sum:", sum)

	// Example 2: Calling a function with multiple return values
	result, err := divide(100, 0)
	if err != nil {
		fmt.Println("Error:", err)
	} else {
		fmt.Println("Result:", result)
	}
}

// Function definition with parameters and return type
func add(a, b int) int {
	return a + b
}

// Function definition with multiple return values
func divide(dividend, divisor float64) (float64, error) {
	if divisor == 0 {
		return 0, fmt.Errorf("division by zero error")
	}
	return dividend / divisor, nil
}

Explanation:
- Calling add(10, 20): This call passes 10 and 20 as arguments to add, computes their sum (30), and assigns the result to sum.
- Calling divide(100, 0): This call attempts to divide 100 by 0. Since division by zero is invalid, divide returns an error (division by zero error), which is handled in the main function.

Key Points:

Functions in Go are defined using the func keyword, followed by the function name, parameters (if any), return type (if any), and the function body.
Function parameters must specify both the type and the name of each parameter (a, b int).
Functions can return multiple values ((float64, error)), making error handling more explicit and flexible.
Functions in Go are called by their names followed by parentheses, optionally passing arguments inside the parentheses if the function expects parameters.

Definition of Methods

Methods in Go are defined by attaching a function to a specific type. The syntax for defining a method is similar to that of defining functions, but with an added receiver parameter between the func keyword and the method name. The receiver parameter specifies the type that the method operates on. Here’s an example:

go

package main

import (
	"fmt"
	"math"
)

// Define a struct type named Circle
type Circle struct {
	radius float64
}

// Method area() associated with Circle type
func (c Circle) area() float64 {
	return math.Pi * c.radius * c.radius
}

// Method perimeter() associated with Circle type
func (c Circle) perimeter() float64 {
	return 2 * math.Pi * c.radius
}

func main() {
	// Create a Circle object with radius 5
	circle := Circle{radius: 5}

	// Call methods on the Circle object
	area := circle.area()
	perimeter := circle.perimeter()

	// Print the results
	fmt.Printf("Circle Area: %.2f\n", area)
	fmt.Printf("Circle Perimeter: %.2f\n", perimeter)
}

Explanation

Struct Definition (Circle):
- Circle is defined as a struct type with a single field radius of type float64.
Methods (area() and perimeter()):
- Methods are defined using the func keyword followed by the receiver parameter (c Circle) and the method name (area() and perimeter()).
- These methods operate on the Circle type and compute the area and perimeter of the circle using the math.Pi constant and the radius field of the Circle struct.
Main Function:
- In main(), a Circle object circle is created with a radius of 5.
- Methods area() and perimeter() are called on the circle object to compute the area and perimeter.
- Results are printed using fmt.Printf().

Key Points

Receiver Parameter: The receiver parameter (c Circle) binds the method to the Circle type. It acts like a method’s this or self in other languages.
Method Syntax: Methods are defined with the receiver parameter followed by the method name, optional parameters, and return types. They can have the same name but different receivers, allowing methods with identical names on different types.
Accessing Struct Fields: Inside methods, you can access the fields of the receiver struct (c.radius in the example).

Methods in Go enable you to encapsulate behavior specific to a type, promoting code organization and reusability. They are powerful constructs for building structured and maintainable Go programs.

Here are 10 examples demonstrating various aspects of methods in Go:

Example 1: Basic Method with Struct

go

package main

import "fmt"

// Define a struct type
type Rectangle struct {
    width  float64
    height float64
}

// Method to calculate area of Rectangle
func (r Rectangle) Area() float64 {
    return r.width * r.height
}

func main() {
    rect := Rectangle{width: 5, height: 3}
    fmt.Println("Area of rectangle:", rect.Area())
}

Example 2: Method with Pointer Receiver

go

package main

import "fmt"

// Define a struct type
type Circle struct {
    radius float64
}

// Method to update radius of Circle using a pointer receiver
func (c *Circle) SetRadius(newRadius float64) {
    c.radius = newRadius
}

func main() {
    circle := Circle{radius: 3}
    fmt.Println("Initial radius:", circle.radius)
    
    // Call method with pointer receiver
    circle.SetRadius(5)
    fmt.Println("Updated radius:", circle.radius)
}

Example 3: Method with Non-Struct Receiver

go

package main

import (
    "fmt"
    "math"
)

// Define a custom type for float64
type MyFloat float64

// Method to check if a float is negative
func (f MyFloat) IsNegative() bool {
    return f < 0
}

func main() {
    num := MyFloat(-5.7)
    fmt.Println("Is the number negative?", num.IsNegative())
}

Example 4: Methods with Multiple Parameters

go

package main

import "fmt"

// Define a struct type
type Rectangle struct {
    width  float64
    height float64
}

// Method to calculate area of Rectangle with another parameter
func (r Rectangle) Area(scaleFactor float64) float64 {
    return r.width * r.height * scaleFactor
}

func main() {
    rect := Rectangle{width: 5, height: 3}
    fmt.Println("Scaled area of rectangle:", rect.Area(1.5))
}

Example 5: Methods with Multiple Return Values

go

package main

import "fmt"

// Define a struct type
type Circle struct {
    radius float64
}

// Method to calculate area and circumference of Circle
func (c Circle) AreaAndCircumference() (float64, float64) {
    area := c.radius * c.radius * 3.14
    circumference := 2 * c.radius * 3.14
    return area, circumference
}

func main() {
    circle := Circle{radius: 5}
    area, circumference := circle.AreaAndCircumference()
    fmt.Printf("Area: %.2f, Circumference: %.2f\n", area, circumference)
}

Example 6: Method with Variadic Parameters

go

package main

import "fmt"

// Define a struct type
type Math struct{}

// Method to sum arbitrary number of integers
func (m Math) Sum(numbers ...int) int {
    sum := 0
    for _, num := range numbers {
        sum += num
    }
    return sum
}

func main() {
    math := Math{}
    fmt.Println("Sum:", math.Sum(1, 2, 3, 4, 5))
}

Example 7: Method with Named Return Values

go

package main

import "fmt"

// Define a struct type
type Rectangle struct {
    width  float64
    height float64
}

// Method to calculate area of Rectangle with named return values
func (r Rectangle) Area() (area float64) {
    area = r.width * r.height
    return
}

func main() {
    rect := Rectangle{width: 5, height: 3}
    fmt.Println("Area of rectangle:", rect.Area())
}

Example 8: Methods with Interface Types

go

package main

import (
    "fmt"
    "math"
)

// Define interface
type Shape interface {
    Area() float64
}

// Define struct types
type Circle struct {
    radius float64
}

type Rectangle struct {
    width  float64
    height float64
}

// Method to calculate area of Circle
func (c Circle) Area() float64 {
    return math.Pi * c.radius * c.radius
}

// Method to calculate area of Rectangle
func (r Rectangle) Area() float64 {
    return r.width * r.height
}

func main() {
    shapes := []Shape{
        Circle{radius: 5},
        Rectangle{width: 3, height: 4},
    }

    for _, shape := range shapes {
        fmt.Printf("Area of shape: %.2f\n", shape.Area())
    }
}

Example 9: Methods with Embedded Structs

go

package main

import "fmt"

// Define a struct type
type Person struct {
    firstName string
    lastName  string
    age       int
}

// Method for Person
func (p Person) Details() string {
    return fmt.Sprintf("%s %s is %d years old", p.firstName, p.lastName, p.age)
}

// Define another struct embedding Person
type Employee struct {
    Person
    salary float64
}

// Method for Employee
func (e Employee) Details() string {
    return fmt.Sprintf("%s and earns $%.2f", e.Person.Details(), e.salary)
}

func main() {
    emp := Employee{
        Person: Person{
            firstName: "John",
            lastName:  "Doe",
            age:       30,
        },
        salary: 50000,
    }
    fmt.Println(emp.Details())
}

Example 10: Methods with Pointer Receivers for Mutability

go

package main

import "fmt"

// Define a struct type
type Counter struct {
    count int
}

// Method to increment count using pointer receiver
func (c *Counter) Increment() {
    c.count++
}

// Method to get current count using value receiver
func (c Counter) Count() int {
    return c.count
}

func main() {
    counter := Counter{}
    counter.Increment()
    counter.Increment()
    fmt.Println("Current count:", counter.Count())
}

These examples cover various aspects of methods in Go, including basic method definitions, pointer receivers, interface methods, methods with variadic parameters, and more. Methods are a fundamental feature of Go that enable you to define behavior for types, promoting encapsulation and code reuse.

Higher-Order Functions

In Go, higher-order functions are functions that can either take other functions as arguments or return functions as their results. They enable functional programming paradigms, allowing for more flexible and modular code.

Function as a Parameter

You can define higher-order functions that accept other functions as parameters. This allows for dynamic behavior based on the function passed as an argument.

go

package main

import "fmt"

// Higher-order function that takes a function as a parameter
func applyOperation(num int, operation func(int) int) int {
    return operation(num)
}

// Function to square a number
func square(x int) int {
    return x * x
}

func main() {
    num := 5
    
    // Passing 'square' function as an argument
    squared := applyOperation(num, square)
    fmt.Printf("Square of %d is %d\n", num, squared)
}

Function as a Return Value

Higher-order functions can also create and return new functions, encapsulating behavior that varies based on conditions.

go

package main

import "fmt"

// Higher-order function that returns a function
func multiplier(factor int) func(int) int {
    return func(x int) int {
        return x * factor
    }
}

func main() {
    multiplyByTwo := multiplier(2)
    multiplyByThree := multiplier(3)
    
    fmt.Println("Multiply by 2:", multiplyByTwo(5))    // Output: 10
    fmt.Println("Multiply by 3:", multiplyByThree(5))  // Output: 15
}

Functions in Collections

Functions can be stored in collections like arrays or slices, allowing for iteration and dynamic function application.

go

package main

import "fmt"

// Define a type for a function that takes an int and returns an int
type IntOperation func(int) int

func main() {
    // Array of functions with the same signature
    operations := []IntOperation{
        func(x int) int { return x + 1 },
        func(x int) int { return x * 2 },
        func(x int) int { return x - 1 },
    }
    
    num := 5
    for _, op := range operations {
        result := op(num)
        fmt.Printf("Operation result: %d\n", result)
    }
}

Closures

Closures in Go are anonymous functions that can access and manipulate variables defined outside of their own scope. They allow for maintaining state across multiple function calls.

Basic Closure

A closure captures variables from its surrounding context, allowing the function to access those variables even after the outer function has finished executing.

go

package main

import "fmt"

func main() {
    // Define a closure that captures a variable from the outer scope
    message := "Hello, "
    greeting := func(name string) {
        fmt.Println(message + name)
    }
    
    // Call the closure
    greeting("John")  // Output: Hello, John
}

Closure with Mutable State

Closures can have mutable state, where variables declared in the outer function are accessible and modifiable by the closure.

go

package main

import "fmt"

func main() {
    // Closure with mutable state
    increment := func() func() int {
        count := 0
        return func() int {
            count++
            return count
        }
    }
    
    next := increment()
    fmt.Println(next())  // Output: 1
    fmt.Println(next())  // Output: 2
    fmt.Println(next())  // Output: 3
}

Using Closures in Iterations

Closures are often used in loops to capture the iteration variable, providing a unique context for each closure instance.

go

package main

import "fmt"

func main() {
    // Using closure in a loop
    var closures []func()
    for i := 0; i < 3; i++ {
        // Capture the loop variable in the closure
        closures = append(closures, func() {
            fmt.Println(i)
        })
    }
    
    // Call each closure
    for _, closure := range closures {
        closure()  // Outputs: 3, 3, 3 (due to closure capturing the final value of 'i')
    }
}

Closure with Anonymous Function

Closures can be defined directly as anonymous functions, allowing for immediate execution or delayed invocation.

go

package main

import "fmt"

func main() {
    // Closure with an anonymous function
    func() {
        msg := "Hello, World!"
        fmt.Println(msg)
    }()
}

Closure with Arguments

Closures can take arguments and return results, encapsulating behavior that can vary based on input parameters.

go

package main

import "fmt"

func main() {
    // Closure that takes arguments and returns a result
    multiplier := func(factor int) func(int) int {
        return func(x int) int {
            return x * factor
        }
    }
    
    multiplyByTwo := multiplier(2)
    fmt.Println("Multiply by 2:", multiplyByTwo(5))    // Output: 10
    
    multiplyByThree := multiplier(3)
    fmt.Println("Multiply by 3:", multiplyByThree(5))  // Output: 15
}

In conclusion, higher-order functions and closures in Go are essential features that enable functional programming styles and provide powerful mechanisms for building flexible and reusable code. They facilitate the creation of modular components, allow for dynamic behavior, and enhance the overall expressiveness of Go programs.

Tony's CodeForge Blog