# What is Functional Programming? A Beginner's Guide  Vinay Khatri
Last updated on October 20, 2022

Functional Programming is a very vast area. But fortunately, we can define it with simple key points because it is derived from a key idea or a very easy principle. Here in this article, we will cover that principle so you can get a better understanding of what functional programming is.

## What is Functional Programming?

In computer science, we do programming, and in programming, we have different types of paradigms, such as Functional, Procedural, and Object-Oriented programming. We can define a programming paradigm as the approach to solving a problem using programming or coding. The origin of functional programming is derived from mathematics.

As we use different equations and functions in math, we have adopted the same concept and used it in programming languages to solve problems. These days each high-level programming languages support functional programming because it reduces the redundancy of code and increases the concept of reusability of code.

Many times, we get confused between Procedural programming and Functional programming. However, both are different, and the main disparity is the outcome of the same input. As we know, Functional Programming is completely embraced by mathematics. And like mathematics, no matter what, if the input is the same for a function, the output will be the same too.

But in Procedural programming, the output of the input depends upon the state of the programming, so here in Procedural programming , the output of the same input may differ from state to state.

### Characteristics of Functional Programming

• Like a mathematical function, mapping one input to one output is similar to functional programming. Every input has only one output.
• Functional programming is “without variable assignment programming.”
• Data is immutable in functional programming, which means if we pass x as 12, the value of x will remain 12 for the complete function.
• As data is immutable so we cannot perform a loop and other types of increment operation on data, so to perform a repetitive task, we can use recursion.
• It completely follows the concepts of Mathematics.

### Terms of Functional Programming

There are some specific concepts and terminology we use in Functional Programming.

• First-Class and Higher-Order Functions
• Pure Functions
• Recursion
• Modularity
• Referential Transparency

#### 1. First-Class and high-order functions

In a high-order function, the function can accept and return a function as input and output, respectively. When we perform the differentiation ( d/dx ) , we perform it on function, and the result is also in the form of a function for most cases. Decorators in programming languages are the perfect example of High order functions.

Example:

``````def fun(a):
return a()
def g():
print("something")
fun(g)``````

#### 2. Pure functions

With pure function, the output will remain the same for the same inputs. No matter how many times you execute the function with the same input, the outcome of the function remains the same. This defines the immutability of the function input with its corresponding output. There is another property of pure function, which defines that they do not have any side effects on the memory or input-output.

#### 3. Recursion

Recursion is when a function calls itself in order to iterate over a statement. In functions, we often use recursion for iterative operations though it has an impact on memory because for each recursion, it occupies the same amount of memory as a complete function. The recursion of a function may be infinite. So we set a base condition with each recursion function. When the recursion meets the base condition, the program returns a value and terminates the function execution.

#### 4. Modularity

With modularity, we increase the productivity and reusability of code in the program. We can create small modules and use them whenever we want. As we can create modules separately, it makes it easier for testers to test and debug each module.

#### 5. Referential Transparency

In the pure function, the outcome or result of a function remains constant with respect to the argument or input list. This is also known as Referential transparency. In referential transpiration, calling the same function with the same inputs return the same result.

• It makes code easy to test and debug.
• Achieve parallel processing.
• Provide the reusability of code with modularity
• Provide recursion for iteration.
• Increase the productivity of the developer.
• It adopts lazy evaluation, which avoids repeated evaluation because the value is evaluated and stored only when needed.

• It has a complex definition.
• Decrease the readability of code.
• The recursion needs more memory and hence, can slow down the performance of the function.

## Conclusion

In functional programming, we try to merge everything in a pure mathematical functions style. This programming paradigm makes it easier for testers to test and debug programs. Also, it helps you write clean and maintainable code and achieve parallel processing. We hope you have gained enough clarity on functional programming after reading this article. You can share your queries regarding this topic in the comments section below.

## FAQs

Functional programming is a programming paradigm that leverages the mathematical concept of solving expressions and functions. It divides the entire problem into small tasks, where each task is implemented a function.

Python is not purely a functional programming language.

Yes, Haskell is purely a functional programming language widely used for research and academia.

The foremost advantage of functional programming is brevity, i.e., the code in functional programming is concise, short, and crisp.