# Simple and Recursive Javascript Promises

When I learned functional programming, one of the most exciting moments was the realization that recursive functions can replace all for- and while-loops. Being able to use recursion effectively means that you can generalize `for` and `while` into something simpler and more powerful. Not that you always should, but this post is an example of exactly why such a thing is both powerful and practical.

To start with, here’s a recursive factorial function, the “Hello World” of recursion.

``````function factorial(n) {
if (n < 2) return 1;
return n * factorial(n - 1);
}``````

It’s not too difficult to understand or write, because multiplication is instantaneous, but what if the multiplication function returned a promise, like this?

``````function multiplyAsync(a, b) {
return Promise.resolve(a * b);
}``````

How would you write a factorial function if you had to use the above `multiplyAsync`? Since the multiply function returns a promise, the factorial function will have to return a Promise too. Here’s one way to do it:

``````function factorialAsync(n) {
if (n < 2) return Promise.resolve(1);
return factorialAsync(n - 1)
.then(n1 => multiplyAsync(n1, n));
}``````

This technique works for factorials, but not when order of operations matter, since it works “right-to-left”. What if we were trying to apply a list of changes to a database? Given:

``````[
{ user: 'Jeff', food: 'Ice Cream' },
{ user: 'Sonic', food: 'Chili Dogs' },
{ user: 'Donatello', food: 'Pizza' },
{ user: 'Jeff', food: 'Cheesecake' }
]``````

You would expect the fourth entry to overwrite the first. If we use the technique above, the code would expand to:

``````db.insert('Jeff', 'Cheesecake')
.then('Donatello', 'Pizza')
.then('Sonic', 'Chili Dogs')
.then('Jeff', 'Ice Cream');``````

Backwards.

For example, what if we were trying to insert over 9000 things into a database in groups of 500? The above method would insert the last 500 things first, then the previous 500, and so on. Not very desirable behavior.

So, if your database library gives you a function like

``db.insertRecords(records); // returns a promise``

How would you write the following function?

``````function insertToDatabaseInBatches(recordsToInsert, batchSize) {
// A little help?
}``````

Here’s the best I could come up with:

``````function insertToDatabaseInBatches(recordsToInsert, batchSize) {
if (recordsToInsert.length === 0) return Promise.resolve();

const batch = recordsToInsert.slice(0, batchSize);
const remaining = recordsToInsert.slice(batchSize);

return db.insertRecords(batch)
.then(() => insertToDatabaseInBatches(remaining, batchSize));
}``````

Inserting a bunch of records into a database, in batches, asynchronously, in 7 lines of code. Not bad, recursion.