Currying Functions with Named Parameters in JavaScript

curryNamed.js

/**
 * Currying Functions with Named Parameters.
 * @gunar, @drboolean, @dtipson 2016
 * 
 * Why does it return a thunk, though?
 *   Because in JS named arguments are opaque. There is no way of getting a function's named arguments list.
 *   e.g.
 *     const foo = function ({ a, b }) { }
 *     console.log(foo.arguments) // Throws. Ideally would return ['a', 'b'].
 * 
 * What would be an alternative?
 *   Providing a "spec". curryNamed would have to be told what the named arguments were upfront
 *   (as curryN does with numbered arguments). I personally think that's less useful.
 */
 
'use strict'

function curryNamed(fn, acc = {}) {
  return args => {
    if (!args) return fn(acc)
    return curryNamed(fn, Object.assign({}, acc, args))
  }
}

const foo = ({ a, b, c } = {}) => console.log({ a, b, c })
const bar = curryNamed(foo)

bar() // { a: undefined, b: undefined, c: undefined }

const a = bar({ a: 1 })
a() // { a: 1, b: undefined, c: undefined }

const ab = a({ b: 2 })
ab() // { a: 1, b: 2, c: undefined }

bar({ a: 1, b: 2, c: 3 })() // { a: 1, b: 2, c: 3 }

NB: There's still room to make it context aware i.e. this.

Having to "spec" all arguments beforehand would suck

  const bar = curryNamed(foo, ['a', 'b', 'c'])

but there's a middle path. Using just a number, like curryN does.

'use strict'

function curryNamedN(fn, len = 0, acc = {}) {
  if (len < 1) return fn(Object.assign({}, acc))
  return (args = {}) => {
    const _len = len - Object.keys(args).length
    return curryNamedN(fn, _len, Object.assign({}, acc, args))
  }
}

// @gunar
const foo = ({ a, b, c } = {}) => console.log({ a, b, c })
const bar = curryNamedN(foo, 3)

bar() // undefined

const a = bar({ a: 1 }) // undefined
const ab = a({ b: 2 }) // undefined
ab({ c: 3 }) // { a: 1, b: 2, c: 3 }

bar({ a: 1, b: 2, c: 3 }) // { a: 1, b: 2, c: 3 }

Is this desired though?

bar({a:6,b:2,z:7});//->Object {a: 6, b: 2, c: undefined}

If the number of props is all it knows, then there's nothing guaranteeing that the named props used in the function will all be there, so they can't be relied on either in the function or any functions this one is composed with.

You are correct. This should be the format:

const curried = curryNamed(fn, ['user', 'client']);
curried({ user: 1 });
curried({ client: 2 }) // evaluates "fn";

There y'all go

https://github.com/gunar/ncurry

It accepts partial application and stuff.