While working with a new language you will always try to find some similarities with languages that you already know. I’m experienced in JavaScript and Java and can conclude that Go is more similar to JS. Why is that so? Well, in my opinion, this is because of the supporting some functional paradigm features. Pure functions It is a basic entity of functional programming. From wiki: the function return values are identical for identical arguments Here is an example of a pure function: func multiply(a, b int) int {
  return a * b
} Functions as First-Class Citizens According to the wiki, it means that: ; properties such as being able to be assigned to a variable, passed around as a function argument, returned from a function, etc. a given entity (such as a function) supports all the operational properties inherent to other entities We can return a function: package main

import "fmt"

func main() {
	myFunc := makeCounter()
	myFunc()
	myFunc()
}

func makeCounter() func() {
	counter := 0
	return func() {
		fmt.Println(counter)
		counter++
	}
} What should you notice here is that function not only returns a new anonymous function but also got a variable that saves in anonymous function lexical closure, just like in JavaScript. makeCounter In programming languages, a closure, also lexical closure or function closure, is . Operationally, a closure is a record storing a function together with an environment. a technique for implementing lexically scoped name binding in a language with first-class functions Wrapping At the time this article is written, Go doesn’t support generics through Go version 1.18 which will include support of generic types should be released in March 2022 Go 1.18 is not yet released. These are work-in-progress release notes. Go 1.18 is expected to be released in March 2022. Despite this fact you can also use some wrapper functions, for example, if you want to provide some data to the output while invoking certain functions like so: func multiply(a, b int) int {
	return a * b
}

func wrapWithLogs(fn func(a, b int) int) func(a,b int) int {
	return func(a, b int) int {
		start := time.Now()
		r := fn(a, b)
		duration := time.Since(start)
		fmt.Println("function took ", duration)
		return r
	}
} Of course, it will be much more effective using generics. So we need just to wait for a while until the new release will be published :) If you want to get the name of the function dynamically you can also use: runtime.FuncForPC(reflect.ValueOf(fn).Pointer()).Name() Wrapping opens a door to use some cool things like memoization Memoization In computing, memoization or memoisation is . an optimization technique used primarily to speed up computer programs by storing the results of expensive function calls and returning the cached result when the same inputs occur again Like it said, if you have some heavy calculation - it is always better to cache already computed results somewhere and use them instead of doing the same calculation again. func sum(a,b int) int {
	return a + b
}

func memo(fn func(a, b int) int) func(a, b int) int {
	cache := make(map[string]int)
	return func(a, b int) int {
		key := strconv.Itoa(a) + " " + strconv.Itoa(b)
		v, ok := cache[key]
		if !ok {
			fmt.Println("calculating...")
			cache[key] = fn(a, b)
			v = cache[key]
		}
		return v
	}
}

func main() {
	mSum := memo(sum)
	fmt.Println(mSum(2, 3))
	fmt.Println(mSum(2, 3))
} The result will be: calculating... 5 5 Of course, you can avoid wrapper function and write memorization logic directly inside your function. But still you will use closure to store cache inside. Recursion We can use recursion if we need to calculate something like factorial: func funcFactorial(num int) int {
	if num == 0 {
		return 1
	}
	return num * funcFactorial(num-1)
} But please be aware of using recursion whenever possible. The problem is that in most cases it is better to use some stack or queue instead of recursion. Usually, limits of memory lie further than the limits of the call stack. Currying Remember we discussed closure in the first example? Currying is about taking a parameter and returning it in a closure. For example, we got a function multiply: func multiply(a, b int) int {
  return a * b
} We can call this function like . With currying, we can call this function in a way . To do that we need to rewrite our main function: multiply(2, 3) multiply(2)(3) func multiply(a int) func(b int) int {
  return func(b int) int {
    return a * b
  }
} But rewriting existing function just to use currying is not a good practice. Using some wrapper function we can do it in a better way: func multiply(a, b int) int {
	return a * b
}

func curry(a int) func(b int) int {
	return func(b int) int {
		return multiply(a, b)
	}
} Conclusion Go supports some features of the functional paradigm to make things easier. But don’t forget that it is structural language and there is no need to try to write Go code in Functional or OOP style. You will lose in both cases.

2022 - HackerNoon Contributor of the Year - Functional Programming

2022 - HackerNoon Contributor of the Year - Golang

Nominated for 2022 - HackerNoon Contributor of the Year - Golang

Nominated for 2022 - HackerNoon Contributor of the Year - Functional Programming

Too Long; Didn't Read

In your car, at home, or at work — Bosch technology shapes many areas of life.

Practice with Functional Programming in Go

Too Long; Didn't Read

Georgii Kliukovkin

About Author

TOPICS

THIS ARTICLE WAS FEATURED IN...

Practice with Functional Programming in Go

Too Long; Didn't Read

Georgii Kliukovkin

About Author

TOPICS

THIS ARTICLE WAS FEATURED IN...

RELATED STORIES