re: Any suggestions for books to learn Functional Programming Paradigm VIEW POST

VIEW PARENT COMMENT VIEW FULL DISCUSSION
 

Not sure where you got this from. Functions are absolutely first class citizens in Javascript.

 

Kind of, in JS functions are first class objects, they can have properties and other functions attached, the difference is that this objects can be called ().

When comparing to static OOP languages JS functions are high ranked citizens, you can do crazy stuff with them, now we have lamdba functions too which is more amazing.

But in functional programming functions are first class ..anything, even the operators are functions

(++)                    :: [a] -> [a] -> [a]
[]     ++ ys            =  ys
(x:xs) ++ ys            =  x : (xs++ys)

and you can overload them

fib :: Integer -> Integer
fib 0 = 1
fib 1 = 1
fib n = fib (n-1) + fib (n-2)

and many other things I do not understand yet :)

Functions in Javascript are first-class. Period. The ability to model them as objects with instance members is not relevant. The fact that Javascript separates the notion of operators and functions does not have any relevance either. Nor does the ES6 lambda syntax. Javascript has always had first-class anonymous functions! Semantically, it's not recent at all.

The term first class is well-defined in our field. If you look it up and test each requirement against the capabilities of functions in Javascript, you will see that they are indeed first class.

Functions in Javascript are first-class. Period.

This is what I usually say too, but there is no period, if you learn more advanced topics you find out that everything in JS is an object. You cannot just say is not relevant (like you say), is very relevant on THIS topic, when you compare the language to Functional Programming ones.

JS -> everything is an object
FP -> everything is a function

You can loosely say that functions are prime citizens in JS and in FP languages, but ... we have to differentiate them to a degree, world is not white and black like you say, there are many grey nuances.

In JavaScript, functions are first-class objects, because they can have properties and methods just like any other object. What distinguishes them from other objects is that functions can be called. In brief, they are Function objects. -- MDN documentation

Also Arrow (lambda called in other languages) functions are not anonymous functions, they have different implementations and effects. Anonymous is just a function without a name (which is not recommended anyway because it's harder to debug).

We are talking in circles here. Your quote is saying nothing of relevance. The ability to furnish a function with properties and methods that operate upon them does not matter at all.

Let me make this really clear.

You say: "methods [Functions] are not prime [first-class] citizens"

You are wrong.

Functions in Javascript conform to all of the requirements that make a construct first-class in a programming language.

If you still want to disagree this with, please provide a concrete example demonstrating how functions are not first-class in Javascript.

 

FP languages are a lot more than functions being first class citizens. Its also the semantics support, syntactic support, and core language facilities. An FP language is far more than providing Filter, Map, and Reduce.

Compare JavaScript and C++ to OCaml:

JavaScript (ES6):

const cf = (a) => (b) => (c) => (d) => { return a * b * c * d; }
const answer = cf(3)(4)(5)(6)
const paf = cf(3)(4)
const answer2 = paf(3)(4)

C++:

template<typename Function, typename... Arguments>
auto partial_application(Function function, Arguments... args) {
    return [=](auto... rest) {
        return function(args..., rest...);
    };
}
auto add6 = [](int a, int b, int c, int d, int e, int f) -> int { return a + b + c + d +e + f; }
auto pa1 = partial_application(add6, 4);
auto pa2 = partial_application(pa1, 5);
auto pax = pa2(10, 11, 12, 13);

auto c0 = curry(add6);
auto c1 = c0(4); // sort of kind of like pa1
auto c2 = c1(5); // sort of kind of like pa2
auto cx = c2(10)(11)(12)(13);
// note that c2 and pa2 are called in very different ways.
// cx and pax both equal 55.

OCaml/F#:

let cf a b c d = a * b * c * d 
let answer = cf 3 4 5 6 
let paf = cf 3 4
let answer2 = paf 3 4

But to JavaScript you'd need to add transitive immutability (as if all objects were made deep frozen at creation, by default, using value semantics like in mathematics), piping, implicit currying, implicit partial application, guaranteed tail recursion (because of immutability),

Yes, you can do FP style programming in JavaScript. And you can also do FP style programming in C, or in C++, or in Lisp. None of those languages are FP languages.

Functional-first FP languages are OCaml, F#, Haskell, Clojure, Elm.

Thanks for the response. My qualm, however, is only with the OPs mention of Javascripts function model. I am making no claims at all regarding where Javascript sits on the functional scale. Infact, I am not claiming Javascript is even a mildly good language for any type of programming. I am simply saying that functions in Javascript are first class constructs.

Maybe I've been misunderstood, but I am lost as to why that is a controversial comment.

You are correct. Functions in JavaScript are first class constructs.

(The OP mentioned the Functional Programming Paradigm, which JavaScript falls far short compared to functional programming languages.)

code of conduct - report abuse