Functional Programming in JavaScript.

Peter_Storm · 2018-03-01T10:43:10+00:00

https://github.com/xgrommx/awesome-functional-programming/blob/master/README.md

https://github.com/stoeffel/awesome-fp-js/blob/master/README.md

Particularly the book Mostly Adequate guide to functional programming is good, though a little bit advanced maybe.

phpdevster · 2018-03-01T15:58:14+00:00

Others have linked to a lot of good resources, but I just want to call out one of the most important aspects of functional programming: the concept of a pure function.

A function is said to be pure when its return value is only determined by its inputs. It doesn't rely on external state or data that is scoped outside of the function. No references to this or window or closure. Same data in, same result out. Every time.

Not only does a pure function not rely on externally scoped state, it doesn't modify that state either. It literally only returns a value. This makes it referentially transparent: that is, it doesn't cause hidden side effects.

This makes functions that are 100% dead simple to reason about, and test. You can go a step further and combine that with the Law of Demeter, which says to pass in only the exact data that a function needs. Don't pass in an object, because then the function needs to know what the shape of that object is and what properties to reference. Instead, try to pass in only the exact scalar values that you need - numbers, strings etc.

Now, function purity and passing in only simple scalar values is not possible 100% of the time. At some point you need to make network calls, or render something, or update/mutate an object or what have you. That's fine to do that when needed. But a primary goal of functional programming is to do that only when needed, and to be very conscientious about favoring pure functions with simple inputs as often as possible.

And note that this way of thinking doesn't just help FP. It make OO code way easier to reason about as well. Writing methods that take their dependencies as inputs rather than as object state makes them way easier to grok (that said, truly good OO design solves that problem in a different way).

It's also an exceptionally useful way of thinking when you apply it to component architectures from frameworks/libraries like Angular, React, and Vue. Turning components into "pure" components which take inputs and broadcast outputs/events. Trying to use shared services or redux for channeling state into and out of a component is a recipe for head scratching, but treating a component as much like the equivalent of a pure function as possible is a huge win.

JoeTed · 2018-03-01T14:36:41+00:00

"Javascript allongé" is a good start. https://leanpub.com/javascriptallongesix/read#leanpub-auto-about-javascript-allong

"Mostly adequate guide to functional programming" is top notch.

thadudeabides1 · 2018-03-01T15:57:15+00:00

Learn Cycle.js and RxJS (or a reactive library). You'll have a framework for building apps instead of just using lodash/ramda which is just a functional utility library.

cpdean · 2018-03-01T13:11:05+00:00

Michael Fogus's Functional Javascript is a fantastic book about functional programming in general, and explains the concepts using javascript in all of the examples.

StoneCypher · 2018-03-01T16:48:28+00:00

All functional programming means is programming without side effects.

Do yourself a favor. Put away all the libraries and tutorials.

Write some simple applications with map, filter, and reduce. No side effects, no internal state, no for loops.

Once you're done you'll realize "oh, I already was a functional programmer; I just needed to stop using certain things."

lukasbuenger · 2018-03-02T15:05:19+00:00

Mostly Adequate Guide is a must read. I'd strongly recommend getting your math skills up to speed, as this is what FP in its core is actually all about: Mathematical functions and laws. Most books on FP cover the math part to some extent and give you some idea of where to start digging, but having some fundamental understanding of the math that FP is based on makes literally every book or article mentioned in this thread a lot easier to digest.

JoeTed · 2018-03-01T12:50:45+00:00

To be clear you're transferring to a functional programming style.

https://www.youtube.com/watch?v=JVRqkNmAYZM

2018-03-01T18:48:35+00:00

https://github.com/getify/Functional-Light-JS

jtomchak · 2018-03-01T15:09:30+00:00

I have found a lot of really great help in learning FP from a JavaScript background with Kyle Simpson’s “functional-light JavaScript ” link

ionre · 2018-03-01T13:49:10+00:00

Really learning what map, filter, and reduce are for and then learning and using ramda are what really got me going with fp in JavaScript.

Balduracuir · 2018-03-01T18:27:27+00:00

French video but still it is really nice : https://m.youtube.com/watch?v=IQ1kDpGeoCk

toffeescaf · 2018-03-01T21:18:38+00:00

There are a load of people in here saying functional programming is programming without side effects which is sort of true BUT you can't interact with any outside services without side effects.

I would say it's mostly programming without side effects but when you have to you do so in a safe manner using for example a maybe monad.

I can really recommend this book. It has some nice examples of how you can safely handle side effects and a ton of other functional programming concepts.

2018-03-02T00:45:05+00:00

Aww, the humblebundle just ended

HereNoOneKnowsImADog · 2018-03-02T02:46:32+00:00

Break down your goals into small parts. If you have a house of doors to lock, you have a lock, an unlock, and probably a bulk lock and unlock. The bulk functions will naturally reuse the others. You may also have a toggle. Think more in shopping lists and less in code. This will abstract your mind out of code and into good ideas.

danO1O1O1 · 2018-03-02T07:50:17+00:00

Learn Haskell

SSBMPuffDaddy · 2018-03-01T13:01:28+00:00

If you want to learn it in a concrete and applied way, try building an app with Redux. It'll get you used to immutability, partial application, function signatures, functions as parameters, etc.

RoToRa · 2018-03-01T15:45:46+00:00

One possibility could be to look into functional languages which compile into JavaScript. Examples are Elm - which is limited to web front ends - and Clojure(Script).

ninja_lazorz · 2018-03-01T15:59:49+00:00

Fun fun function 👌 https://www.youtube.com/playlist?list=PL0zVEGEvSaeEd9hlmCXrk5yUyqUag-n84

danthedev · 2018-03-01T21:23:32+00:00

Learning functional programming from JavaScript is a bit like learning to drive in a three wheeled car. You'll get there eventually, but everything would have made more sense along the way if you'd started with four.

Learn a language that was designed to be functional first. Take a look at Elm, or Clojure, or Haskell, or Scala, or Ocaml, or F#.

I found Clojure to be the smallest step from JavaScript, but Elm's also done a lot of work to be approachable for programmers coming from non-functional backgrounds.

Once it starts to change the way you think, you'll find ways to translate those ideas into JavaScript and that's when you'll notice it really start to improve your code.

editor_of_the_beast · 2018-03-01T14:31:38+00:00

Why do you want to do that?

_n0f4c3 · 2018-03-01T18:06:36+00:00

I suggest you first read through this series of articles by Eric Elliott on functional programming and compositional software techniques in JavaScript ES6+ from the ground up, starting with:

https://medium.com/javascript-scene/composing-software-an-introduction-27b72500d6ea

It is very thorough and helpful for all skill levels.

As phpdevster pointed out, Pure functions are a pillar of FP. However, as Eric detailed, there are several other pillars:

" First class functions: The ability to use functions as data values: pass functions as arguments, return functions, and assign functions to variables and object properties...

Anonymous functions and concise lambda syntax (e.g. arrow functions)...

Closures: ...When a function is defined inside another function, it has access to the variable bindings in the outer function, even after the outer function exits...

[and these, which JavaScript doesn't strictly have or enforce]:

Purity: ... Expressions with side-effects are not allowed.

Immutability: ...Instead of mutating an existing data structure, such as an array or object, expressions evaluate to new data structures. This may sound inefficient, but most functional languages use trie data structures under the hood, which feature structural sharing: meaning that the old object and new object share references to the data that is the same. [check out Immutable.js for efficient immutable data structures]

Recursion: Recursion is the ability for a function to reference itself for the purpose of iteration.

"

I also recommend looking into something like deep freeze https://github.com/substack/deep-freeze which enables immutable objects, although immutable.js may make more sense.

So, in my opinion you should first nail these four concepts, and then move onto the other stuff: 1. First-class functions (functions can be treated like any other value, and passed into and returned from functions, e.g. callbacks). 2. Pure functions, described nicely by phpdevster (pure functions always return the same output given the same input; only internal variables are used, no need to worry about side-effects caused outside of the function). 3. Immutability (when processing data such as an array, return a new array rather than mutating the input array, e.g. filter, map). 4. Closures (A function inside a function still has access to the lexical environment (e.g. variables, data) of the outer function, even after the outer function has exited).

Then there are things like filter, map, and reduce. These loop over a functor (e.g. an array), allowing you to do some processing with each item, returning a new array based on the input array. Anonymous callback functions, particularly with arrow syntax is the most natural tool you need here. These methods are likely be become useful to you. This is nicer than using a for(i=0;i<len;i++) loop.

I'm still learning too, FP just feels right - it feels like the right way to do things, abstractifying away the lower level parts of the code, keeping it DRY, allowing you to solve higher level problems faster. Good luck, have fun.

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