Functional programming is a declarative programming paradigm in that the programming is done with expressions or declarations instead of statements. In functional programming code, the output value of a function depends only on its arguments, so calling a function multiple times with the same value for an argument always produces the same result. Therefore there is no side effects on the result.
One of the easiest way for the development of functional programming is making a program by eliminating changes, in state that they do not depend on function inputs, which are called side effects. So you need to keep in mind that there should be no side effects.
First Class and High Order Function
In functional programming, the language supports passing functions as arguments to another functions, returning them as values from functions and assigning them to variables or storing them into data structure. This is what a first class function is meant to be. So first class functions are first-class variables.
With first-class functions, the names of functions do not have any special status; they are treated like ordinary variables with a function type.
A higher-order function is a function that does at least one of the following:
- takes one or more functions as arguments (i.e. procedural parameters)
- returns a function as its result
First-class functions are a necessity for the functional programming style, in which the use of higher-order functions is a standard practice.
A simple example of a higher-ordered function is the map function, which takes, as its arguments, a function and a list, and returns the list formed by applying the function to each member of the list. For a language to support map, it must support passing a function as an argument.
The distinction between the first-class function and higher-order function is subtle: “higher-order” describes a mathematical concept of function that operates on other functions, while “first-class” is a computer science term that describes programming language entities that have no restriction on their use and first-class functions can appear anywhere in the program.
Thus first-class functions can appear anywhere in the program that other first-class entities like numbers can, including as arguments to other functions and as their return values.
local twice = function(f,v) return f(f(v)) end local addthree = function(v) return v + 3 end print(twice(addthree,7))
Pure functions have no side effects and no state.
Calling the pure function again with the same arguments returns the same result. This can enable caching for memory optimizations.
The evaluation of any pure expression is thread-safe.
sum(x, y): return x + y
Notice in the above
sum() function, how the return value of the
sum() function only depends on the input parameters
y. Notice also that the
sum() has no side effects, so it does not modify any state (variables) outside the function.
Iteration or looping in functional programming is usually accomplished via recursion. Recursive functions invoke themselves, letting an operation be repeated until it reaches the base case or terminating condition is met.
fibonacci(n): if (n <= 1) return 1 else return fibonacci(n - 1) + fibonacci(n - 2)
Functional programs do not have assignment statements, i.e., the value of a variable in a functional program never changes once defined. This eliminates any chances of side effects. So, functional programs are referentially transparent.
Consider an assignment statement
x = x + 10, this changes the value assigned to the variable
x. Let us say that the initial value of
1, then two consecutive evaluations of the variable
12 respectively. Clearly, the expression is not referentially transparent.
In functional programming paradigm the idea is you should not modify a variable once it has been initialized. Therefore immutable variables are needed in functional programming. Immutable variables makes it easier to avoid side effects.
That’s all about functional programming.