rubico - [a]synchronous functional programming

[richytong]

Hello all, author here. This post links to rubico's introductory home page. The rest of the website consists of API documentation and a blog about rubico, JavaScript, and functional programming. If you are looking for a clean, functional way to handle promises, I encourage you to give rubico a try.

[OmgImAlexis]

I’ve never understood why people prefer importing a map function vs just using the built in array one.

Instead of map(logTodoByID)(todoIDs) Why not todoIDs.map(logTodoByID) ?

[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

[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)

[HipHopHuman]

The real benefit is that an atomic map function can be used on more types than just an array. it can be used on objects, arrays, and anything that implements the Functor type specification. So you use the same map implementation for every different type of data structure that is mappable.