# What is Functional Programming? Tutorial with Example

Functional programming means using functions to the best impact for creating clean and maintainable software.

Functional programming has been a current in software development since the earliest days, but has taken on new significance in the modern era.

In this tutorial, you will learn-

Contents

## What is Functional Programming?

Functional programming (additionally called FP) is a perspective about software development by creating pure capacities. It avoid ideas of shared state, impermanent data observed in Object Oriented Programming.

Functional languages empazies on expression and declarations instead of execution of statements. Thusly, dissimilar to different techniques which rely upon a nearby or worldwide state, value output in FP relies just upon the arguments passed to the function.

## Characteristics of Functional Programming

• Functional programming strategy focuses on results, not the process

• Emphasis is on what is to be computed

• Data is immutable

• Functional programming Decompose the issue into ‘functions

• It is based on the idea of mathematical functions which uses conditional expressions and recursion to do play out the calculation

• It doesn’t support emphasis like loop statements and conditional statements like If-Else

## History of Functional programming

• The foundation for Functional Programming is Lambda Calculus. It was developed during the 1930s for the functional application, definition, and recursion

• LISP was the first functional programming language. McCarthy designed it in 1960

• In the last part of the 70’s researchers at the University of Edinburgh defined the ML(Meta Language)

• In the early 80’s Hope language adds algebraic data types for recursion and equational reasoning

• In the year 2004 Innovation of Functional language ‘Scala.’

## Functional Programming Languages

The target of any FP language is to mimic the mathematical functions. Nonetheless, the fundamental interaction of computation is different in functional programming.

Here, are some most prominent Functional programming languages:

• SML

• Clojure

• Scala

• Erlang

• Clean

• F#

• ML/OCaml Lisp/Scheme

• XSLT

• SQL

• Mathematica

## Fundamental Functional Programming Terminology and Concepts

### Immutable Data

Immutable Data implies that you ought to effectively ready to create data structures as opposed to altering ones which is now exist.

### Referential transparency

Functional programs ought to perform activities just like as if it is for the first time. Thus, you will know what could possibly have occurred during the program’s execution, and its side effects. In FP term it is called Referential transparency.

### Modularity

Modularity design builds usefulness. small modules can be coded rapidly and have a greater chance of re-use which without a doubt leads quicker development of projects. Aside from it, the modules can be tried separately which assists you with reduce the time spent on unit testing and debugging.

### Maintainability

Maintainability is a basic term which implies FP programming is simpler to keep up with as you don’t have to stress over incidentally changing anything outside the given function.

### First-class function

‘First-class function’ is a definition, attributed to programming language elements that have no limitation on their use. Hence, first-class functions can show up anyplace in the program.

### Closure

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

### Higher-order functions

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

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

### Pure function

A ‘pure function’ is a function whose inputs are proclaimed as input and none of them ought to be hidden. The outputs are additionally declared as outputs.

pure functions act their parameters. It’s not efficient if not bringing anything back. In addition, it offers similar output for the given parameters

Example:

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

### Impure functions

Impure functions precisely in opposite of pure. They have hidden inputs or output; it is called impure. Impure functions can’t be used or tried in detachment as they have dependencies.

Example

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

### Function Composition

Function composition is consolidating at least 2 capacities to make another one.

### Shared States

Shared states is a significance idea in OOP programming. Essentially, It’s adding properties to objects. For instance, 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 happen outside of a called work. The biggest objective of any FP programming language is to minimize side effects, by separating them from the remainder of the software code. In FP programming It is vital to remove side effects from the remainder of your programming logic.

## The benefits of functional programming

• Allows you to try not to confound issues and errors in the code

• Easier to test and execute Unit testing and debug FP Code.

• Parallel handling and simultaneousness

• Hot code deployment and fault tolerance

• Offers better modularity with a more limited code

• Increased usefulness of the developer

• Supports Nested Functions

• Functional Constructs like Lazy Map and Lists, and so forth

• Allows effective use of Lambda Calculus

## Limitations of Functional Programming

• Functional programming worldview isn’t simple, so it is hard to comprehend for the beginner

• Hard to keep up with as numerous objects evolve during the coding

• Re-use is extremely complicated and needs continually refactoring

• Objects may not address the issue effectively

## Functional Programming vs. Object-oriented Programming

Conclusion

Functional programming or FP is a perspective about software development dependent on some fundamental defining standards

• Functional programming ideas focuses around results, not the process

• The objective of any FP language is to mimic the mathematical functions

• Some most prominent Functional programming languages: 1)Haskell 2)SM 3) Clojure 4) Scala 5) Erlang 6) Clean

• A ‘pure function’ is a function whose inputs are declared as inputs of info and none of them ought to be hidden. The outputs are likewise declared as outputs.

• Immutable Data implies that you ought to effectively ready to create data structures as opposed to adjusting ones which is as of now exist

• Allows you to try not to confusing issues and errors in the code

• Functional code isn’t simple, so it is hard to comprehend for the beginner

• FP uses Immutable data while OOP uses Mutable data

Related:

Software Engineer vs Software Developer: What’s The Difference?

SDLC: Phases & Models of Software Development Life Cycle

Thanks for reading! We hope you found this tutorial helpful and we would love to hear your feedback in the Comments section below. And show us what you’ve learned by sharing your projects with us.