basic return stack usage

[scpubgit/DKit.git] / lib / DX / State.pm

package DX::State;

use Return::MultiLevel qw(with_return);
use DX::Op::FromCode;
use Moo;

has next_op => (is => 'ro', required => 1);

has return_stack => (is => 'ro', required => 1);

has by_id => (is => 'ro', required => 1);

has scope => (is => 'ro', required => 1);

has last_choice => (is => 'ro', required => 1);

sub scope_var {
  my ($self, $name) = @_;
  $self->by_id->{$self->scope->{$name}};
}

sub bind_stream_then {
  my ($self, $var, $stream, $then) = @_;
  warn "Binding ".$var->id." to $stream";
  my $bound = $var->with_stream($stream);
  $self->new(%$self,
    by_id => { %{$self->by_id}, $var->id => $bound },
    next_op => $then
  )->mark_choice($bound);
}

sub mark_choice {
  my ($self, $var) = @_;
  $self->new(%$self,
    last_choice => [ $self, $var ]
  );
}

sub backtrack {
  my ($self) = @_;
  my ($state, $var) = ($self);
  while (($state, $var) = @{$state->last_choice}) {
    $var->bound_value; $var->clear_bound_value;
    return $state->mark_choice($var) unless $var->bound_stream->is_exhausted;
  }
  if (our $No_Options_Handler) {
    $No_Options_Handler->(undef);
  }
  die "Out of options";
}

sub then {
  my ($self, $then) = @_;
  $self->new(%$self, next_op => $then);
}

sub select_next_op {
  my ($self) = @_;
  return $self->next_op || do {
    if (my @stack = @{$self->return_stack}) {
      my $top = pop @stack;
      DX::Op::FromCode->new(
        code => sub {
          $_[1]->new(%{$_[1]}, return_stack => \@stack, next_op => $top)
        }
      );
    } else {
      undef;
    }
  };
}

sub run {
  my ($state) = @_;
  with_return {
    my ($return) = @_;
    local our $No_Options_Handler = $return;
    while (my $op = $state->select_next_op) {
      $state = $op->run($state);
    }
    return $state;
  }
}

sub push_backtrack {
  $_[0]->then(DX::Op::FromCode->new(code => sub { $_[1]->backtrack }));
}

1;