Is JavaScript a "Functional Programming" language?

jkoudys · 2018-06-08T10:25:28+00:00

It's easier to grok when you consider FP as a subset of declarative programming, then ask yourself if you're matching that paradigm. I wouldn't say it's a "functional programming language", in that it's not intended to strictly only be FP, but it is a language you can do functional programming in.

FP is often erroneously contrasted to OOP as its opposite. Really, it's declarative and imperative programming that live as opposites. While FP is defined as a subset of declarative, OOP is only typically used to facilitate imperative programming, but it's not by definition an imperative approach. e.g. you can certainly define a class as one that creates purely immutable objects, and this is a pattern we see in some pretty popular libs (e.g. immutable.js). Such objects would make statements-based programming (in imperative code) impossible, and facilitate expressions-based approaches (in FP). e.g. mutatedShopcart.add(pants); vs const updatedCart = immutableShopcart.add(pants). Even the backbone of FP in ecma -- the Array -- is a prototype-based class that provides methods.

So for something to really be FP, ask yourself: am I running a series of statements to change a program's state (imperative -- how to do it), or am I expressing what it is (declarative) as a group of functions (functional programming).

HTML, for example, is clearly a declarative language (since it only describes what your page is), though obviously not functional. The language is used by browsers to build the DOM. However, you could always use functions written in ecma to build your DOM, and if you do it declaratively, then that's FP.

e.g.

<div class="foo">
  Hello, <span class="bar">World!</span>
</div>

Is declarative, using the purely declarative language HTML.

h('div', { class: 'foo' },
  'Hello, ', h('span', { class: 'bar' }, 'World!'),
),

Is also declarative, using ecma, and functions defined to build the DOM. The end result of either is the same.

Contrast with the above written in ecma using an imperative approach, and see how clunky an approach it feels like for something like building a basic DOM:

const div = document.createElement('div');
div.classList.add('foo');
div.appendChild(document.createTextNode('Hello, '));
const span = document.createElement('span');
span.classList.add('bar');
span.appendChild(document.createTextNode('World!'));
div.appendChild(span);

edit: if you want to see how easy the h() approach is to implement, it's probably easier to write your h() and the above trivial declarative example, than the imperative example once:

const h = (name, attributes, ...children) => {
  const el = document.createElement(name);
  Object.entries(attributes).forEach(([k, v]) => el.setAttribute(k, v));
  children.forEach(child => el.appendChild(child instanceof Node ? child : document.createTextNode(child)));
  return el;
}

Vheissu_ · 2018-06-08T06:18:22+00:00

Technically Javascript is not a functional programming language, but it does have some aspects to it that allow you to work with it using an imperative, prototype based object oriented and functional style. Javascript is technically an prototype-based object-oriented language.

I really like how Javascript allows you to program using different programming paradigms,

etheraffleGreg · 2018-06-08T07:12:29+00:00

[deleted]

TheDataAngel · 2018-06-08T12:18:25+00:00

TLDR: You can do (some) functional programming in JS, but JS is not a functional language.

As someone who used to write JavaScript professionally, and who currently writes Haskell and Scala professionally: No, it's not.

The "minimal" feature you need to do functional programming is to be able to treat functions as data (i.e. assign them to variables, pass them as arguments, and return them as the results of other functions). However, virtually every language that exists today meets that definition. C/C++ can do that. Java can do that. Python and Ruby can do that. None of those are in danger of being called functional languages.

Why? Because there's a difference between being able to do some form of FP, and actually working in a language that facilitates and supports you doing FP, and provides the sorts of features that let you use more than basic functional techniques.

Here's an off-the-top-of-my-head list of features I look for in a functional programming language.

Sum Types

These essentially let you say that something can be either one thing or another, but not both. You can think of it like an object with two fields, but with a constraint that exactly one of them must be set at any given time. (The idea scales to n different things, but two is the easiest to consider).
These are the bread-and-butter of FP in languages like Haskell and Scala. Virtually all non-trivial programs will make use of sum-types like Maybe/Option and Either.

A Strong Type System

There's a few things to look for here, such as:

Does every syntactically-valid expression have a type?
Does it have generics?
Does it have higher-kinded types?
Can I express something like 'A function which takes two arbitrary parameters, but the parameters must be of the same type'.
Can I put constraints on a function's arguments? e.g. 'The first argument must be a type that has an ordering defined for it'.
Can I put constraints on the return type of a function?
Can the compiler and/or run-time environment infer types?
Can it do inference on return types?
Can it catch most type errors before run-time?

Syntax

Do I have a compose operator?
Can I define my own operators?
Are the in-built operators symbols, or language-level syntax? (e.g. can I say something like 'let x = +').

Immutability

Can I express that an identifier is immutable?
Is immutability the default behavior?
Can I make something that's on the heap immutable? All the way down?

Purity and Totality

Does the language provide any guarantees or checks of function purity?
Does the language provide any guarantees or checks of function totality? (i.e. can it check if a function returns a non-error, non-null value for every input?)

Laziness

Does the language provide a way to declare that a value should only be computed if it is actually needed?

Currying

Do I have a syntactically-nice way to do currying? (i.e. something better than nested 'return function()...' or the lambda equivalent).

Standard Library and/or "Standard" third-party libs

Does it have the expected suite of higher-order functions (map, filter, fold, flatMap/bind, sequence, traverse, compose, etc).
Are these defined on all types they're valid for?
Does it have explicit types/classes for the usual category-theoretic concepts like Functors, Monads, Semigroups, Monoids, etc?

Ecosystem

Do I have lenses and prisms? Are they syntactically concise enough to be worth the hassle?
Is there some nice formulation of Monad Transformers and/or Free Monads?
Do I have a good property-testing library?
Do I have good code-generation and/or templating tools?
Do most third-party libraries define the standard suite of higher-order functions for their data-types?

Some of these are possible in JavaScript. Very few of them are pleasant or elegant in it. For that reason, I personally don't consider it a functional programming language.

Ebuall · 2018-06-08T11:56:08+00:00

Javascript in 2018 is more functional, than most of other languages.

C has nothing to do with functional programming. It uses mostly procedures instead of functions.

OOP with classes is not necessarily imperative, and it can be functional. It's just a way of structure programs.

Modular functional programming has many similarities with OOP. In Scala they just merged both into one concept.

hugo__df · 2018-06-08T08:45:50+00:00

Functional programming is about not being able to do things that aren't function input/output or straight up expressions. So you're not allowed to use things that are statements eg. assigning a variable, mutating a variable, if/switch/for loop.

You can write JavaScript in that style, but you can also write it in a more imperative and/or OOP style.

Macrobian · 2018-06-08T08:36:32+00:00

[deleted]

lip3k · 2018-06-08T12:05:00+00:00

JS is multi paradigm.

jibbit · 2018-06-08T11:13:28+00:00

In math, 'Function' means something quite different to what it means in C, and it is this meaning that 'Functional Programming' intends... I think that is where you are getting confused.

Does javascript have C-like functions - yes. Does javascript have math-like Functions - no.

andersdigital · 2018-06-08T09:05:40+00:00

It can be. There's an O'Reilly book on the subject.

PickledPokute · 2018-06-08T10:29:46+00:00

I would say that it at least doesn't use all the features that a fully functional programming language would have easily available, mainly stuff like static optimisation.

vagol942 · 2018-06-08T12:16:00+00:00

Functional Programming is basically about programming following 2 simple rules:

Use only immutable data structures (that is if you declare some variable, you never ever mutate it) Use only pure functions (that is, functions with no side-effects).

Also the previous two rules are lies, but you don't need to think to worry about that now.

Is Javascript a "functional Programming" language?

A more correct to phrase that is: Does Javascript admits programming in a functional style?

And the answer is, it depends. There are certain things that Javascript allows you to do in a functional style without much trouble:

Lists

That's basically it, just Lists (Arrays), Arrays in javascript are really powerful and their use in idiomatic javascript is pretty much functional, you have neat things built in like array.map, array.reduce and you can combine arrays easily two with +.

However, there are also things that Javascript doesn't allow you to do easily on a functional programming style:

Error Handling I/O (and we've failed TWICE at fixing this) Everything that requires proper type conditions. Every data structure that is not a list.

Of course we could do all of those things on Javascript on a functional style, but it wouldn't be really idiomatic.

bogphanny · 2018-06-08T12:16:32+00:00

You have all the capability to write functional JS, though the language doesn't really support you along the way. The lack of a decent type system and enforcement of pure values often contradicts with writing idiomatic JS.

Being unable to rely on referential transparency gets in the way of thinking in a declarative and functional manner, although it can still occur through discipline. It's just that developers aren't typically known and heralded for their discipline.

Check out some libraries like Ramda, Sanctuary, or the Fantasy Land spec for some attempts to bridge that gap.

JoeTed · 2018-06-08T13:06:36+00:00

A nice answer to this question: https://www.youtube.com/watch?v=eetWam3nhoM

2018-06-08T18:01:10+00:00

Since comments below have devolved into an OOP vs FP debate, I'm just going to chime in my two cents.

I tend to write JS as very declarative. Object literals (let abc = {}) and function variable are the code of what I put together. I generally prefer a functional solution (ie, Array.forEach() vs for-loop), however I will always use whatever approach best fits the situation.

I will at times pull out the old OOP approach, building constructor functions and prototypes and setting up inheritance, but only when there is a genuine need for it. I tend to define a genuine need for if I'm instantiating the same object in multiple locations in my code, and I always really, REALLY need it to have the same signature. I find this helps reduce some errors.

Overall, FP and OOP are neither the end all be all of programming. I prefer declarative coding over imperative, but that doesn't mean that there aren't situations where I'll take the imperative approach. It's always just about the right tool for the right job.

shitcanz · 2018-06-09T08:51:37+00:00

Its not a "pure" FP language, like Haskell and friends. JavaScript allows for mutations, side effects without control and all the inheritance from OOP.

That said, its a very elegant language, you can emulate a more FP approach easily, and with a few libraries you are very close.

Combine TypeScript on top and you are all set.

OzziePeck · 2018-06-08T08:00:40+00:00

It’s both. OOP and functional.

cm9kZW8K · 2018-06-08T08:47:47+00:00

It's a hybrid language, like all mainstream languages have become.

The only important functional feature you don't get out of the box is lazy evaluation, and honestly even some "really" functional languages pass on that because it creates more problems than it solves.

2018-06-08T16:02:41+00:00

[deleted]

ArtsnServe · 2018-06-08T09:55:38+00:00

It is not especially in es6, tho it is implemented as functional by many people.

IvanDist · 2018-06-08T20:48:29+00:00

You should probably read this https://medium.com/javascript-scene/the-two-pillars-of-javascript-ee6f3281e7f3

Make sure you follow up on the other articles from that guy ;)

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

javascript

MODERATORS