slightly less useless error on lack of variable

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

diff --git a/lib/DX/State.pm b/lib/DX/State.pm
index 379b41f..899c0d9 100644 (file)
--- a/lib/DX/State.pm
+++ b/lib/DX/State.pm
@@ -1,8 +1,10 @@
 package DX::State;
 
 use Return::MultiLevel qw(with_return);
-use DX::Op::FromCode;
+use DX::Op::Backtrack;
 use Scalar::Util qw(blessed);
+use List::MoreUtils qw(uniq);
+use Safe::Isa;
 use Moo;
 
 has next_op => (is => 'ro', required => 1);
@@ -21,51 +23,92 @@ has rule_set => (is => 'ro');
 
 has facts => (is => 'ro');
 
+has dependencies => (is => 'ro', default => sub { {} });
+
+has actions => (is => 'ro', default => sub { {} });
+
 sub scope_var {
   my ($self, $name) = @_;
-  $self->by_id->{$self->scope->{$name}};
+  my $id = $self->scope->{$name}
+    or die "no such variable in scope: $name";
+  $self->by_id->{$id};
+}
+
+sub resolve_value {
+  my ($self, $var) = @_;
+die("FUCK") unless $var;
+  die "Can't resolve unbound ${\$var->id}" unless $var->is_bound;
+  my $val = $var->bound_value;
+  if ($val->$_does('DX::Role::Ref')) {
+    return $val->resolve($self);
+  }
+  return $val;
 }
 
 sub allocate_var {
-  my ($self, $name, $var) = @_;
-  my $id = join('_', $name, ++($self->id_gen->{$name}));
+  my ($self, $name, $var, $id_gen) = @_;
+  my $id = join('_', $name, ++($id_gen->{$name}||='000'));
   DX::Var->new(id => $id, %$var);
 }
 
-sub assign_vars {
+sub expand_vars {
   my ($self, %vars) = @_;
   my %by_id = %{$self->by_id};
-  my $state = $self->but(id_gen => { %{$self->id_gen} });
+  my %id_gen = %{$self->id_gen};
   foreach my $name (keys %vars) {
-warn "assign: ${name}";
     unless (blessed($vars{$name})) {
-      my $var = $vars{$name} = $state->allocate_var($name, $vars{$name});
+      my $var = $vars{$name} = $self->allocate_var(
+        $name, $vars{$name}, \%id_gen
+      );
       $by_id{$var->id} = $var;
     }
   }
+  $self->but(
+    by_id => \%by_id, id_gen => \%id_gen,
+  ), %vars;
+}
+
+sub record_action {
+  my ($self, $action) = @_;
+  my %id_gen = %{$self->id_gen};
+  my ($type) = (ref($action) =~ /([^:]+)$/);
+  my $id = join('_', $type, ++($id_gen{$type}||='000'));
+  my $recorded = $action->but(id => $id);
+  $self->but(
+    id_gen => \%id_gen,
+    actions => { %{$self->actions}, $id => $recorded }
+  ), $id;
+}
+
+sub assign_vars {
+  my ($self, %vars) = @_;
+  my ($state, %expanded) = $self->expand_vars(%vars);
   $state->but(
-    by_id => \%by_id,
-    scope => { %{$self->scope}, map +($_ => $vars{$_}->id), keys %vars }
+    scope => { %{$self->scope}, map +($_ => $expanded{$_}->id), keys %expanded }
   );
 }
 
-sub bind_var_then {
-  my ($self, $var, $value, $then) = @_;
-  warn "Binding ".$var->id." to $value";
-  my $bound = $var->with_value($value);
+sub bind_value {
+  my ($self, $var_id, $value) = @_;
+  my $bound = $self->by_id->{$var_id}->with_value($value);
   $self->but(
-    by_id => { %{$self->by_id}, $var->id => $bound },
-    next_op => $then
+    by_id => { %{$self->by_id}, $var_id => $bound },
   );
 }
 
-sub bind_stream_then {
-  my ($self, $var, $stream, $then) = @_;
-  warn "Binding ".$var->id." to $stream";
+sub bind_stream {
+  my ($self, $var, $stream) = @_;
   my $bound = $var->with_stream($stream);
   $self->but(
     by_id => { %{$self->by_id}, $var->id => $bound },
-    next_op => $then
+  )->mark_choice($bound);
+}
+
+sub bind_root_set {
+  my ($self, $var_id, $set) = @_;
+  my $bound = $self->by_id->{$var_id}->with_root_set($set);
+  $self->but(
+    by_id => { %{$self->by_id}, $var_id => $bound },
   )->mark_choice($bound);
 }
 
@@ -91,24 +134,36 @@ sub then {
 
 sub return_from_run {
   my (undef, $return) = @_;
-  (our $Nonlocal_Return)->($return);
+  (our $Run_Return)->($return);
+}
+
+sub return_from_op {
+  my (undef, $return) = @_;
+  if (our $Op_Return) {
+    $Op_Return->($return);
+  }
 }
 
 sub run {
   my ($state) = @_;
   with_return {
     my ($return) = @_;
-    local our $Nonlocal_Return = $return;
+    local our $Run_Return = $return;
     while (my $op = $state->next_op) {
-#::Dwarn($op);
-      $state = $op->run($state);
+      my $backtrack = with_return {
+        my ($return) = @_;
+        local our $Op_Return = $return;
+        $state = $op->run($state);
+        return;
+      };
+      if ($backtrack) { $state = $state->backtrack }
     }
     return $state;
   }
 }
 
 sub push_backtrack {
-  $_[0]->then(DX::Op::FromCode->new(code => sub { $_[1]->backtrack }));
+  $_[0]->then(DX::Op::Backtrack->new);
 }
 
 sub but {
@@ -120,15 +175,51 @@ sub pop_return_stack {
   my ($self) = @_;
   my @stack = @{$self->return_stack};
   my $top = pop @stack;
-  $self->but(return_stack => \@stack, next_op => $top);
+  $self->but(return_stack => \@stack, next_op => $top->[0]);
 }
 
 sub push_return_then {
   my ($self, $return, $then) = @_;
   $self->but(
-    return_stack => [ @{$self->return_stack}, $return ],
+    return_stack => [ @{$self->return_stack}, [ $return, $self ] ],
     next_op => $then
   );
 }
 
+sub add_dependencies {
+  my ($self, @pairs) = @_;
+  my %deps = %{$self->dependencies};
+  while (my ($from, $to) = splice(@pairs, 0, 2)) {
+    unless ($deps{$from}{$to}) {
+      $deps{$from} = { %{$deps{$from}||{}}, $to => 1 };
+    }
+  }
+  $self->but(dependencies => \%deps);
+}
+
+sub action_dependencies {
+  my ($self, @ids) = @_;
+  my @found;
+  my $deps = $self->dependencies;
+  my $by_id = $self->by_id;
+  my %seen;
+  my @queue = @ids;
+  while (my $id = shift @queue) {
+    $seen{$id}++;
+    my $value = $self->resolve_value($by_id->{$id});
+    push @found, $value if $value->$_does('DX::Role::Fact')
+                           and $value->has_required_action;
+    push @queue, grep !$seen{$_}, keys %{$deps->{$id}};
+  }
+  return uniq map $_->required_action, @found;
+}
+
+sub copy_vars {
+  my ($self) = @_;
+  my $by_id = $self->by_id;
+  $self->but(by_id => {
+    map +($_ => $by_id->{$_}->copy), keys %$by_id
+  });
+}
+
 1;