Bluebird

bluebird (aka B combinator), which is written:

(b -> c) -> (a -> b) -> a -> c
// f => g => a => c => f(g(a)))

The bluebird combinator represents function composition, which is probably the most basic (and maybe important, too) concept in functional (composable) programming. I’m not going to try to define and deep-dive into what function composition is here, but the core idea here is that you have two functions, one (f) which takes an a and returns a b, and one (g) which takes a b and returns a c, where f accepts as its argument the result of g. As you may be able to see, the value you pass in (a) flows through the functions from right to left.

In a totally imperative form, it could look like this:

const someMath = a => {
  const fn1 = a => a+1
  const fn2 = b => Math.floor(b/2)
  const output1 = fn1(a)
  const output2 = fn2(output1)
  return output2
}

Do you see how fn2 depends on the output of fn1? I’m sure this is a familiar pattern. So what is wrong with this? Not really anything, I guess, but in taking a, adding 1, and then dividing by 2, (basic math, right?) you’ve introduced one of the most difficult things in programming: Naming Things. Take this example as an alternative:

const someMath = a => bluebird(b => Math.floor(b/2))(a => a+1)(a)

How many intermediary values? None.

Bluebird_

bluebird_ (aka B` combinator), which is written:

(a -> c -> d) -> a -> (b -> c) -> b -> d
// f => a => g => b) => f(a)(g(b)))

The bluebird_ combinator is a slightly more abstract version of bluebird in that it still performs function composition, but the outer function (f) is a higher-order function in that it returns a function. This can be useful (among many other situations) when you really want to avoid intermediary values. Consider the following examples:

const bluebird = (b -> c) -> (a -> b) -> a -> c
const add = a => b => a+b
const addN = n => add(n)
const add10 = addN(10)
["1", "2", "3"].map(bluebird(add10)(parseInt))
// [ "11", "12", "13" ]

const bluebird_ = (a -> c -> d) -> a -> (b -> c) -> b -> d
const add = a => b => a+b
const addN = n => add(n)
["1", "2", "3"].map(bluebird(addN)(10)(parseInt))
// [ "11", "12", "13" ]

Granted there are no big wins here, but I guess this is a pretty contrived example. The key here, though, is that you can avoid declaring these intermediary values (the function add10 here) that don’t necessarily have any value on their own.

Try It On Your Own

Can you use bluebird to compose a higher-order function? ie: A function that accepts a function and/or returns a function?

Since both bluebird and bluebird_ compose together only two functions, can you make a function using either or both to create a composition of more than two functions? How about an odd number of functions vs and even number?

Next up: bluebird