GSP
Quick Navigator

Search Site

Unix VPS
A - Starter
B - Basic
C - Preferred
D - Commercial
MPS - Dedicated
Previous VPSs
* Sign Up! *

Support
Contact Us
Online Help
Handbooks
Domain Status
Man Pages

FAQ
Virtual Servers
Pricing
Billing
Technical

Network
Facilities
Connectivity
Topology Map

Miscellaneous
Server Agreement
Year 2038
Credits
 

USA Flag

 

 

Man Pages
Mojo::Promise(3) User Contributed Perl Documentation Mojo::Promise(3)
 

Mojo::Promise - Promises/A+

  use Mojo::Promise;
  use Mojo::UserAgent;
  # Wrap continuation-passing style APIs with promises
  my $ua = Mojo::UserAgent->new;
  sub get {
    my $promise = Mojo::Promise->new;
    $ua->get(@_ => sub {
      my ($ua, $tx) = @_;
      my $err = $tx->error;
      if   (!$err || $err->{code}) { $promise->resolve($tx) }
      else                         { $promise->reject($err->{message}) }
    });
    return $promise;
  }
  # Perform non-blocking operations sequentially
  get('https://mojolicious.org')->then(sub {
    my $mojo = shift;
    say $mojo->res->code;
    return get('https://metacpan.org');
  })->then(sub {
    my $cpan = shift;
    say $cpan->res->code;
  })->catch(sub {
    my $err = shift;
    warn "Something went wrong: $err";
  })->wait;
  # Synchronize non-blocking operations (all)
  my $mojo = get('https://mojolicious.org');
  my $cpan = get('https://metacpan.org');
  Mojo::Promise->all($mojo, $cpan)->then(sub {
    my ($mojo, $cpan) = @_;
    say $mojo->[0]->res->code;
    say $cpan->[0]->res->code;
  })->catch(sub {
    my $err = shift;
    warn "Something went wrong: $err";
  })->wait;
  # Synchronize non-blocking operations (race)
  my $mojo = get('https://mojolicious.org');
  my $cpan = get('https://metacpan.org');
  Mojo::Promise->race($mojo, $cpan)->then(sub {
    my $tx = shift;
    say $tx->req->url, ' won!';
  })->catch(sub {
    my $err = shift;
    warn "Something went wrong: $err";
  })->wait;

Mojo::Promise is a Perl-ish implementation of Promises/A+ <https://promisesaplus.com>.

A promise is an object representing the eventual completion or failure of a non-blocking operation. It allows non-blocking functions to return values, like blocking functions. But instead of immediately returning the final value, the non-blocking function returns a promise to supply the value at some point in the future.
A promise can be in one of three states:
pending
Initial state, neither fulfilled nor rejected.
fulfilled
Meaning that the operation completed successfully.
rejected
Meaning that the operation failed.
A pending promise can either be fulfilled with a value or rejected with a reason. When either happens, the associated handlers queued up by a promise's "then" method are called.

Mojo::Promise implements the following attributes.

  my $loop = $promise->ioloop;
  $promise = $promise->ioloop(Mojo::IOLoop->new);
Event loop object to control, defaults to the global Mojo::IOLoop singleton. Note that this attribute is weakened.

Mojo::Promise inherits all methods from Mojo::Base and implements the following new ones.

  my $new = Mojo::Promise->all(@promises);
Returns a new Mojo::Promise object that either fulfills when all of the passed Mojo::Promise objects have fulfilled or rejects as soon as one of them rejects. If the returned promise fulfills, it is fulfilled with the values from the fulfilled promises in the same order as the passed promises. This method can be useful for aggregating results of multiple promises.

  my $new = $promise->catch(sub {...});
Appends a rejection handler callback to the promise, and returns a new Mojo::Promise object resolving to the return value of the callback if it is called, or to its original fulfillment value if the promise is instead fulfilled.
  # Longer version
  my $new = $promise->then(undef, sub {...});
  # Pass along the rejection reason
  $promise->catch(sub {
    my @reason = @_;
    warn "Something went wrong: $reason[0]";
    return @reason;
  });
  # Change the rejection reason
  $promise->catch(sub {
    my @reason = @_;
    return "This is bad: $reason[0]";
  });

  my $new = $promise->clone;
Return a new Mojo::Promise object cloned from this promise that is still pending.

  my $new = $promise->finally(sub {...});
Appends a fulfillment and rejection handler to the promise, and returns a new Mojo::Promise object resolving to the original fulfillment value or rejection reason.
  # Do something on fulfillment and rejection
  $promise->finally(sub {
    my @value_or_reason = @_;
    say "We are done!";
  });

  my $new = Mojo::Promise->race(@promises);
Returns a new Mojo::Promise object that fulfills or rejects as soon as one of the passed Mojo::Promise objects fulfills or rejects, with the value or reason from that promise.

  my $new  = Mojo::Promise->reject(@reason);
  $promise = $promise->reject(@reason);
Build rejected Mojo::Promise object or reject the promise with one or more rejection reasons.
  # Longer version
  my $promise = Mojo::Promise->new->reject(@reason);

  my $new  = Mojo::Promise->resolve(@value);
  $promise = $promise->resolve(@value);
Build resolved Mojo::Promise object or resolve the promise with one or more fulfillment values.
  # Longer version
  my $promise = Mojo::Promise->new->resolve(@value);

  my $new = $promise->then(sub {...});
  my $new = $promise->then(sub {...}, sub {...});
  my $new = $promise->then(undef, sub {...});
Appends fulfillment and rejection handlers to the promise, and returns a new Mojo::Promise object resolving to the return value of the called handler.
  # Pass along the fulfillment value or rejection reason
  $promise->then(
    sub {
      my @value = @_;
      say "The result is $value[0]";
      return @value;
    },
    sub {
      my @reason = @_;
      warn "Something went wrong: $reason[0]";
      return @reason;
    }
  );
  # Change the fulfillment value or rejection reason
  $promise->then(
    sub {
      my @value = @_;
      return "This is good: $value[0]";
    },
    sub {
      my @reason = @_;
      return "This is bad: $reason[0]";
    }
  );

  $promise->wait;
Start "ioloop" and stop it again once the promise has been fulfilled or rejected, does nothing when "ioloop" is already running.

Mojolicious, Mojolicious::Guides, <https://mojolicious.org>.
2018-12-10 perl v5.28.1

Search for    or go to Top of page |  Section 3 |  Main Index

Powered by GSP Visit the GSP FreeBSD Man Page Interface.
Output converted with ManDoc.