I'm refactoring some old node modules into a more functional style. I'm like a second year freshman when it es to FP :) Where I keep getting hung up is handling large async flows. Here is an example where I'm making a request to a db and then caching the response:

// Some external xhr/promise lib
const fetchFromDb = make => {
  return new Promise(resolve => {
    console.log('Simulate async db request...'); // just simulating a async request/response here.
    setTimeout(() => {
      console.log('Simulate db response...');
      resolve({ make: 'toyota', data: 'stuff' }); 
    }, 100);
  });
};

// memoized fn
// this caches the response to getCarData(x) so that whenever it is invoked with 'x' again, the same response gets returned.
const getCarData = R.memoizeWith(R.identity, (carMake, response) => response.data);

// Is this function pure? Or is it setting something outside the scope (i.e., getCarData)?
const getCarDataFromDb = (carMake) => {
  return fetchFromDb(carMake).then(getCarData.bind(null, carMake));
  // Note: This return statement is essentially the same as: 
  // return fetchFromDb(carMake).then(result => getCarData(carMake, result));
};

// Initialize the request for 'toyota' data
const toyota = getCarDataFromDb('toyota'); // must be called no matter what

// Approach #1 - Just rely on thenable
console.log(`Value of toyota is: ${toyota.toString()}`);
toyota.then(d => console.log(`Value in thenable: ${d}`)); // -> Value in thenable: stuff

// Approach #2 - Just make sure you do not call this fn before db response.
setTimeout(() => { 
  const car = getCarData('toyota'); // so nice!
  console.log(`later, car is: ${car}`); // -> 'later, car is: stuff'
}, 200);

<script src=".25.0/ramda.min.js"></script>

I'm refactoring some old node modules into a more functional style. I'm like a second year freshman when it es to FP :) Where I keep getting hung up is handling large async flows. Here is an example where I'm making a request to a db and then caching the response:

// Some external xhr/promise lib
const fetchFromDb = make => {
  return new Promise(resolve => {
    console.log('Simulate async db request...'); // just simulating a async request/response here.
    setTimeout(() => {
      console.log('Simulate db response...');
      resolve({ make: 'toyota', data: 'stuff' }); 
    }, 100);
  });
};

// memoized fn
// this caches the response to getCarData(x) so that whenever it is invoked with 'x' again, the same response gets returned.
const getCarData = R.memoizeWith(R.identity, (carMake, response) => response.data);

// Is this function pure? Or is it setting something outside the scope (i.e., getCarData)?
const getCarDataFromDb = (carMake) => {
  return fetchFromDb(carMake).then(getCarData.bind(null, carMake));
  // Note: This return statement is essentially the same as: 
  // return fetchFromDb(carMake).then(result => getCarData(carMake, result));
};

// Initialize the request for 'toyota' data
const toyota = getCarDataFromDb('toyota'); // must be called no matter what

// Approach #1 - Just rely on thenable
console.log(`Value of toyota is: ${toyota.toString()}`);
toyota.then(d => console.log(`Value in thenable: ${d}`)); // -> Value in thenable: stuff

// Approach #2 - Just make sure you do not call this fn before db response.
setTimeout(() => { 
  const car = getCarData('toyota'); // so nice!
  console.log(`later, car is: ${car}`); // -> 'later, car is: stuff'
}, 200);

<script src="https://cdnjs.cloudflare./ajax/libs/ramda/0.25.0/ramda.min.js"></script>

I really like memoization for caching large JSON objects and other puted properties. But with a lot of asynchronous requests whose responses are dependent on each other for doing work, I'm having trouble keeping track of what information I have and when. I want to get away from using promises so heavily to manage flow. It's a node app, so making things synchronous to ensure availability was blocking the event loop and really affecting performance.

I prefer approach #2, where I can get the car data simply with getCarData('toyota'). But the downside is that I have to be sure that the response has already been returned. With approach #1 I'll always have to use a thenable which alleviates the issue with approach #2 but introduces its own problems.

Questions:

1. Is getCarFromDb a pure function as it is written above? If not, how is that not a side-effect?
2. Is using memoization in this way an FP anti-pattern? That is, calling it from a thenable with the response so that future invocations of that same method return the cached value?

• javascript
• node.js
• asynchronous
• functional-programming
• ramda.js

• why we are not using when then function? – Negi Rox Commented Feb 9, 2018 at 18:16
• 2 Is getCarFromDb a pure function as it is written above?" It's not. Anything that accesses I/O is impure. – JLRishe Commented Feb 9, 2018 at 18:20

2 Answers 2

Question 1

It's almost a philosophical question here as to whether there are side-effects here. Calling it does update the memoization cache. But that itself has no observable side-effects. So I would say that this is effectively pure.

Update: a ment pointed out that as this calls IO, it can never be pure. That is correct. But that's the essence of this behavior. It's not meaningful as a pure function. My answer above is only about side-effects, and not about purity.

Question 2

I can't speak for the whole FP munity, but I can tell you that the Ramda team (disclaimer: I'm a Ramda author) prefers to avoid Promises, preferring more lawful types such Futures or Tasks. But the same questions you have here would be in play with those types substituted for Promises. (More on these issues below.)

In General

There is a central point here: if you're doing asynchronous programming, it will spread to every bit of the application that touches it. There is nothing you will do that changes this basic fact. Using Promises/Tasks/Futures helps avoid some of the boilerplate of callback-based code, but it requires you to put the post response/rejection code inside a then/map function. Using async/await helps you avoid some of the boilerplate of Promise-based code, but it requires you to put the post reponse/rejection code inside async functions. And if one day we layer something else on top of async/await, it will likely have the same characteristics.

(While I would suggest that you look at Futures or Tasks instead of Promises, below I will only discuss Promises. The same ideas should apply regardless.)

My suggestion

If you're going to memoize anything, memoize the resulting Promises.

However you deal with your asynchrony, you will have to put the code that depends on the result of an asynchronous call into a function. I assume that the setTimeout of your second approach was just for demonstration purposes: using timeout to wait for a DB result over the network is extremely error-prone. But even with setTimeout, the rest of your code is running from within the setTimeout callback.

So rather than trying to separate the cases for when your data has already been cached and when it hasn't, simply use the same technique everywhere: myPromise.then(... my code ... ). That could look something like this:

// getCarData :: String -> Promise AutoInfo
const getCarData = R.memoizeWith(R.identity, make => new Promise(resolve => {
    console.log('Simulate async db request...')
    setTimeout(() => {
      console.log('Simulate db response...')
      resolve({ make: 'toyota', data: 'stuff' }); 
    }, 100)
  })
)

getCarData('toyota').then(carData => {
  console.log('now we can go', carData)
  // any code which depends on carData
})

// later
getCarData('toyota').then(carData => {
  console.log('now it is cached', carData)
})

<script src="//cdnjs.cloudflare./ajax/libs/ramda/0.25.0/ramda.min.js"></script>

In this approach, whenever you need car data, you call getCarData(make). Only the first time will it actually call the server. After that, the Promise is served out of the cache. But you use the same structures everywhere to deal with it.

I only see one reasonable alternative. I couldn't tell if your discussion about having to have to wait for the data before making remaining calls means that you would be able to pre-fetch your data. If that's the case, then there is one additional possibility, one which would allow you to skip the memoization as well:

// getCarData :: String -> Promise AutoInfo
const getCarData = make => new Promise(resolve => {
  console.log('Simulate async db request...')
  setTimeout(() => {
    console.log('Simulate db response...')
    resolve({ make: 'toyota', data: 'stuff' }); 
  }, 100)
})

const makes = ['toyota', 'ford', 'audi']

Promise.all(makes.map(getCarData)).then(allAutoInfo => {
  const autos = R.zipObj(makes, allAutoInfo)
  console.log('cooking with gas', autos)
  // remainder of app that depends on auto data here
})

<script src="//cdnjs.cloudflare./ajax/libs/ramda/0.25.0/ramda.min.js"></script>

But this one means that nothing will be available until all your data has been fetched. That may or may not be all right with you, depending on all sorts of factors. And for many situations, it's not even remotely possible or desirable. But it is possible that yours is one where it is helpful.

One technical point about your code:

const getCarDataFromDb = (carMake) => {
  return fetchFromDb(carMake).then(getCarData.bind(null, carMake));
};

Is there any reason to use getCarData.bind(null, carMake) instead of () => getCarData(carMake)? This seems much more readable.

Is getCarFromDb a pure function as it is written above?

No. Pretty much anything that uses I/O is impure. The data in the DB could change, the request could fail, so it doesn't give any reliable guarantee that it will return consistent values.

Is using memoization in this way an FP anti-pattern? That is, calling it from a thenable with the response so that future invocations of that same method return the cached value?

It's definitely an asynchrony antipattern. In your approach #2 you are creating a race condition where the operation will succeed if the DB query pletes in less than 200 ms, and fail if it takes longer than that. You've labeled a line in your code "so nice!" because you're able to retrieve data synchronously. That suggests to me that you're looking for a way to skirt the issue of asynchrony rather than facing it head-on.

The way you're using bind and "tricking" memoizeWith into storing the value you're passing into it after the fact also looks very awkward and unnatural.

It is possible to take advantage of caching and still use asynchrony in a more reliable way.

For example:

// Some external xhr/promise lib
const fetchFromDb = make => {
  return new Promise(resolve => {
    console.log('Simulate async db request...')
    setTimeout(() => {
      console.log('Simulate db response...')
      resolve({ make: 'toyota', data: 'stuff' }); 
    }, 2000);
  });
};

const getCarDataFromDb = R.memoizeWith(R.identity, fetchFromDb);

// Initialize the request for 'toyota' data
const toyota = getCarDataFromDb('toyota'); // must be called no matter what

// Finishes after two seconds
toyota.then(d => console.log(`Value in thenable: ${d.data}`));


// Wait for 5 seconds before getting Toyota data again.
// This time, there is no 2-second wait before the data es back.
setTimeout(() => { 
    console.log('About to get Toyota data again');
    getCarDataFromDb('toyota').then(d => console.log(`Value in thenable: ${d.data}`));
}, 5000);

<script src="https://cdnjs.cloudflare./ajax/libs/ramda/0.25.0/ramda.min.js"></script>

The one potential pitfall here is that if a request should fail, you'll be stuck with a rejected promise in your cache. I'm not sure what would be the best way to address that, but you'd surely need some way of invalidating that part of the cache or implementing some sort of retry logic somewhere.