Transitioning to Functional Programming

Transitioning to a functional programming paradigm can be challenging, but here are some tips and concepts to help you make the switch more smoothly:

Understand the Core Concepts:

1. Immutability: Variables should not be changed once they are set. This helps to avoid side effects. First-Class Functions: Functions are treated as first-class citizens, meaning they can be assigned to variables, passed as arguments, and returned from other functions.
2. Pure Functions: A function where the output value is determined only by its input values, without observable side effects.
3. Function Composition: Combining multiple functions to create a new function.
4. Recursion: A technique where a function calls itself to solve smaller instances of the same problem.
5. Higher-Order Functions: Functions that take other functions as arguments or return them as results.

Practice Thinking in Functions:

• Break problems into smaller, reusable functions.
• Embrace the idea of composing functions to build complex behavior.
• Use map, reduce, and filter operations for transforming data collections.

Avoid Side Effects:

Strive to write functions that do not alter the state or interact with the outside world (e.g., no printing to console, modifying global variables).

Use Functional Libraries:

In JavaScript, libraries like Ramda or Lodash provide utilities that encourage functional programming. In Go, you might look into functional-style packages or try writing Go in a functional style by utilizing functions and immutability principles.

Explore Functional Languages:

Spend time with languages designed for functional programming, like Elixir, Elm, or Haskell. This immersion can help solidify your understanding of functional concepts.

Refactor Existing Code:

Take some of your existing object-oriented or procedural code and try to refactor it in a functional style. This can be a practical way to understand how to apply functional concepts.

Study Functional Patterns:

Learn about common functional patterns like currying, partial application, and function composition.

Leverage Type Systems:

Languages like Elm have strong type systems that guide you towards functional programming patterns. Type annotations can help enforce immutability and pure functions.

Practice, Practice, Practice:

Here’s a simple example to illustrate transforming an imperative approach to a functional one:

// Imperative approach
const numbers = [1, 2, 3, 4, 5]
let doubled = []
for (let i = 0; i < numbers.length; i++) {
  doubled.push(numbers[i] * 2)
}
console.log(doubled)

// Functional approach
const numbers = [1, 2, 3, 4, 5]
const doubled = numbers.map((num) => num * 2)
console.log(doubled)

Javascript v Elixir : basic functional programming example

// JavaScript
let sum = 0
for (let i = 1; i <= 10; i++) {
  sum += i
}
console.log(sum)

# Elixir
sum = Enum.reduce(1..10, 0, fn x, acc -> x + acc end)
IO.puts(sum)

Javascript v Elixir : higher order functions example

const numbers = [1, 2, 3, 4, 5]
const doubled = []
for (let i = 0; i < numbers.length; i++) {
  doubled.push(numbers[i] * 2)
}
console.log(doubled)

numbers = [1, 2, 3, 4, 5]
doubled = Enum.map(numbers, fn x -> x * 2 end)
IO.inspect(doubled)

Javascript v Elixir : immunability example

let state = { count: 0 }
function increment() {
  state.count += 1
}
increment()
console.log(state.count) // 1

state = %{count: 0}
increment = fn state -> %{state | count: state.count + 1} end
state = increment.(state)
IO.inspect(state.count)  # 1

Some Elixir Examples

# Sum of squares of numbers
defmodule Math do
  def sum_of_squares(numbers) do
    numbers
    |> Enum.map(fn x -> x * x end)
    |> Enum.sum()
  end
end
 
numbers = [1, 2, 3, 4, 5]
IO.puts(Math.sum_of_squares(numbers))

Filter even numbers

defmodule Math do
  def filter_even(numbers) do
    numbers
    |> Enum.filter(fn x -> rem(x, 2) == 0 end)
  end
end
 
numbers = [1, 2, 3, 4, 5]
IO.inspect(Math.filter_even(numbers))

Calculate factorial

defmodule Math do
  def factorial(n) when n <= 1, do: 1
  def factorial(n) do
    n * factorial(n - 1)
  end
end
 
IO.puts(Math.factorial(5))

Fibonacci sequence

defmodule Math do
  def fibonacci(n) when n <= 0, do: []
  def fibonacci(1), do: [0]
  def fibonacci(2), do: [0, 1]
  def fibonacci(n) do
    fib = fibonacci(n - 1)
    [Enum.at(fib, -1) + Enum.at(fib, -2) | fib]
  end
end
 
IO.inspect(Math.fibonacci(10))

Map and Reduce

defmodule Math do
  def double(numbers) do
    Enum.map(numbers, fn x -> x * 2 end)
  end
 
  def sum(numbers) do
    Enum.reduce(numbers, 0, fn x, acc -> x + acc end)
  end
end
 
numbers = [1, 2, 3, 4, 5]
IO.inspect(Math.double(numbers))
IO.puts(Math.sum(numbers))

defmodule Math do
  def double_and_sum(numbers) do
    numbers
    |> Enum.map(&(&1 * 2))
    |> Enum.sum()
  end
end
 
numbers = [1, 2, 3, 4, 5]
IO.puts(Math.double_and_sum(numbers))  # Output: 30

The expression &(&1 * 2) in Elixir is a shorthand syntax for creating an anonymous function. Here’s a breakdown of what it does:

1. & Operator: This is used to create an anonymous function.
2. &1 : This is a placeholder for the first argument passed to the anonymous function.
3. * 2: This indicates that the argument (&1) should be multiplied by 2.

So, &(&1 * 2) is equivalent to writing fn x -> x * 2 end.

Currying

Currying is a technique where a function with multiple arguments is transformed into a sequence of functions, each taking a single argument. Here’s an example in Elixir:

defmodule Math do
  def add(a, b), do: a + b
  def curry_add(a), do: fn b -> add(a, b) end
end
 
add_2 = Math.curry_add(2)
IO.puts(add_2.(3))  # 5

Partial Application

Partial application is similar to currying, but it involves fixing a number of arguments in a function. Here’s an example in Elixir:

defmodule Math do
  def add(a, b, c), do: a + b + c
  def partial_add(a, b), do: fn c -> add(a, b, c) end
end
 
add_2_3 = Math.partial_add(2, 3)
IO.puts(add_2_3.(4))  # 9

Function Composition

Function composition is the act of combining two or more functions to produce a new function. Here’s an example in Elixir:

defmodule Math do
  def add(a, b), do: a + b
  def square(x), do: x * x
end
 
add_and_square = fn x, y -> Math.square(Math.add(x, y)) end
IO.puts(add_and_square.(2, 3))  # 25