Functional programming generator#
Functional programming software#
Functional programming code#

Given a parameter A в†’ expect the function to return value B.

So we can unit test pure functions with different contexts: We donвЂ™t need to think of situations when the same parameter has different results - because it will never happen. Given the same parameters, pure functions will always return the same result. Pure functions are stable, consistent, and predictable. Now every function is isolated and unable to impact other parts of our system. If we follow these two simple rules, it gets easier to understand our programs.

The function returns the incremented value without altering the value of the variable. See that our pure function increase-counter returns 2, but the counter value is still the same. But how would we make it pure? Just return the value increased by 1. Observation: mutability is discouraged in functional programming. Our impure function receives that value and re-assigns the counter with the value increased by 1. Now we want to implement a function to receive an integer value and return the value increased by 1. It does not cause any observable side effectsД®xamples of observable side effects include modifying a global object or a parameter passed by reference.

Functional programming generator#

Random number generationДЄny function that relies on a random number generator cannot be pure. If our function reads external files, itвЂ™s not a pure function - the fileвЂ™s contents can change. For the parameters radius = 10 & PI = 42, we will always have the same the result: 4200.For the parameters radius = 10 & PI = 3.14, we will always have the same the result: 314.0.So now we are just accessing parameters passed to the function. TA-DA ?! Now weвЂ™ll always pass theP I value as a parameter to the function. For the same parameter ( radius = 10), we have a different result. Our impure function will now result in 10 * 10 * 42 = 4200. Now imagine some mathematicians argue that the PI value is actually 42and change the value of the global object. Why is this an impure function? Simply because it uses a global object that was not passed as a parameter to the function. In Clojure, the operator comes first, so radius * radius * PI becomes (* radius radius PI): An impure function would receive radius as the parameter, and then calculate radius * radius * PI. Imagine we want to implement a function that calculates the area of a circle. It returns the same result if given the same arguments It does not cause any observable side effects.It returns the same result if given the same arguments (it is also referred as deterministic).So how do we know if a function is pure or not? Here is a very strict definition of purity: But what does that really mean? What makes a function pure? The first fundamental concept we learn when we want to understand functional programming is pure functions. Take a look: Functional Programming Principles in Javascript What is functional programming? Functional programming is a programming paradigm - a style of building the structure and elements of computer programs - that treats computation as the evaluation of mathematical functions and avoids changing-state and mutable data - Wikipedia Pure functions вЂњwater dropвЂќ by Mohan Murugesan on Unsplash If you are not comfortable with a LISP-type-of-language, I also published the same post in JavaScript. This article uses Clojure as a programming language example to explain Functional Programming.

Functional programming code#

In this post, I will tell you more about functional programming, and some important concepts, with a lot of code examples. Those concepts are big advantages to build side-effect-free functions, so it is easier to maintain systems - with some other benefits.

Functional programming software#

' Complexity is anything that makes software hard to understand or to modify.' - John OuterhoutДoing some research, I found functional programming concepts like immutability and pure function. After a long time learning and working with object-oriented programming, I took a step back to think about system complexity.