Declarative functions

In some functional programming languages there is this one function called ap, which is short for apply, is basically .map's long lost brother.

You see with .map you apply a callback to a value inside a data structure, and it all works great. But what if your callback is also trapped inside a data structure? that's where .ap comes in, it will figure out all the details to get the values out of the data structures and apply them.

An interesting example where this could be useful is if you try to make your own improvised "validation framework". Using plain objects as our data structures, we could implement map and ap for them.

const Obj = {
  map(fn, data) {
    let result = {};

    for (let key in data) {
      result[key] = fn(data[key]);
    }

    return result;
  },
  ap(Fns, data) {
    let result = {};

    for (let key in data) {
      result[key] = Fns[key](data[key]);
    }

    return result;
  },
};

Now imagine we have this input.

const badinput = {
  password: "Anima",
  username: "O",
  email: ""
};

If you want to validate that all you have to do is wrap your validation functions inside an object of the same shape.

const validations = {
  password: is_strong_password,
  username: is_required,
  email: is_email,
};

With that in place you just apply them.

Obj.ap(validations, badinput);

That will return an object of the same shape but with the result data of each validation. Since these are all plain functions you can do all sorts of crazy stuff inside them, you can have multiple validations inside one function, you can have it return a lot metadata... well anything you can think of.

Try out pipe and tap. pipe takes an array of functions and lets you chain them together so that the return value of one function becomes the first argument to the next. tap takes a function and some input, calls the function with input, and returns the original input (good for effects). Both of these functions used together can get you started composing functions pretty fast. Here are some implementations for the functions.

const functionConcat = (funcA, funcB) => value => funcB(funcA(value))

// pipe(funcs Array<function>)(value any) -> any
const pipe = funcs => funcs.reduce(functionConcat)

const tap = func => value => {
  func(value)
  return value
}

Example with pipe, tap, map, and filter

pipe([
  filter(number => number % 2 == 1), // isOdd
  map(number => number ** 2), // square
  tap(console.log),
])([1, 2, 3, 4, 5]) // -> [1, 9, 25]

I created a library with async-capable versions of the above and more. Check it out at rubico.land