lib/DX/State.pm

   1 package DX::State;
   2
   3 use Return::MultiLevel qw(with_return);
   4 use DX::Op::Backtrack;
   5 use Scalar::Util qw(blessed);
   6 use List::MoreUtils qw(uniq);
   7 use Safe::Isa;
   8 use Moo;
   9
  10 has next_op => (is => 'ro', required => 1);
  11
  12 has return_stack => (is => 'ro', required => 1);
  13
  14 has by_id => (is => 'ro', required => 1);
  15
  16 has scope => (is => 'ro', required => 1);
  17
  18 has last_choice => (is => 'ro', required => 1);
  19
  20 has id_gen => (is => 'ro', default => sub { {} });
  21
  22 has rule_set => (is => 'ro');
  23
  24 has facts => (is => 'ro');
  25
  26 has dependencies => (is => 'ro', default => sub { {} });
  27
  28 has actions => (is => 'ro', default => sub { {} });
  29
  30 sub has_scope_var {
  31   my ($self, $name) = @_;
  32   return !!$self->scope->{$name};
  33 }
  34
  35 sub scope_var {
  36   my ($self, $name) = @_;
  37   my $id = $self->scope->{$name}
  38     or die "no such variable in scope: $name";
  39   $self->by_id->{$id};
  40 }
  41
  42 sub resolve_value {
  43   my ($self, $var) = @_;
  44 die("FUCK") unless $var;
  45   die "Can't resolve unbound ${\$var->id}" unless $var->is_bound;
  46   my $val = $var->bound_value;
  47   if ($val->$_does('DX::Role::Ref')) {
  48     return $val->resolve($self);
  49   }
  50   return $val;
  51 }
  52
  53 sub allocate_var {
  54   my ($self, $name, $var, $id_gen) = @_;
  55   my $id = join('_', $name, ++($id_gen->{$name}||='000'));
  56   DX::Var->new(id => $id, %$var);
  57 }
  58
  59 sub expand_vars {
  60   my ($self, %vars) = @_;
  61   my %by_id = %{$self->by_id};
  62   my %id_gen = %{$self->id_gen};
  63   foreach my $name (keys %vars) {
  64     unless (blessed($vars{$name})) {
  65       my $var = $vars{$name} = $self->allocate_var(
  66         $name, $vars{$name}, \%id_gen
  67       );
  68       $by_id{$var->id} = $var;
  69     }
  70   }
  71   $self->but(
  72     by_id => \%by_id, id_gen => \%id_gen,
  73   ), %vars;
  74 }
  75
  76 sub record_action {
  77   my ($self, $action) = @_;
  78   my %id_gen = %{$self->id_gen};
  79   my ($type) = (ref($action) =~ /([^:]+)$/);
  80   my $id = join('_', $type, ++($id_gen{$type}||='000'));
  81   my $recorded = $action->but(id => $id);
  82   $self->but(
  83     id_gen => \%id_gen,
  84     actions => { %{$self->actions}, $id => $recorded }
  85   ), $id;
  86 }
  87
  88 sub assign_vars {
  89   my ($self, %vars) = @_;
  90   my ($state, %expanded) = $self->expand_vars(%vars);
  91   $state->but(
  92     scope => { %{$self->scope}, map +($_ => $expanded{$_}->id), keys %expanded }
  93   );
  94 }
  95
  96 sub bind_value {
  97   my ($self, $var_id, $value) = @_;
  98   my $bound = $self->by_id->{$var_id}->with_value($value);
  99   $self->but(
 100     by_id => { %{$self->by_id}, $var_id => $bound },
 101   );
 102 }
 103
 104 sub bind_stream {
 105   my ($self, $var, $stream) = @_;
 106   my $bound = $var->with_stream($stream);
 107   $self->but(
 108     by_id => { %{$self->by_id}, $var->id => $bound },
 109   )->mark_choice($bound);
 110 }
 111
 112 sub bind_root_set {
 113   my ($self, $var_id, $set) = @_;
 114   my $bound = $self->by_id->{$var_id}->with_root_set($set);
 115   $self->but(
 116     by_id => { %{$self->by_id}, $var_id => $bound },
 117   )->mark_choice($bound);
 118 }
 119
 120 sub mark_choice {
 121   my ($self, $var) = @_;
 122   $self->but(last_choice => [ $self, $var ]);
 123 }
 124
 125 sub backtrack {
 126   my ($self) = @_;
 127   my ($state, $var) = ($self);
 128   while (($state, $var) = @{$state->last_choice}) {
 129     $var->bound_value; $var->clear_bound_value;
 130     return $state->mark_choice($var) unless $var->bound_stream->is_exhausted;
 131   }
 132   $self->return_from_run(undef);
 133 }
 134
 135 sub then {
 136   my ($self, $then) = @_;
 137   $self->but(next_op => $then);
 138 }
 139
 140 sub return_from_run {
 141   my (undef, $return) = @_;
 142   (our $Run_Return)->($return);
 143 }
 144
 145 sub return_from_op {
 146   my (undef, $return) = @_;
 147   if (our $Op_Return) {
 148     $Op_Return->($return);
 149   }
 150 }
 151
 152 sub run {
 153   my ($state) = @_;
 154   with_return {
 155     my ($return) = @_;
 156     local our $Run_Return = $return;
 157     while (my $op = $state->next_op) {
 158       my $backtrack = with_return {
 159         my ($return) = @_;
 160         local our $Op_Return = $return;
 161         $state = $op->run($state);
 162         return;
 163       };
 164       if ($backtrack) { $state = $state->backtrack }
 165     }
 166     return $state;
 167   }
 168 }
 169
 170 sub push_backtrack {
 171   $_[0]->then(DX::Op::Backtrack->new);
 172 }
 173
 174 sub but {
 175   my ($self, @but) = @_;
 176   $self->new(%$self, @but);
 177 }
 178
 179 sub pop_return_stack {
 180   my ($self) = @_;
 181   my @stack = @{$self->return_stack};
 182   my $top = pop @stack;
 183   $self->but(return_stack => \@stack, next_op => $top->[0]);
 184 }
 185
 186 sub push_return_then {
 187   my ($self, $return, $then) = @_;
 188   $self->but(
 189     return_stack => [ @{$self->return_stack}, [ $return, $self ] ],
 190     next_op => $then
 191   );
 192 }
 193
 194 sub add_dependencies {
 195   my ($self, @pairs) = @_;
 196   my %deps = %{$self->dependencies};
 197   while (my ($from, $to) = splice(@pairs, 0, 2)) {
 198     unless ($deps{$from}{$to}) {
 199       $deps{$from} = { %{$deps{$from}||{}}, $to => 1 };
 200     }
 201   }
 202   $self->but(dependencies => \%deps);
 203 }
 204
 205 sub action_dependencies {
 206   my ($self, @ids) = @_;
 207   my @found;
 208   my $deps = $self->dependencies;
 209   my $by_id = $self->by_id;
 210   my %seen;
 211   my @queue = @ids;
 212   while (my $id = shift @queue) {
 213     $seen{$id}++;
 214     my $value = $self->resolve_value($by_id->{$id});
 215     push @found, $value if $value->$_does('DX::Role::Fact')
 216                            and $value->has_required_action;
 217     push @queue, grep !$seen{$_}, keys %{$deps->{$id}};
 218   }
 219   return uniq map $_->required_action, @found;
 220 }
 221
 222 sub copy_vars {
 223   my ($self) = @_;
 224   my $by_id = $self->by_id;
 225   $self->but(by_id => {
 226     map +($_ => $by_id->{$_}->copy), keys %$by_id
 227   });
 228 }
 229
 230 1;