My path to JavaScript: Refactoring fizzbuzz to accept any kind of predicates on numbers for substitutions

I've been playing a bit more with scopes to make the generalized version of FizzBuzz using Array.map and Array.join I posted about recently accept substitution rules with any predicate on a number. I also coded a factory function that creates the substitute function.

This is the factory that creates a substitute function given a list of substitution descriptions objects which are composed of a predicate on the number and a replacement for the number:

	var makeSubstitute = function (substitutionDescriptions) {
	var substituteOne = (function () {
	var substitutions = [], i;
	function makeSubstitution (pred, replacement) {
	return function substituteNumber(acc, number) {
	if ( pred(number) ) {
	acc += replacement;
	}
	return acc;
	};
	}
	for(i = 0; i < substitutionDescriptions.length; i++) {
	substitutions.push(makeSubstitution(
	substitutionDescriptions[i].pred,
	substitutionDescriptions[i].replacement));
	}
	return function (number) {
	var res = (function f(acc, remainingSubstitutions) {
	if (remainingSubstitutions.length == 0) {
	return acc;
	} else {
	acc = remainingSubstitutions[0](acc, number);
	return f(acc, remainingSubstitutions.slice(1));
	}
	}("", substitutions));
	if (res != "")
	return res;
	return String(number);
	};
	}());
	return function (numbers) {
	return numbers.map(substituteOne).join(" ");
	};
	};

view raw substituteWithAnyKindOfPredicateFactory.js hosted with ❤ by GitHub

Next you can see how this factory is used in the tests to create each substitute function:

	describe("FizzBuzz", function () {
	var fizzBuzzSubstitute;
	beforeEach(function () {
	fizzBuzzSubstitute = makeSubstitute([
	{ pred: function(number) {return number % 3 == 0;},
	replacement: "Fizz"},
	{ pred: function(number) {return number % 5 == 0;},
	replacement: "Buzz"}
	]);
	});
	it("works for an empty array", function () {
	expect(fizzBuzzSubstitute([])).toBe("");
	});
	it("returns same number for array with number not multiple of 3 or 5", function () {
	expect(fizzBuzzSubstitute([1])).toBe("1");
	});
	it("returns Fizz for an array with a multiple of 3", function () {
	expect(fizzBuzzSubstitute([3])).toBe("Fizz");
	expect(fizzBuzzSubstitute([9])).toBe("Fizz");
	});
	it("returns Buzz for an array with a multiple of 5", function () {
	expect(fizzBuzzSubstitute([5])).toBe("Buzz");
	expect(fizzBuzzSubstitute([25])).toBe("Buzz");
	});
	it("returns FizzBuzz for an array with a multiple of both 3 and 5", function () {
	expect(fizzBuzzSubstitute([15])).toBe("FizzBuzz");
	});
	it("also works with arrays with more than one element", function () {
	expect(fizzBuzzSubstitute([1, 2, 15])).toBe("1 2 FizzBuzz");
	});
	});
	describe("FizzKozz", function () {
	var fizzKozzSubstitute = makeSubstitute([
	{ pred: function(number) {return number % 3 == 0;},
	replacement: "Fizz"},
	{ pred: function(number) {return number % 2 == 0;},
	replacement: "Kozz"}
	]);
	it("also works with different substitution rules", function () {
	expect(
	fizzKozzSubstitute([1, 2, 4, 6, 15])).toBe("1 Kozz Kozz FizzKozz Fizz");
	});
	});
	describe("FizzOddSeven", function () {
	var fizzOddSevenSubstitute = makeSubstitute([
	{ pred: function(number) {return number % 3 == 0;},
	replacement: "Fizz"},
	{ pred: function(number) {return number % 2 == 1;},
	replacement: "Odd"},
	{ pred: function(number) {return number == 7;},
	replacement: "Seven"}
	]);
	it("works with rules using any predicate on a number", function () {
	expect(
	fizzOddSevenSubstitute(
	[1, 2, 4, 6, 15, 7])).toBe("Odd 2 4 Fizz FizzOdd OddSeven");
	});
	});

view raw substituteFactoryTests.js hosted with ❤ by GitHub

This has been a nice practice with higher order functions, closures and free variables.
Next time, I'll move on to a new kata to practice with JavaScript objects.