My solutions to Functional Javascript Workshop https://github.com/timoxley/functional-javascript-workshop

1-hello-world.js

/*jslint node, es6, maxlen: 80 */

"use strict";

function upperCaser(input) {
    return input.toUpperCase();
}

module.exports = upperCaser;

10-partial-application-with-bind.js

/*jslint node, es6, maxlen: 80 */

"use strict";

module.exports = function (namespace) {
    return console.log.bind(console, namespace);
};

11-implement-map-with-reduce.js

/*jslint node, es6, maxlen: 80 */

"use strict";

module.exports = function arrayMap(arr, fn) {
    return arr.reduce(
        (acc, currentValue) => [...acc, fn(currentValue)],
        []
    );
};

12-function-spies.js

/*jslint node, es6, maxlen: 80 */

"use strict";

function Spy(target, method) {
    const spy = {count: 0};

    const original = target[method];

    target[method] = function (...args) {
        spy.count += 1;

        return original.apply(target, args);
    };

    return spy;
}

module.exports = Spy;

13-blocking-event-loop.js

/*jslint node, es6, maxlen: 80 */

"use strict";

function repeat(operation, num) {
    if (num <= 0) {
        return;
    }

    operation();

    return setImmediate(() => repeat(operation, num - 1), 0);
}

module.exports = repeat;

14-trampoline.js

/*jslint node, es6, maxlen: 80 */

"use strict";

function repeat(operation, num) {
    if (num <= 0) {
        return;
    }

    operation();

    return () => repeat(operation, num - 1);
}

function trampoline(fn) {
    let next = fn();

    while (next) {
        next = next();
    }
}

module.exports = function (operation, num) {
    return trampoline(() => repeat(operation, num));
};

15-async-loops.js

/*jslint node, es6, maxlen: 80 */

"use strict";

function loadUsers(userIds, load, done) {
    const users = [];

    let numberOfLoadedUsers = 0;

    userIds.forEach(
        (userId, index) => load(
            userId,
            function (user) {
                users[index] = user;

                numberOfLoadedUsers += 1;

                if (numberOfLoadedUsers === userIds.length) {
                    done(users);
                }
            }
        )
    );
}

module.exports = loadUsers;

16-recursion.js

/*jslint node, es6, maxlen: 80 */

"use strict";

function getDependencies(tree) {
    function getUniqueDependencies(subtree = {}) {
        const {dependencies} = subtree;

        if (!dependencies) {
            return {};
        }

        return Object
            .keys(dependencies)
            .reduce(
                function (acc, depName) {
                    acc[`${depName}@${dependencies[depName].version}`] =
                            undefined;

                    return Object.assign(
                        {},
                        acc,
                        getUniqueDependencies(dependencies[depName])
                    );
                },
                {}
            );
    }

    const uniqueDependencies = getUniqueDependencies(tree);

    return Object.keys(uniqueDependencies).sort();
}

module.exports = getDependencies;

16-tail-recursion.js

/*jslint node, es6, maxlen: 80 */

"use strict";

function getDependencies(tree) {
    function getDepsArray(subtree = {}) {
        if (!subtree.dependencies) {
            return [];
        }

        return Object
            .keys(subtree.dependencies)
            .map(
                (packageName) => Object.assign(
                    {name: packageName},
                    subtree.dependencies[packageName]
                )
            );
    }

    function getUniqueDependencies(depsArray, depsAcc = {}) {
        if (depsArray.length === 0) {
            return depsAcc;
        }

        const {newDepsArray, newDepsAcc} = depsArray.reduce(
            function reduce({newDepsArray, newDepsAcc}, aPackage) {
                const {name, version} = aPackage;

                newDepsAcc[`${name}@${version}`] = undefined;

                return {
                    newDepsArray: newDepsArray.concat(
                        getDepsArray(aPackage)
                    ),
                    newDepsAcc
                };
            },
            {
                newDepsArray: [],
                newDepsAcc: depsAcc
            }
        );

        return getUniqueDependencies(newDepsArray, newDepsAcc);
    }

    const deps = getDepsArray(tree);

    const uniqueDependencies = getUniqueDependencies(deps);

    return Object.keys(uniqueDependencies).sort();
}

module.exports = getDependencies;

17-currying.js

/*jslint node, es6, maxlen: 80 */

"use strict";

function curryN(fn, n) {
    const arity = n === undefined
        ? fn.length
        : n;

    return function partial(...params) {
        return params.length < arity
            ? (...rest) => partial(...params, ...rest)
            : fn(...params);
    };
}

module.exports = curryN;

18-function-call.js

/*jslint node, es6, maxlen: 80 */

"use strict";

module.exports = Function.prototype.call.bind(Array.prototype.slice);

2-higher-order-functions.js

/*jslint node, es6, maxlen: 80 */

"use strict";

function repeat(operation, num) {
    if (num <= 0) {
        return;
    }

    operation();

    return repeat(operation, num - 1);
}

module.exports = repeat;

3-basic-map.js

/*jslint node, es6, maxlen: 80 */

"use strict";

function doubleAll(numbers) {
    return numbers.map((number) => number * 2);
}

module.exports = doubleAll;

4-basic-filter.js

/*jslint node, es6, maxlen: 80 */

"use strict";

function getShortMessages(messages) {
    return messages
        .filter(function isShort({message}) {
            return message.length < 50;
        })
        .map((object) => object.message);
}

module.exports = getShortMessages;

5-basic-every-some.js

/*jslint node, es6, maxlen: 80 */

"use strict";

function checkUsersValid(goodUsers) {
    return function allUsersValid(submittedUsers) {
        return submittedUsers.every(
            (submittedUser) => goodUsers.some(
                (goodUser) => submittedUser.id === goodUser.id
            )
        );
    };
}

module.exports = checkUsersValid;

6-basic-reduce.js

/*jslint node, es6, maxlen: 80 */

"use strict";

function countWords(inputWords) {
    return inputWords.reduce(
        function countWord(counts, word) {
            counts[word] = counts[word]
                ? counts[word] + 1
                : 1;

            return counts;
        },
        {}
    );
}

module.exports = countWords;

7-recursion.js

/*jslint node, es6, maxlen: 80 */

"use strict";

function reduce(arr, fn, initial) {
    function recur(acc, tail) {
        if (tail.length === 0) {
            return acc;
        }

        const [car, ...cdr] = tail;

        return recur(
            fn(acc, car),
            cdr
        );
    }

    return recur(initial, arr);
}

module.exports = reduce;

8-basic-call.js

/*jslint node, es6, maxlen: 80 */

"use strict";

function duckCount(...ducks) {
    return ducks
        .filter((duck) => Object.prototype.hasOwnProperty.call(duck, "quack"))
        .length;
}

module.exports = duckCount;

9-partial-application-without-bind.js

/*jslint node, es6, maxlen: 80 */

"use strict";

function logger(namespace) {
    return function log(...args) {
        console.log(...[namespace, ...args]);
    };
}

module.exports = logger;