Evo

 view release on metacpan or  search on metacpan

lib/Evo/Promise/Role.pm  view on Meta::CPAN

package Evo::Promise::Role;
use Evo -Class;
use Evo '-Promise::Sync; -Lib try; -Promise::Const *; -Promise::Deferred';
use Evo 'Carp croak; Scalar::Util blessed';

requires 'postpone';

# https://promisesaplus.com/

has $_, optional for qw(d_v d_locked d_fh d_rh d_settled);
has 'd_children' => ro, sub { [] };
has 'state' => PENDING;

#sub assert { shift or croak join '; ', caller() }

#sub value($self) {
#  croak "$self isn't fulfilled" unless $self->state eq FULFILLED;
#  $self->d_v;
#}
#

lib/Evo/Promise/Role.pm  view on Meta::CPAN

  my $p = ref($self)->new(ref($fh) ? (d_fh => $fh) : (), ref($rh) ? (d_rh => $rh) : ());
  push $self->d_children->@*, $p;
  $self->d_traverse if $self->d_settled;
  $p;
}

### DRIVER INTERNAL METHODS

sub d_lock_in ($self, $parent) {

  #assert(!$self->d_locked);
  #assert(!$self->d_settled);
  unshift $parent->d_children->@*, $self->d_locked(1);
}

sub d_fulfill ($self, $v) {

  #assert(!$self->d_settled);
  $self->d_settled(1)->state(FULFILLED)->d_v($v);
}

sub d_reject ($self, $r) {

lib/Evo/Promise/Util.pm  view on Meta::CPAN

package Evo::Promise::Util;
use Evo '-Export *; List::Util first; Carp croak; /::Const *';

sub is_locked_in ($parent, $child) : Export {
  croak unless defined wantarray;
  first { $_ == $child } $parent->d_children->@*;
}

sub is_fulfilled_with ($v, $p) : Export {
  croak unless defined wantarray;
  return unless $p->d_settled && $p->state eq FULFILLED;
  my $dv = $p->d_v;

  return defined $dv ? $v eq $dv : !defined $v;

t/evo/promise/func/resolved_rejected.t  view on Meta::CPAN

sub p { MyTestPromise->new(@_) }

# resolved/rejected

ok is_fulfilled_with 33, MyTestPromise->resolve(33);
ok is_rejected_with 44,  MyTestPromise->reject(44);

# resolve will follow, reject not
my $p = p();
ok is_locked_in $p,     MyTestPromise->resolve($p);
ok is_rejected_with $p, MyTestPromise->reject($p);

done_testing;

1;

t/evo/promise/promise/driver.t  view on Meta::CPAN

  ok p->d_fulfill(0)->d_settled;
  ok p->d_reject(0)->d_settled;
  my $p = p();
  $p->d_lock_in(p());
  ok !$p->d_settled;
}

LOCK_IN: {
  my ($ch, $p) = (p(), p());
  $ch->d_lock_in($p);
  ok is_locked_in($p, $ch);
  ok $ch->d_locked;
}

REJECT: {
  my $p = p();
  $p->d_reject(0);
  ok is_rejected_with(0, $p);
}

FULFILL: {
  my $p = p();

t/evo/promise/promise/driver_resolve.t  view on Meta::CPAN

  my $p = p();
  my $r = p()->d_reject(0);
  $p->d_resolve($r);
  ok is_rejected_with 0 => $p;
}

LOCKED: {
  my $p       = p();
  my $pending = p();
  $p->d_resolve($pending);
  ok is_locked_in $pending => $p;
}

# thenable
THENABLE_ASYNC: {
  my $th = My::Thenable->new(then_fn => sub { });
  my $p = p();
  $p->d_resolve($th);
  ok !$p->d_settled;

}

t/evo/promise/util.t  view on Meta::CPAN

ok is_fulfilled_with(undef, p()->d_fulfill(undef));
ok !is_fulfilled_with(0, p()->d_reject(0));
ok !is_fulfilled_with(1, p()->d_fulfill(0));

# is_rejected
ok is_rejected_with(0,     p()->d_reject(0));
ok is_rejected_with(undef, p()->d_reject(undef));
ok !is_rejected_with(0, p()->d_fulfill(0));
ok !is_rejected_with(1, p()->d_fulfill(0));

# is_locked_on
my $par = p();
my $ch  = p();
unshift $par->d_children->@*, $ch;
ok is_locked_in($par, $ch);
ok !is_locked_in(p(), $ch);

done_testing;

1;