Function as First Class Citizen in Go: Code like a Pro with 5 Simple use cases

Introduction

Function as first class citizen is a key feature in Go, allowing us to use function powerfully. It can elevate our coding skills to great heights.

In the Go programming language, functions are treated as first-class citizens, which means they can be assigned to variables, passed as arguments to other functions, returned as values from functions, and stored in data structures. This flexibility allows for powerful and elegant programming constructs. Let’s explore this concept more comprehensively:

Below is a mind-map representation of a function as a first-class citizen in Go.

Examples of function as first class citizen in go

Functions as Values

In Go, functions are treated like any other value such as integers, strings, or structs. They can be assigned to variables and manipulated just like any other data type. This flexibility makes function as first class citizen in go.

Assigning Functions to Variables:

package main

import (
    "fmt"
)

func greet() {
    fmt.Println("Hello, there!")
}

func main() {
    var myFunc func() // Declare a variable of function type

    myFunc = greet // Assign the greet function to myFunc variable

    myFunc() // Call myFunc, which invokes the greet function
}

Passing Functions as Arguments (function as first class citizen)

Functions can be passed as arguments to other functions, enabling higher-order functions and functional programming paradigms.

Function as Argument Example:

package main

import (
    "fmt"
)

func sayHello(name string) {
    fmt.Println("Hello,", name)
}

func processGreeting(greetFunc func(string), name string) {
    greetFunc(name)
}

func main() {
    processGreeting(sayHello, "Alice")
}

Returning Functions from Functions (function as first class citizen)

In Go, functions can return other functions, allowing for the creation of closures and more advanced functional patterns.

Returning Functions Example:

package main

import (
    "fmt"
)

func getGreetFunction() func(string) {
    greeting := "Hola" // Local variable accessible in the returned function

    greet := func(name string) {
        fmt.Println(greeting, name)
    }

    return greet
}

func main() {
    greetFunc := getGreetFunction()
    greetFunc("Maria") // Prints "Hola Maria"
}

Storing Functions in Data Structures (function as first class citizen)

Functions can be stored in data structures like slices, maps, or structs, providing flexibility in managing and accessing them.

Storing Functions in a Map:

package main

import (
    "fmt"
)

func greetInEnglish(name string) {
    fmt.Println("Hello,", name)
}

func greetInSpanish(name string) {
    fmt.Println("Hola,", name)
}

func main() {
    greetings := map[string]func(string){
        "english": greetInEnglish,
        "spanish": greetInSpanish,
    }

    greetings["english"]("Alice") // Prints "Hello, Alice"
    greetings["spanish"]("Maria") // Prints "Hola, Maria"
}

Function having method (function as first class citizen)

Most of us would be familiar with the below code

package main

import (
	"fmt"
	"net/http"
)

func greetHandler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "Welcome to the greeting page!") // Sending a response to the client
}

func main() {
	http.HandleFunc("/greet", greetHandler)

	fmt.Println("Server running at port 8080...")
	http.ListenAndServe(":8080", nil) // Starting the server
}

In the above example, greetHandler is a HandlerFunc (which is a type defined as type HandlerFunc func(w http.ResponseWriter, r *http.Request)), but how do requests with router /greet are handled by greetHandler? Let us understand this.

In the above code, we are using the DefaultServeMux router since the handler is nil. The DefaultServeMux acts as a router that directs incoming HTTP requests to the appropriate handler based on the registered patterns, It works by calling the ServeHTTP method on Handler or HandlerFunc. HandlerFunc implements the Handler interface as below.

// Handler interface
type Handler interface {
  func ServeHTTP(w http.ResponseWriter, r *http.Request)
}

type HandlerFunc func(ResponseWriter, *Request)

// ServeHTTP calls f(w, r).
func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
    f(w, r)
}

Normally we see that methods are associated with structs but in the above code, HandlerFunc which is a type on function (func(ResponseWriter, *Request)) has the ServeHTTP method.

Conclusion

In conclusion, Go’s treatment of functions as first class citizens empowers developers to embrace functional programming paradigms, fostering the creation of modular, adaptable, and expressive solutions. This approach, enabling the seamless passing, returning, assignment, and storage of functions, significantly expands the language’s capabilities. Such flexibility not only enhances reusability and logic conciseness but also facilitates the development of dynamic and sophisticated applications.

By integrating functions seamlessly into the codebase, Go encourages cleaner, maintainable, and scalable software architectures. This foundational principle underscores the language’s elegance and efficiency, driving the construction of robust, innovative, and future-ready software solutions. Ultimately, Go’s embrace of first-class functions is a cornerstone for building intricate yet comprehensible software, empowering developers to craft cutting-edge applications with ease and precision.