–Functional Programming (or FP, as it's usually shortened) has been around since the earliest times and is going through a sort of revival, due to its increased use with several frameworks and libraries, and most particularly in JavaScript. In this chapter, we shall:

• Introduce some concepts of FP, to give a small taste of what it means

• Show benefits (and problems) implied by the usage of FP

• Start thinking about whyJavaScript (JS) can be considered to be an appropriate language for FP

• Go over the language features and tools that you should be aware of, to fully take advantage of everything in this book

So, let's get started by asking ourselvesWhat is FP? and start working on that topic.

If you go back in computer history, you'll find that the second–oldest programming language still in use, LISP, has its bases in Functional Programming. Since then there have been many more functional languages, and FP has been applied more widely. But even so, if you ask around what FP is, you'll probably get two widely dissimilar answers.

Depending on whom you ask, you'll either learn that it's a modern, advanced, enlightened approach to programming that leaves every other paradigm behind, or you'll be told that it's mainly a theoretical thing, with more complications than benefits, practically impossible to implement in the real world. And, as usual, the real answer is not in the extremes, but somewhere within.

In this book, we won't be going about FP in a theoretical way: our point is, rather, to show how some of its techniques and tenets can be successfully applied for common, everyday JavaScript programming. But, and this is important, we won't be going about this in a dogmatic fashion, but rather in a very practical way. We won't dismiss useful JS constructs, only because they don't happen to fulfill the academic expectations of FP. We won't avoid practical JS features just to fit the FP paradigm. In fact, we could almost say we'll be doingSFP—Sorta Functional Programming because our code will be a mixture of FP features and more classical imperative andObject Oriented Programming (OOP).

(This doesn't mean that we'll be leaving all the theory by the side. We'll be picky, and just touch the main theoretical points, give some vocabulary and definitions, and explain core FP concepts... but we'll always be keeping in sight the idea of helping to produce actual, useful, JS code, and not to try to achieve some mystical, dogmatic FP criteria.)

OOP has been a way to solve the inherent complexity of writing large programs and systems, and developing clean, extensible, scalable application architectures. However, because of the scale of today's web applications, the complexity of all codebases is continuously growing. Also, the newer features of JS make it possible to develop applications that wouldn't even have been possible just a few years ago; think of mobile (hybrid) apps done with Ionic, Apache Cordova, or React Native, or desktop apps done with Electron or NW.js, for example. JS has also migrated to the backend with Node.js, so today the scope of usage for the language has grown in a serious way, and dealing with all the added complexity taxes all designs.

FP implies a different way of writing programs, which can sometimes be difficult to learn. In most languages, programming is done in imperative fashion: a program is a sequence of statements, executed in a prescribed fashion, and the desired result is achieved by creating objects and doing manipulations on them, which usually modify the objects themselves. FP is based on producing the desired result by evaluating expressions, built out of functions composed together. In FP, it's usual to pass functions around (as parameters to other functions, or returned as the result of some calculation), to not use loops (opting for recursion instead), and to skip side effects (such as modifying objects or global variables).

Another way of saying this, is that FP focuses onwhat should be done, rather than onhow. Instead of worrying about loops or arrays, you work at a higher level, considering what you need to be done. After getting accustomed to this style, you'll find that your code becomes simpler, shorter, more elegant, and can be easily tested and debugged. However, don't fall into the trap of considering FP as a goal! Think of FP only as a means towards an end, as with all software tools. Functional code isn't good just for being functional... and writing bad code is just as possible with FP as with any other techniques!

Since we have been saying some things about what FP is, let's also clear some common misconceptions, and consider some things that FP isnot:

• FP isn't just an academic ivory tower thing: It is true that the lambda calculus upon which it is based, was developed by Alonzo Church in 1936, as a tool in order to prove an important result in theoretical computer science. (This work preceded modern computer languages by more than 20 years!). However, FP languages are being used today for all kinds of systems.

• FP isn't the opposite of object–oriented programming (OOP): Also, it isn't either a case of choosing declarative or imperative ways of programming. You can mix and match as it best suits you, and we'll be doing that sort of thing in this book, bringing together the best of all worlds. 

• FP isn't overly complex to learn: Some of the FP languages are rather different from JS, but the differences are mostly syntactic. Once you learn the basic concepts, you'll see you can get the same results in JS as with FP languages.

It may also be relevant to mention that several modern frameworks, such as the React+Redux combination, include FP ideas. For example, in React it's said that the view (whatever the user gets to see at a given moment) is a function of the current state. You use a function to compute what HTML and CSS must be produced at each moment, thinking inblack box fashion.

Similarly, in Redux you get the concept ofactions that are processed byreducers. An action provides some data, and a reducer is a function that produces the new state for the application in a functional way out of the current state and the provided data. 

So, both because of theoretical advantages (we'll be getting to those in the following section) and of practical ones (such as getting to use the latest frameworks and libraries) it makes sense to consider FP coding; let's get on with it.

Throughout the years, there have been many programming styles and fads. However, FP has proved quite resilient and is of great interest today. Why would you care to use FP? The question should rather first be,What do you want to get? and only thenDoes FP get you that?

We can certainly agree that the following list of concerns are universal. Our code should be:

• Modular: The functionality of your program should be divided into independent modules, each of which contains what it needs to perform one aspect of the program functionality. Changes in a module or function shouldn't affect the rest of the code.
• Understandable: a reader of your program should be able to discern its components, their functions, and understand their relationships without undue effort. This is highly correlated withmaintainability: your code will have to be maintained at some time in the future, to change or add some new functionality.
• Testable:unit tests try out small parts of your program, verifying their behavior with independence of the rest of the code. Your programming style should favor writing code that simplifies the job of writing unit tests. Also, unit tests are like documentation, insofar that they can help readers understand what the code is supposed to do.
• Extensible: it's a fact that your program will someday require maintenance, possibly to add new functionality. Those changes should impact only minimally (if at all) the structure and data flow of the original code. Small changes shouldn't imply large, serious refactorings of your code.
• Reusable:code reuse has the goal of saving resources, time, money, and reducing redundancy, by taking advantage of previously written code. There are some characteristics that help this goal, such asmodularity (which we already mentioned), plushigh cohesion (all the pieces in a module do belong together),low coupling (modules are independent of each other),separation of concerns (the parts of a program should overlap in functionality as little as possible), andinformation hiding (internal changes in a module shouldn't affect the rest of the system).

So, now, does FP get you these five characteristics?

• In FP, the goal is writing separate independent functions, which are joined together to produce the final results.
• Programs written in functional style usually tend to be cleaner, shorter, and easier to understand.
• Functions can be tested on its own, and FP code has advantages for that.
• You can reuse functions in other programs, because they stand on their own, not depending on the rest of the system. Most functional programs share common functions, several of which we'll be considering in this book.
• Functional code is free from side effects, which means you can understand the objective of a function by studying it, without having to consider the rest of the program.

Finally, once you get used to FP ways, code becomes more understandable and easier to extend. So, it seems that all five characteristics can be ensured with FP!

However, let's strive for a bit of balance. Using FP isn't asilver bullet that willautomagically make your code better. Some FP solutions are actually tricky — and there are developers who show much glee in writing code and then askingWhat does this do? If you aren't careful, your code may becomewrite–only, practically impossible to maintain... and there goUnderstandable,Extensible, andReusable out of the door!

Another disadvantage: you may find it harder to find FP–savvy developers. (Quick question: how manyFunctional Programmer Sought job ads have you ever seen?) The vast majority of today's JS code is written in imperative, non–functional ways, and most coders are used to that way of working. For some, having to switch gears and start writing programs in a different way, may prove an unpassable barrier. 

Finally, if you try to gofully functional, you may find yourself at odds with JS, and simple tasks may become hard to do. As we said at the beginning, we'll rather opt forSorta FP, so we won't be drastically rejecting any JS features that aren't 100% functional. We want to use FP to simplify our coding, not to make it more complex!

So, while I'll strive to show you the advantages of going functional in your code, as with any change, there will always be some difficulties. However, I'm fully convinced that you'll be able to surmount them and that your organization will develop better code by applying FP. Dare to change!

About this time, another important question that you should be asking:Is JS a functional language? Usually, when thinking about FP, the mentioned languages do not include JS, but do listless common options, such as Clojure, Erlang, Haskell, or Scala. However, there is no precise definition for FP languages or a precise set of features that such languages should include. The main point is that you can consider a language to be functional if it supports the common programming style associated with FP. 

JS has evolved through the years, and the version we'll be using is (informally) called JS8, and (formally) ECMAScript 2017, usually shortened to ES2017 or ES8; this version was finalized in June 2017. The previous versions were:

• ECMAScript 1, June 1997
• ECMAScript 2, June 1998, basically the same as the previous version
• ECMAScript 3, December 1999, with several new functionalities
• ECMAScript 5 appeared only in December 2009 (and no, there never was an ECMAScript 4, because it was abandoned)
• ECMAScript 5.1 was out in June 2011
• ECMAScript 6 (or ES6; later renamed ES2015) in June 2015
• ECMAScript 7 (also ES7, or ES2016) was finalized in June 2016
• ECMAScript 8 (ES8 or ES2017) was finalized in June 2017

JS isn't a functional language, but it has all the features we need to work as if it were. The main features of the language that we will be using are:

• Functions as first–class objects
• Recursion
• Arrow functions
• Closures
• Spread

Let's see some examples of each one, to explain why they will be useful to us.

Saying that functions arefirst class objects (also:first classcitizens) means that you can do everything with functions, that you can do with other objects. For example, you can store a function in a variable, you can pass it to a function, you can print it out, and so on. This is really the key to doing FP: we will often be passing functions as parameters (to other functions) or returning a function as the result of a function call. 

If you have been doing async Ajax calls, you have already been using this feature: acallback is a function that will be called after the Ajax call finishes and is passed as a parameter. Using jQuery, you could write something like:

$.get("some/url", someData, function(result, status) {
    //check status, and do something
    //with the result
});

The$.get() function receives a callback function as a parameter, and calls it after the result is obtained. 

This is a most potent tool for developing algorithms and a great aid for solving large classes of problems. The idea is that a function can at a certain point callitself, and whenthat call is done, continue working with whatever result it has received. This is usually quite helpful for certain classes of problems or definitions. The most often quoted example is the factorial function (the factorial ofn is writtenn!) as defined for non-negative integer values:

• Ifn is 0, thenn!=1
• Ifn is greater than 0, thenn! = n * (n-1)!

This can be immediately turned into JS code:

functionfact(n) {
    if (n === 0) {
        return 1;
    } else {
        return n *fact(n - 1);
    }
}
console.log(fact(5)); //120

Closures are a way to implement data hiding (with private variables), which leads to modules and other nice features. The key concept is that when you define a function, it can refer to not only its own local variables, but also to everything outside of the context of the function:

function newCounter() {
let count = 0;
    return function() {
        count++;
return count;
    };
}
const nc = newCounter();
console.log(nc()); //1
console.log(nc()); //2
console.log(nc()); //3

Even afternewCounter exits, the inner function still has access tocount, but that variable is not accessible to any other parts of your code.

Arrow functions are just a shorter, more succinct way of creating an (unnamed) function. Arrow functions can be used almost everywhere a classical function can be used, except that they cannot be used as constructors. The syntax is either (parameter, anotherparameter, ...etc) => {statements } or (parameter, anotherparameter, ...etc) => expression. The first one allows you to write as much code as you want; the second is short for{ returnexpression }. We could rewrite our earlier Ajax example as:

$.get("some/url", data,(result, status) =>{
    //check status, and do something
    //with the result
});

A new version of the factorial code could be:

constfact2 = n => {
    if (n === 0) {
        return 1;
    } else {
        return n * fact2(n - 1);
    }
};
console.log(fact2(5)); //also 120

In order to get out of this availability and compatibility problem, there are a couple oftranspilers that you can use. Transpilers take your original ES8 code, and transform it into equivalent JS5 code. (It's a source-to-source transformation, instead of a source-to-object code as in compilation.) You can code using advanced ES8 features, but the user's browsers will receive JS5 code. A transpiler will also let you keep up with upcoming versions of the language, despite the time needed by browsers to adopt new standards across desktop and mobile devices.

1.1. Classes as first-class objects: We saw that functions are first class objects, but did you knowclasses also are? (Though, of course, speaking of classes asobjects does sound weird...) Study this example and see what makes it tick! Be careful: there's some purposefully weird code in it:

      const makeSaluteClass = term =>
          class {
              constructor(x) {
                 this.x = x;
              }

              salute(y) {
                 console.log(`${this.x} says "${term}" to ${y}`);
               }
          };

      const Spanish = makeSaluteClass("HOLA");
      new Spanish("ALFA").salute("BETA");
      //ALFA says "HOLA" to BETA

      new (makeSaluteClass("HELLO"))("GAMMA").salute("DELTA");
      //GAMMA says "HELLO" to DELTA

      const fullSalute = (c, x, y) => new c(x).salute(y);
      const French = makeSaluteClass("BON JOUR");
      fullSalute(French, "EPSILON", "ZETA");
      //EPSILON says "BON JOUR" to ZETA

1.2.Factorial errors: Factorials, as we defined them, should only be calculated for non-negative integers. However, the function we wrote doesn't verify if its argument is valid or not. Can you add the necessary checks? Try to avoid repeated, redundant tests!

1.3.Climbing factorial: Our implementation of factorial starts multiplying byn, then byn-1, thenn-2, and so on., in what we could call a downward fashion. Can you write a new version of the factorial function, that will loopupwards?

In this chapter, we have seen the basics of functional programming, a bit of its history, its advantages (and also some possible disadvantages, to be fair), why we can apply it in JavaScript, which isn't usually considered a functional language, and what tools we'll need in order to take advantage of the rest of the book.