What is Functional Programming?

What is Functional Programming?

Functional programming (also called FP) is a way of thinking about software construction by creating pure functions. It avoids concepts of shared state and mutable data observed in Object Oriented Programming.

Functional languages emphasize expressions and declarations rather than the execution of statements. Therefore, unlike other procedures which depend on a local or global state, value output in FP depends only on the arguments passed to the function.

Characteristics of Functional Programming

• Functional programming method focuses on results, not the process.
• Emphasis is on what is to be computed.
• Data is immutable.
• Functional programming decomposes the problem into functions.
• It is built on the concept of mathematical functions which use conditional expressions and recursion to perform the calculation.
• It does not support iteration like loop statements and conditional statements like If-Else.

History of Functional programming

• The foundation for Functional Programming is Lambda Calculus. It was developed in the 1930s for the functional application, definition, and recursion.
• LISP was the first functional programming language. McCarthy designed it in 1960.
• In the late 70’s, researchers at the University of Edinburgh defined the ML (Meta Language).
• In the early 80’s, the Hope language added algebraic data types for recursion and equational reasoning.
• In the year 2004, the functional language ‘Scala’ was innovated.

Functional Programming Languages

The objective of any FP language is to mimic mathematical functions. However, the basic process of computation is different in functional programming.

Here are some of the most prominent Functional programming languages:

• Haskell
• SML
• Clojure
• Scala
• Erlang
• Clean
• F#
• ML/OCaml Lisp / Scheme
• XSLT
• SQL
• Mathematica

Basic Functional Programming Terminology and Concepts

Immutable Data

Immutable Data means that you should be easily able to create data structures instead of modifying ones which already exist.

Referential transparency

Functional programs should perform operations just as if it is for the first time. So, you will know what may or may not have happened during the program’s execution, and its side effects. In FP terms, this is called Referential transparency.

Modularity

Modular design increases productivity. Small modules can be coded quickly and have a greater chance of re-use, which surely leads to faster development of programs. Apart from that, the modules can be tested separately, which helps you to reduce the time spent on unit testing and debugging.

Maintainability

Maintainability is a simple term which means FP programming is easier to maintain, as you do not need to worry about accidentally changing anything outside the given function.

First-class function

‘First-class function’ is a definition attributed to programming language entities that have no restriction on their use. Therefore, first-class functions can appear anywhere in the program.

Closure

A closure is an inner function which can access variables of the parent function, even after the parent function has executed.

Higher-order functions

Higher-order functions either take other functions as arguments or return them as results.

Higher-order functions allow partial applications or currying. This technique applies a function to its arguments one at a time, with each application returning a new function which accepts the next argument.

Pure function

A ‘Pure function’ is a function whose inputs are declared as inputs and none of them should be hidden. The outputs are also declared as outputs.

Pure functions act on their parameters. It is not efficient if it does not return anything. Moreover, it offers the same output for the given parameters.

Example:

Function Pure(a,b)
{
	return a+b;
}

Impure functions

Impure functions are exactly the opposite of pure functions. They have hidden inputs or outputs, and that is why they are called impure. Impure functions cannot be used or tested in isolation as they have dependencies.

Example

int z;
function notPure(){
	z = z+10;
}

Function Composition

Function composition is combining 2 or more functions to make a new one.

Shared States

Shared state is an important concept in OOP programming. Basically, it is adding properties to objects. For example, if a HardDisk is an Object, Storage Capacity and Disk Size can be added as properties.

Side Effects

Side effects are any state changes which occur outside of a called function. The biggest goal of any FP programming language is to minimize side effects by separating them from the rest of the software code. In FP programming, it is vital to take side effects away from the rest of your programming logic.

The benefits of functional programming

• Allows you to avoid confusing problems and errors in the code.
• Easier to test and execute Unit testing and debug FP Code.
• Parallel processing and concurrency.
• Hot code deployment and fault tolerance.
• Offers better modularity with shorter code.
• Increased productivity of the developer.
• Supports Nested Functions.
• Functional Constructs like Lazy Map & Lists, etc.
• Allows effective use of Lambda Calculus.

Limitations of Functional Programming

• The functional programming paradigm is not easy, so it is difficult to understand for beginners.
• Hard to maintain as many objects evolve during the coding.
• Needs lots of mocking and extensive environmental setup.
• Re-use is very complicated and needs constant refactoring.
• Objects may not represent the problem correctly.

Functional Programming vs. Object-oriented Programming

FAQs