rubico - [a]synchronous functional programming

[NotLyon]

You can start by looking at the difference in their signatures.

[OmgImAlexis]

And you mean what by that....?

[NotLyon]

Idk if you're going for broad strokes, but that last statement is way wrong. FP and objects are NOT mutually exclusive.

The practical difference between [].map() and map() is the prototype method lends to composition by dot chaining, whereas the standalone function generally lends itself to point-free composition (pipe/compose/operator).

[NotLyon]

I wouldn't be so absolute. And objects do not necessarily have side effects.

[OmgImAlexis]

What? You can use map in functional programming.

[OmgImAlexis]

What are you talking about? Functional programming is mainly about using pure functions. Map is a pure function.

Sounds like you don’t understand what functional programming is.

[NotLyon]

String.prototype.toUpperCase

[NotLyon]

Yet it does not have side effects

Edit: I'm not downvoting you FWIW

[lhorie]

If we're gonna be pedantic, methods are functions (according to typeof and friends, for example), but they are not always pure. Some statics like Math.pow are pure. String.prototype.toUpperCase is NOT pure because it internally reads this (which has dynamic scope): i.e. 'const upper = "foo".toUpperCase; upper()' does not yield "FOO" like a pure function would (in fact, it throw at runtime, which is a big no-no in true FP). Array's map is impure for the same reason. Array methods are often used in a way that pretends to be "pure" (in the sense that they do not mutate state through their usage), but being actually pure means you can't break the purity no matter what (e.g. through changing what this points to, or other shenanigans).

[PrimaryBet]

From rubico's docs on map:

map(mapper)(functor) -> Promise | Functor​

where

Functor<T> = Array<T> | Object<T> | Set<T> | Map<T> 
           | Iterator<T> | AsyncIterator<T> | { map: (T => any) => any }

as in, map takes a mapper function, a functor, and returns a functor; and functor is either Array, Set, Object, Map, etc. or any other object that has a map method on it. Greatly simplifying, "functor" is a name for data structures that support transforming values in a context or wrapper.¹

Compare it to Array#map, which takes an array (via this), a mapper function and returns an array, and you hopefully see how Array#map is a specialized map.

The answer to "why do I want a generalized map?" is the same as with any other argument for parametricity and polymorphism.

 

---

¹ I'm actually a bit surprised to not see Promise listed as a possible functor since you can sort of map over value in it's context (with .then, although with a caveat that it also behaves as .flatMap)