[Part 1](https://eazymock.net/blogs/functional-programming-where-bugs-become-elegant-puzzles-sW3YH7gQbn)
[Part 2](https://eazymock.net/blogs/functional-programming-where-bugs-become-elegant-puzzles-part-2-yMpZavj0z5)

## Example 4: Fully Functional using `IBM/fp-go` package

The `IBM/fp-go` package provides a set of utilities to write fully functional code in Go. Let's see how we can use this package to implement the following example:

```go
type User struct {
	ID     string `json:"id"`
	Name   string `json:"name"`
	Phone  string `json:"phone"`
	RoleID int    `json:"role_id"`

	Role string `json:"role"`
}

type Role struct {
	ID   int    `json:"id"`
	Name string `json:"name"`
}

const APIEnpoint = "https://api.eazymock.net/mock/5abdcf75-2345-4df6-ba62-1fb040f632eb/126/"

// getUsers fetches users from the API
func getUsers(endpoint string) ([]User, error) {
	resp, err := http.Get(endpoint + "users")
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	var users []User
	if err := json.NewDecoder(resp.Body).Decode(&users); err != nil {
		return nil, err
	}

	return users, nil
}

// getRoles fetches roles from the API
func getRoles(endpoint string) ([]Role, error) {
	resp, err := http.Get(endpoint + "roles")
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	var roles []Role
	if err := json.NewDecoder(resp.Body).Decode(&roles); err != nil {
		return nil, err
	}

	return roles, nil
}

func main() {
	// Get users from API
	users, err := getUsers(APIEnpoint)
	if err != nil {
		fmt.Println(err)
		return
	}

	// Get roles from API
	roles, err := getRoles(APIEnpoint)
	if err != nil {
		fmt.Println(err)
		return
	}

    // Add role to users
	roleMap := make(map[int]string)
	for _, role := range roles {
		roleMap[role.ID] = role.Name
	}

	var newUsers []User
	for _, user := range users {
		user.Role = roleMap[user.RoleID]
		newUsers = append(newUsers, user)
	}

	// print the result
	data, _ := json.MarshalIndent(newUsers, "", "  ")
	fmt.Println(string(data))
}
```

In this example, we fetch users and roles from an API, map roles to users, and print the result. I'm using [EazyMock](https://eazymock.net/) to simulate the API responses. [EazyMock](https://eazymock.net/) is a free online tool that allows you to mock APIs for testing and development purposes. It allows you to define API endpoints and responses, making it easy to test your code without relying on real APIs. It also provides AI-powered mock generation, making it easy to create mock APIs quickly.

Now, let's rewrite the same logic using the `IBM/fp-go` package:

```go
type User struct {
	ID     string `json:"id"`
	Name   string `json:"name"`
	Phone  string `json:"phone"`
	RoleID int    `json:"role_id"`

	Role string `json:"role"`
}

type Role struct {
	ID   int    `json:"id"`
	Name string `json:"name"`
}

const APIEnpoint = "https://api.eazymock.net/mock/5abdcf75-2345-4df6-ba62-1fb040f632eb/126/"

func main() {
    // Create a new HTTP client
	client := H.MakeClient(http.DefaultClient)

    // 5-step pipeline to fetch users, roles, map roles to users, and print the result
	data := F.Pipe5(
        // Create a tuple of API endpoints
		T.MakeTuple2(APIEnpoint+"users", APIEnpoint+"roles"),
        // Make GET requests to fetch users and roles
		T.Map2(H.MakeGetRequest, H.MakeGetRequest),
        // Read JSON responses
		R.TraverseTuple2(
			H.ReadJSON[[]User](client),
			H.ReadJSON[[]Role](client),
		),
        // Chain to add roles to users
		R.Chain(func(t T.Tuple2[[]User, []Role]) R.ReaderIOEither[T.Tuple1[[]User]] {
			return F.Pipe2(
                // Create a map of role IDs to role names
				T.Of(getUserRoleMap(t.F2)),
                // Map roles to users
				T.Map1(func(roleMap map[int]string) []User {
					return addRoleToUsers(t.F1, roleMap)
				}),
				R.Of,
			)
		}),
        // Marshal the result to JSON
		R.Chain(func(t T.Tuple1[[]User]) R.ReaderIOEither[string] {
			data, _ := json.MarshalIndent(t.F1, "", "  ")
			return R.Of(string(data))
		}),
        // Print the result
		R.ChainFirstIOK(IO.Printf[string]("%v\n")),
	)

	result := data(context.Background())
	result()

}

// getUserRoleMap creates a map of role IDs to role names
func getUserRoleMap(roles []Role) map[int]string {
	roleMap := make(map[int]string)
	for _, role := range roles {
		roleMap[role.ID] = role.Name
	}
	return roleMap
}

// addRoleToUsers adds roles to users
func addRoleToUsers(users []User, roleMap map[int]string) []User {
	var newUsers []User
	for _, user := range users {
		user.Role = roleMap[user.RoleID]
		newUsers = append(newUsers, user)
	}
	return newUsers
}
```

The code may looks a bit complex at first, but it's more functional and composable. If you're familiar with the `fp-ts` library in TypeScript, you'll find the `IBM/fp-go` package quite similar. It provides a set of utilities to write fully functional code in Go, making it easier to manage side effects, error handling, and data transformations in a predictable and composable way.

[[Try it on Go playground](https://goplay.tools/snippet/nkxUS4oom3r)]

## Why Functional Programming?

Functional Programming offers several benefits that make it an attractive paradigm for software development:

- **Semantic Clarity**: FP emphasizes writing code that is more declarative and expressive, making it easier to understand and maintain.

- **Safer Programs**: By minimizing side effects and mutable state, FP reduces the likelihood of bugs and unintended consequences in your code.

- **Concise Code**: FP encourages writing code that is more declarative and expressive, leading to shorter, more readable programs.

- **Easier Debugging & Testing**: Pure functions and immutability make it easier to reason about and test your code, leading to more robust and reliable software.

- **Concurrency**: FP simplifies concurrent programming by eliminating shared mutable state, making it easier to write parallel and distributed systems.

By embracing Functional Programming principles, developers can write code that is more elegant, maintainable, and scalable, ultimately leading to more efficient and reliable software systems.

## Drawbacks

While Functional Programming offers many benefits, it also has some drawbacks that developers should be aware of:

- **Performance**: Functional Programming can sometimes lead to performance issues due to the overhead of creating new data structures and the lack of in-place updates.

- **Not 100% Functional**: It's challenging to write fully functional code in languages like Go, which are not purely functional. You may need to compromise on some functional principles to work within the language's constraints.

- **Idiomatic Go**: Functional Programming may not always align with idiomatic Go practices. Writing purely functional code in Go can sometimes feel unnatural or verbose.

- **Lack of Syntactic Sugar**: Functional Programming can be more verbose than imperative programming, especially in languages like Go that lack syntactic sugar for functional constructs.

## When to Use Functional Programming?

Functional Programming is well-suited for a wide range of scenarios, including:

- **When Performance is Not Critical**: If performance is not a primary concern, Functional Programming can be an excellent choice for writing clear, maintainable, and reliable code.

- **Whenever Possible**: Functional Programming can be used whenever possible, even in languages like Go that are not purely functional. Leveraging functional constructs can lead to more elegant and efficient code.

- **Utilize Libraries**: Functional Programming libraries and utilities can help you write more functional code in languages like Go. By leveraging existing tools and libraries, you can embrace FP principles without reinventing the wheel. Some popular libraries for Go include `IBM/fp-go`, `samber/lo`, and `samber/mo`.

## Misconceptions

Functional Programming is often misunderstood due to several misconceptions:

- **Syntactic Sugar**: Functional Programming is sometimes dismissed as mere syntactic sugar or a coding style. In reality, FP is a paradigm that fundamentally alters how we approach software development.

- **Complicated**: Functional Programming is often perceived as complex and difficult to learn. While it may require a shift in mindset, the core concepts of FP are intuitive and can lead to more elegant and maintainable code.

- **Never Side-Effects**: Functional Programming does not eliminate side effects entirely. Instead, it minimizes side effects and isolates them to specific parts of the codebase, making it easier to reason about and manage.

- **Academic**: Functional Programming is sometimes seen as an academic pursuit with limited real-world applications. In reality, FP is widely used in industry and can lead to more efficient, reliable, and scalable software systems.

## Conclusion

Functional Programming is more than just a coding style; it's a paradigm shift that transforms the way we think about writing software. By embracing FP principles such as pure functions, immutability, recursion, higher-order functions, and monads, developers can write elegant, efficient, and maintainable code. While FP may not be a one-size-fits-all solution, it offers many benefits that make it an attractive choice for a wide range of scenarios. By understanding the core concepts of Functional Programming and leveraging the right tools and libraries, developers can unlock the full potential of FP and embark on a journey to solve programming puzzles with elegance and efficiency.

The IBM/fp-go package provides a set of utilities to write fully functional code in Go. Let's see how we can use this package.

Functional Programming: Where Bugs Become Elegant Puzzles (Part 3)

Hung Vo

## What is Functional Programming?

### Programming Paradigms

#### Structured Programming

In structured programming, the state is external to the code. Programs are structured in a way that separates data and behavior.

#### Object-Oriented Programming (OOP)

OOP integrates state into objects. Objects encapsulate both data and behavior, leading to a modular and scalable approach to software design.

#### Functional Programming (FP)

In FP, the concept of state is minimized or even eliminated. Functional programmers strive to work without relying on traditional state concepts, focusing instead on composing functions to achieve desired outcomes.

![img](https://easymock-blog-prod-qovya.s3.ap-southeast-1.amazonaws.com/t1hRc2VLXbDKaCAmhDa4V.webp)
*[Coderized - The purest coding style, where bugs are near impossible](https://www.youtube.com/watch?v=HlgG395PQWw&t=80s)*

### Imperative vs. Declarative

#### Imperative

Imperative programs specify a sequence of steps on how to achieve a result. They focus on the execution order, detailing each action to be performed.

#### Declarative

Declarative programs express the desired outcome or what to achieve. They emphasize the logic and relationships between components rather than the step-by-step execution.

#### Examples

- In imperative style

```javascript
let sumEvenNumbers = 0;
for (let i = 0; i < 100; i++) {
	if (i % 2 !== 0) {
		sumEvenNumbers += i;
	}
}
```

- In declarative style (using FP)

```javascript
const sumEvenNumbers = [...Array(100).keys()]
	.filter((x) => x % 2)
	.reduce((a, b) => a + b);
```

Functional Programming encourages a shift in mindset, promoting the composition of pure functions and emphasizing immutability. By embracing FP principles, developers can write code that is more concise, maintainable, and easier to reason about, ultimately leading to more robust and scalable software systems.

## Key concepts

Functional Programming (FP) is more than just a coding style; it’s a paradigm shift that transforms the way we think about writing software. Let’s delve into the core concepts of FP to unlock its potential:

### Pure Functions

#### What are they?

Pure functions are the backbone of FP. They have two main characteristics:

- **Deterministic**: Pure functions always produce the same output for a given set of inputs, making them predictable and reliable.
- **Side-Effect Free**: They do not modify external state or perform I/O operations, ensuring that their behavior is isolated and consistent.

``` go
// ❌ causing side effects
func datediff(date1 time.Time) time.Duration {
   return date1.Sub(time.Now())
}

// ✅ Pure Function
func datediff(date1 time.Time, date2 time.Time) time.Duration {
   return date1.Sub(date2)
}

// ❌ modifying argument
func incAge(user *User) {
   user.Age++
}

// ❌ causing side effects
func process() {
   fmt.Println("Processing...")
}

// ✅ Pure Function
const Pi = 3.14159
func circleArea(r float64) float64 {
   return Pi * r * r
}
```

#### Why are they important?

- **Predictability**: Pure functions make code easier to reason about since their behavior is solely determined by their inputs.

- **Testability**: Testing pure functions is straightforward, as there are no external dependencies to set up or manage.

### Immutability

#### What is it?

In FP, data structures are immutable, meaning they cannot be changed after creation. Instead, new versions of data structures are created to represent changes.

```go
// ❌ Mutable data
var john User = User{1, "John"}
john.Name = "Doe"

// ✅ Immutable data
func (u User) changeUserName(name string) User {
   u.Name = name
   return u
}

var john User = User{1, "John"}
doe := john.changeUserName("Doe")
```

#### Why does it matter?

- **Safety**: Immutable data structures prevent accidental data corruption or unintended side effects.
- **Concurrency**: Immutability simplifies concurrent programming by eliminating the need for locks or synchronization mechanisms.

### Recursion

#### How does it work?

Recursion is a fundamental technique where a function calls itself to solve a problem by breaking it down into smaller, self-similar subproblems.

```go
func fact(n int) int {
   if n == 0 {
       return 1
   }
   return n * fact(n-1)
}
```

#### Tail Recursion

A special type of recursion where the recursive call is the very last thing the function does before returning a result.

Optimization (TCO): With Tail Call Optimization, a smart compiler can turn tail recursion into a loop-like structure under the hood, saving stack space and making it more efficient.

Go and TCO: Unfortunately, Go does not guarantee Tail Call Optimization. This means heavily recursive code could run into stack overflow issues if you aren't careful.

```go
// Tail-recursive version
func fact(n int) int {
   return tailFact(n, 1)
}

func tailFact(n, a int) int {
   if n == 0 {
       return a
   }
   return tailFact(n-1, n*a)
}
```

#### Why use it?

- **Simplicity**: Recursion simplifies code by expressing complex problems in terms of simpler ones.
- **Expressiveness**: Recursive solutions often mirror the problem's structure more naturally, leading to clearer and more concise code.

### First-Class Functions and Higher-Order Functions

#### What are they?

- **First-Class Functions**: Functions are treated as first-class citizens, meaning they can be passed as arguments, returned from other functions, and assigned to variables.
- **Higher-Order Functions**: Functions that either take other functions as arguments or return new functions.

```go
// greeterFunc is getting passed as an argument
func processGreeting(greeterFunc func(string) string, name string) string {
   return greeterFunc(name)
}

fmt.Println(processGreeting(greet, "Alice")) // Output: Hello, Alice!

// createGreeter is returning a function
func createGreeter(greeting string) func(string) string {
   return func(name string) string {
       return greeting + ", " + name + "!"
   }
}

// friendlyGreeter is a function returned by createGreeter
friendlyGreeter := createGreeter("Hi")
fmt.Println(friendlyGreeter("Bob")) // Output: Hi, Bob!
```

#### How do they empower FP?

- **Abstraction**: First-class and higher-order functions enable powerful abstractions, allowing developers to write more generic and reusable code.
- **Flexibility**: They provide flexibility in designing algorithms and composing complex behaviors from simpler building blocks.

### Closure and Currying

#### What are they?

- **Closure**: A function that retains access to variables from its lexical scope even after the scope has exited.
- **Currying**: The process of transforming a function that takes multiple arguments into a series of functions, each taking a single argument.

```go
// The outer function createGreeter returns the inner function
func createGreeter(greeting string) func(string) string {
   return func(name string) string {
       return greeting + ", " + name + "!"
   }
}

friendlyGreeter := createGreeter("Hi")

// Even after createGreeter has exited, the inner function retains access to the greeting variable, in this case, "Hi"
fmt.Println(friendlyGreeter("Bob")) // Output: Hi, Bob!
```

#### Why are they useful?

- **Encapsulation**: Closures encapsulate state within functions, leading to modular and maintainable code.
- **Partial Application**: Currying facilitates partial function application, allowing for more flexible and composable APIs.

### Other concepts

- **Lambda Expressions**: Short, unnamed functions you can define and use on the fly. (e.g., in JavaScript: (x, y) => x + y)
- **Monads**: A way to structure computations that might involve side effects (like errors or missing values) safely and predictably.
- **Lazy Evaluation**: Calculating values only when they're needed, potentially saving time and resources.
- **Functors**: Let you apply functions to elements inside data structures, like mapping over a list to double each number.
- **Homomorphism**: A structure-preserving function. If you turn a list of numbers into a list of their string equivalents, that's a homomorphism.
- **Higher-Kinded Types**: Types that can take other types as arguments, letting you make super-general abstractions. These get complex quickly!

Understanding these key concepts is crucial for harnessing the power of Functional Programming. By embracing pure functions, immutability, recursion, higher-order functions, and closures, developers can write code that is not only elegant and concise but also robust, scalable, and maintainable. Unlock the potential of Functional Programming and embark on a journey to solve programming puzzles with elegance and efficiency.

In next part, we'll explorer some practical use-cases of functional programming in Go.

Functional Programming (FP) is more than just a coding style; it's a paradigm that fundamentally alters how we approach software development. Let's explore!

Pick a tag

Functional Programming: Where Bugs Become Elegant Puzzles (Part 3)

Functional Programming: Where Bugs Become Elegant Puzzles