Functional Programming Explained in 5 Minutes [With Examples]

Building software is a very technical and challenging process that requires planning and strategizing to formulate the right way to solve a problem using the software.

In this regard, considering the programming paradigm of choice before developing any software is an important step.

A programming paradigm is a model or approach towards programming which provides features, patterns, principles, rules, and styles of designing, structuring, and writing computer programs.

Examples of popular programming paradigms include Object Oriented Programming(OOP), Procedural programming, Event-Driven Programming, and Functional Programming, among others.

Functional programming, in particular, has been getting a lot of attention in recent times as it promises less buggy code that is highly reusable and easy to maintain. So what is functional programming?

Functional programming is a sub-paradigm of the declarative programming paradigm. Declarative programming is a paradigm that focuses on writing code that describes what a program should do rather than how the program should do it.

An example of this can be seen when querying SQL databases for data. Instead of explicitly saying how you want that to be retrieved, all you specify is the data you want to be retrieved.

Functional programming itself is a paradigm for building computer programs using expressions and pure functions which are applied in sequence to solve problems or achieve desired results.

In functional programming, the entire functionality of a program is broken into reusable, single-responsibility pure functions. Everything in the program happens through the use of pure functions.

A pure function is a deterministic function that, when given the same input values, will return the same output and not affect any other parts of the applications.

The result of a pure function thus solely relies on its input and not a global variable in the application which can alter the results of the function.

These pure functions receive input, process them locally, and produce an output without altering any other part of the program.

Functional programming uses immutable data, that is, data that cannot be changed once it is created, and it also avoids shared states, where the same data can be accessed and modified by different parts of a program.

Since functional programming relies heavily on functions, functions are referred to as first-class citizens meaning they can be passed as an argument, saved to a variable, and also returned from another function.

Additionally, functional programming relies heavily on expression instead of statements and thus avoids loop statements such as for and while. This is done to make the program’s logic easy to follow and debug.

Types of Functional Programming Languages

There are two main types of functional programming languages. These include:

• Purely Functional Languages – These are programming languages that support, enforce and promote the use of functional paradigms such as the use of first-class pure functions, the immutability of states and data, and functions not having side effects to other parts of the program. Examples of purely functional languages include Haskell, Agda, Clean, Idris, Futhark, and Elm, among others.
• Impure Functional Languages – These are languages that have support for functional programming paradigms but also allow the use of impure functions, mutations of a program’s state, and operations that have side effects. Examples of impure functional languages include Javascript, Rust, Erlang, Python, Ruby, Java, Kotlin, and Clojure, among others.

Both purely functional and impure functional languages are in use by developers. However, shifting to a purely functional language might take a lot of time and effort if you’ve never used functional programming before.

Functional Programming Languages and Libraries

Some popular functional programming languages and libraries include:

#1. Haskell

Haskell is a statically typed, lazy, purely functional programming language that is considered the embodiment of the functional programming paradigm.

In addition to type inference, the language offers support for lazy evaluation, where expressions are only evaluated when their results are needed. Haskell also offers support for concurrent programming, and its compilation comes with a high-performance garbage collector and a lightweight concurrency library.

Through its use and strict adherence to functional programming principles, Haskell can make building complex software systems easier and also easy to maintain.

Among many industry players, Haskell is the go-to language when building self-contained systems or domain-specific languages. It also has wide use in academia and research. Some companies that use Haskell include Microsoft, Github, Hasura, and Lumi, among many others.

#2. Ramda

Ramda is a functional programming library for the JavaScript language. Ramda makes it simple to build complex logic through functional composition and provides a set of utility functions that encourage and support the use of functional programming principles in JavaScript.

Ramda also provides an easy way to use immutable objects and functions with no side effects, which are key concepts in functional programming.

Since JavaScript is not a purely functional programming language like Haskell, through the use of a library like Ramda, you can utilize functional programming and reap the performance benefits of functional programming while using JavaScript.

#3. Elixir

Elixir is a general-purpose, concurrent, functional programming language that is designed to be scalable, easy to maintain, and also fault-tolerant. The language was created in 2011 by Jose Valim, runs on the BEAM virtual machine, and is used by companies like Heroku, Discord, change.org, and Duffel, among others.

Being a functional programming language, Elixir encourages the immutability of states and data, the use of pure functions when writing code, and the transformation of data.

Key Concepts in Functional Programming

#1. Pure Functions

Functional programming makes extensive use of pure functions. Pure functions have two main characteristics. First, they produce the same output for the same input regardless of any external factors, making them deterministic in nature and thus predictable.

Secondly, pure functions do not have side effects. That is, they do not modify the external environment outside their scope in any way.

Some examples of pure functions include:

//function to calculate the square of a number
function square(x) {
    return x * x;
}

//function to add two variables
function add(a, b) {
    return a + b
}

The above functions return the same output for the same inputs and do not have any side effects outside their scope.

#2. Immutability

In functional programming, the data used is immutable. This means that once variables have been initialized, they cannot be modified. This ensures the preservation of the state of a variable throughout the program.

In case you want to make any modification to the variable or perform an operation on it, you can create a new variable to store the updated data without altering the initial variable.

#3. Higher-Order Functions

Higher-order functions are functions that accept one or more functions as arguments and/or return a function.

Higher-order functions are useful in functional programming as they allow combining multiple functions to create new functions, allow the use of callbacks, allow the abstraction of common patterns into reusable functions, and finally, higher-order functions allow the writing of more concise and expressive code.

An example of a higher-order function is shown below:

// A higher-order function which returns a function that multiplies
// a number by a given factor
function multiplier(factor) {
    return function (number) {
      return number * factor;
    }
  }
  
const double = multiplier(2); 
const triple = multiplier(3);
const quadruple = multiplier(4);
  
console.log(double(5)); // Output: 10
console.log(triple(5)); // Output: 15
console.log(quadruple(5)); // Output: 20

#4. Recursion

Since functional programming relies on expressions instead of statements, control flow statements such as for and while loops are avoided in this paradigm. These loop statements are, in turn, replaced using recursion, which is what is used to perform iterations in functional programming.

Recursion involves a function calling itself repeatedly until an exit condition is met. Using recursion, a complex problem is broken down into smaller, simpler subproblems which are then solved recursively until a base case is reached, providing a solution to the larger complex problem.

#5. Declarative Programming

Functional programming is a sub-paradigm in the broader declarative programming paradigm which encompasses programming paradigms that focus on writing code in terms of what needs to be done instead of explicitly stating how to do it.

In that regard, when using the functional programming paradigm, your code should describe what needs to be achieved or the problem to be solved.

How that will be achieved is up to the programming language you are using. This helps in writing more concise and easily readable code.

#6. Stateless

Functional programming emphasizes stateless code, where the code does not maintain a global state that can be modified by functions. The outcomes of functions solely rely on the input passed and cannot be influenced by dependencies on other parts of the code.

The functions used cannot modify a state or variable in the program that is outside its scope.

#7. Parallel Execution

Since functional programming uses immutable states, uses pure functions, and immutable data, it allows for the parallel execution of multiple computations simultaneously.

Since each function only has to deal with a given input without worrying about incurring side effects from other parts of a program, complex problems can be broken up into smaller sub-problems and executed simultaneously in parallel, which allows for improved performance and efficiency.

Benefits of Functional Programming

Some of the benefits of functional programming include:

Fewer software bugs

Aside from the fact that code implementing the functional programming paradigm is more readable and easier to understand because of the use of pure functions, functional programming allows for writing code with fewer errors.

Since functional programming works with immutable states, you never have several parts of a program altering the state of a variable or the entire program. This, in turn, results in fewer errors that could have arisen from data being modified from multiple areas because of shared states.

Improves code Readability

Functional programming is a sub-paradigm of the declarative paradigm, which emphasizes writing code that describes what needs to be done rather than how to do it. This, coupled with the use of pure functions, results in code that is self-explanatory, easier to read and understand, and easy to maintain.

Enhance code reusability

Implementing functional programming requires breaking complex problems into smaller subproblems and solving these problems using pure functions. These functions can easily be composed and reused to solve other complex problems. Through the use of pure functions and immutable states, functional programming allows the writing of highly reusable code.

Easier testing and debugging

Functional programming uses pure functions which do not have side effects, only depend on their inputs, and produce consistent deterministic outputs for the same set of inputs.

This makes functional programming inherently easy to test and debug as you do not need to track a variable and how it changes throughout different parts of a program.

Since there are no dependencies in functional programming, debugging and testing become easier as you can target specific parts of a program.

Supports concurrency and parallelism

Since functional programming encourages statelessness and immutability of data, it makes it possible to safely execute multiple pure functions in parallel or concurrently. The capability of running multiple operations in parallel results in better processing speeds and better utilization of processors with multiple cores.

As a programming paradigm, functional programming can help in the writing of more readable and easily understood code with fewer errors and excellent support for parallelism allowing for the efficient use of multicore processors. Functional programming allows the building of software systems that are more reliable and easy to scale.

Limitations of Functional Programming

Though functional programming has a lot to offer, it comes with a learning curve that requires developers to invest a lot of time and effort in learning how to use the paradigm. This is because it introduces new ways of structuring code and new programming concepts.

Coding using functional programming can be extremely complex and difficult as it does not use more intuitive features such as for and while loops. Writing programs recursively is not easy.

As a result, developers may take more to master functional programming, especially when coming from languages that use mutable states, such as in object-oriented programming.

Another limitation of functional programming arises from its core principle of immutability. Since data and states are mutable, and new data structures are created instead of modifying existing ones, this results in functional programming using more storage space. The immutable nature of functional programming can also result in poorer performance in applications.

Conclusion

Although functional programming has existed for a long time, it has become a trending paradigm in recent times. As much as it might be a bit difficult to pick up, developers stand to benefit tremendously from learning about the paradigm and different ways they can implement functional programming when writing programs.

Since you don’t need to use purely functional programming languages such as Haskell, you can implement functional programming concepts in languages such as Javascript, Java, Python, and Kotlin and reap the benefits of functional programming in your projects.

You may also explore some resources to learn Python for beginners.