Closures in Go

package main

import (
    "fmt"
)

////////////////////////////////////////////////////////////

// Go uses escape analysis to determine that the local variable result should
// not be declared on the stack.
func twice(s string) *string {
    result := s + s // result is a local variable
    return &result  // return a pointer to the result
}

func test1() {
    fmt.Println(*twice("apple"))
    fmt.Println(*twice("down"))
}

////////////////////////////////////////////////////////////

// In Go, functions can returned functions. You can also pass functions as
// parameters to functions.
func makeGreeter1() func() {
    return func() {
        fmt.Println("Hello!")
    }
}

func test2() {
    greet := makeGreeter1()
    greet()
    greet()
}

////////////////////////////////////////////////////////////

func makeGreeter2(s string) func() {
    return func() {
        fmt.Println(s)
    }
}

func test3() {
    greet := makeGreeter2("Hi!")
    greet()
    greet()
}

////////////////////////////////////////////////////////////

func makeGreeter3() func(string) {
    return func(s string) {
        fmt.Println(s + "!")
    }
}

func test4() {
    greet := makeGreeter3()
    greet("Hey")
    greet("Hi")
}

////////////////////////////////////////////////////////////

// makeAdder1 returns a closure, i.e. a special value that contains a function
// *and* references to the free variables that are in the function. A closure
// can be called just like a function.
func makeAdder1() func() int {
    total := 0 // local variable
    inc := func() int {
        total++
        return total
    }

    return inc
}

func test5() {
    next := makeAdder1()
    fmt.Println(next())
    fmt.Println(next())
    fmt.Println(next())
}

////////////////////////////////////////////////////////////

// This example shows that two closures can share the same variable.
func makeAdder2() (func() int, func() int) {
    total := 0 // local variable

    inc := func() int {
        total++
        return total
    }

    dec := func() int {
        total--
        return total
    }

    return inc, dec
}

func test6() {
    next, prev := makeAdder2()
    fmt.Println(next())
    fmt.Println(prev())
    fmt.Println(next())
}

////////////////////////////////////////////////////////////

func makeAdder3() (func() int, func() int, func()) {
    total := 0 // local variable

    inc := func() int {
        total++
        return total
    }

    dec := func() int {
        total--
        return total
    }

    reset := func() {
        total = 0
    }

    return inc, dec, reset
}

func test7() {
    next, prev, reset := makeAdder3()
    fmt.Println(next())
    fmt.Println(prev())
    fmt.Println(next())
    reset()
    fmt.Println(next())
    fmt.Println(prev())
    fmt.Println(next())
}

////////////////////////////////////////////////////////////

// Closures are quite powerful, and could, for instance, be used to implemente
// a kind of object-oriented programming.
func makePerson(initName string, initAge int) (func(string), func() string, func(int), func() int) {
    name := initName
    age := initAge

    setName := func(s string) {
        if len(s) > 0 {
            name = s
        }
    }
    getName := func() string {
        return name
    }

    setAge := func(n int) {
        if n > 0 {
            age = n
        }
    }
    getAge := func() int {
        return age
    }

    return setName, getName, setAge, getAge
}

func test8() {
    setName, getName, setAge, getAge := makePerson("May", 11)
    fmt.Printf("%v, %v\n", getName(), getAge())
    setName("Irene")
    setAge(getAge() + 1)
    fmt.Printf("%v, %v\n", getName(), getAge())
}

////////////////////////////////////////////////////////////

func main() {
    // test1()
    // test2()
    // test3()
    // test4()
    // test5()
    // test6()
    // test7()
    test8()
}