F-AA-for-ES6-developers.pod

ECMAScript6 allows programmers to write programs in an asynchronous style, in order to achieve higher performance through concurrency. Such features as the async/await syntax mean that asynchronous functions can be written in a natural way that reads similar to straight-line code. The function can be suspended midway through execution until a result arrives that allows it to continue.

Here is an example which shows how you can use this syntax to implement a function that suspends in the middle of execution until it has received a response to the HTTP request we sent.

const fetch = require("node-fetch");

async function getJson(url) {
  try {
    const response = await fetch(url);
    const json = await response.json();
    return json;
  } catch (error) {
    console.log(error);
  }
}

We can write a similar thing in Perl 5. In ECMAScript6 the event system is built into the language, whereas in Perl 5 we get to choose our own. Because of this, the example is a little more verbose because it has to specify more of these choices.

use Future::AsyncAwait;

use IO::Async::Loop;
use Net::Async::HTTP;

my $loop = IO::Async::Loop->new;

my $http = Net::Async::HTTP->new;
$loop->add( $http );

async sub get_json($url)
{
  try {
    my $response = await $http->GET( $url );
    return decode_json( $response->decoded_content );
  }
  catch {
    warn "Failed to get JSON: $@\n";
  }
}

In both languages we see the await keyword causes the function to wait until the result of its sub-expression is ready. The argument to the await keyword is a value of a type that wraps up the idea of "an operation that may still be pending". In ECMAScript6 that is a value of Promise type; in Perl 5 it is a Future. These are two different names for what is essentially the same idea - in both cases the value encapsulates the concept of an operation that is still ongoing, and will yield its result later. The await keyword is used to suspend the currently-running function until that result is available.

Similarly, in both languages the async keyword decorates a function declaration and remarks that it may return its own result asynchronously via one of these deferred-result values (a Promise or Future), and allows that function to make use of the await expression.