Javascript: 101

Hi Tom,

One difference that you will notice in the functional programming paradigm is providing functions as arguments to other functions.

In the non functional paradigm, we normally give values to functions. The functions do some computation or cause some side effect. But in functional programming we do not restrict ourselves to providing only values to functions. We also provide other functions.

As an example, it is very common in software to have an array and to perform some computation on every element of that array.

In a non functional paradigm every time we wanted to do something like this we would create a different function.

If we need to compute the sum of all values in a array:

function sum(arrOfValues) {
var result = 0;
for(var i = 0; i < arrOfValues.length; i++) {
result += arrOfValues[i];
}
return result;
}

Now let's say somewhere else in the program we have a need to compute the product value. Now we will write another function:

function product(arrOfValues) {
var result = 0;
for(var i = 0; i < arrOfValues.length; i++) {
result *= arrOfValues[i];
}
return result;
}

But in functional programming because functions are first class objects and can be passed to other functions, we can abstract this in a more powerful way.

We can say. Let me create a function which will take an array, and another function, which will be called in every element of the array. This is the forEach function. Once we have written the for each function, our code becomes more concise and readable.

var fsum = function(base, element) {
return base + element;
}

var fproduct = function(base, element) {
return base * element;
}

//to get the sum
var finalSum = forEach(fsum, 0, arrayOfValues);
var finalProduc = forEach(fproduct, 1, arrayOfValues);

I am not sure if this is the best explanation, but I am hoping it will help make functional programming a bit clearer.

--
Regards
Parag

Hi Tom,

That was a really nice explanation of the reduce function. Allow me to also present an analogy.

Reduce is actually part of a larger concept called Map-Reduce. It is used when you have to perform some very large computation which can be broken down into smaller computations and then combined to get to the final answer.

As an example, let's say a country had to do a national census. This is a large job. So they would 'map' it into smaller units by appointing representatives in each state and asking them to do the census of their state. Once all the state representatives complete their individual census, we have an array of values (census of each state) which can be combined ('reduce') to get the final answer (census of the nation).

If we want to compute the total:
array - [state_1_total, state_2_total, state_3_total]
base - 0
combine - will add the element it gets to the base value

If we wanted to compute the median or average then we would have a different combine function.

I will annotate the reduce function with comments

/**
* @param combine A function which accepts an element and a base value. It will perform some computation with these
* values and return a new value
* @param array An array of values
* @base The starting value to be used by each invocation of the combine function. Note that this value will change for
each invocation of combine
* This function takes an array, a base value, and a function. It iterates through the array and invokes the function
* 'combine' for every value of the array. Every time this function is invoked, it is given an element from the array
* and a base value. It performs some computation and returns a value, which will be used as the base value for the
* next invocation of the 'combine' function.
*/
function reduce(combine, base, array) {
//for each element in the array, we invoke an anonymous function which in turn invokes combine and holds the return
//value of combine for the next invocation
forEach(array, function (element) {
base = combine(base, element);
});
//since bae holds the cumulative value of all invocations of combine, we return base which will contain the final
//result
return base;
}

----------------------------------------------------------------------------------------

Here is a more code for our census example

var stateTotals = getStateCensusTotals();
var nationalTotal = reduce(combine, 0, stateTotals);
alert("national census total " + nationalTotal);

var combine = function(base element) {
return base + element;
}

function getStateCensusTotals() {
//compute census for each state and return the result in an array
}