SynchronousAsync.js

Infrastructure.js

let cache = new Map();
let pending = new Map();

function fetchTextSync(url) {
  if (cache.has(url)) {
    return cache.get(url);
  }
  if (pending.has(url)) {
    throw pending.get(url);
  }
  let promise = fetch(url).then(
    response => response.text()
  ).then(
    text => {
      pending.delete(url);
      cache.set(url, text);
    }
  );
  pending.set(url, promise);
  throw promise;
}

async function runPureTask(task) {
  for (;;) {
    try {
      return task();
    } catch (x) {
      if (x instanceof Promise) {
        await x;
      } else {
        throw x;
      }
    }
  }
}

Program.js

function getUserName(id) {
  var user = JSON.parse(fetchTextSync('/users/' + id));
  return user.name;
}

function getGreeting(name) {
  if (name === 'Seb') {
    return 'Hey';
  }
  return fetchTextSync('/greeting');
}

function getMessage() {
  let name = getUserName(123);
  return getGreeting(name) + ', ' + name + '!'; 
}

runPureTask(getMessage).then(message => console.log(message));

Huh, pretty cool.

The major downside is not the throw, it is that you may have to reuse some work if it does.

By this, do you mean that the "infinite" for loop will keep executing same code from start after each await, right?

@sebmarkbage
how is this better than writing fetchTextSync as generator function and using npm/co(Generator based control flow) instead of runPureTask. I mean yes, you doesn't bound to using genearor in your example, but still depends on async runPureTask.
I know it's different concepts and so on, but maybe you could explain why is your approach is generally better and what benefits it provides?