wongi-engine 0.3.9 → 0.4.0.pre.alpha2

data/lib/wongi-engine/beta/neg_node.rb

@@ -1,15 +1,8 @@
 module Wongi
   module Engine
-    NegJoinResult = Struct.new :token, :wme, :neg_node do
-      def unlink
-        wme.neg_join_results.delete self
-        token.neg_join_results.delete self
-      end
-    end
+    NegJoinResult = Struct.new :token, :wme
 
     class NegNode < BetaNode
-      include TokenContainer
-
       attr_reader :alpha, :tests
 
       def initialize(parent, tests, alpha, unsafe)
@@ -19,79 +12,62 @@ module Wongi
         @unsafe = unsafe
       end
 
-      def alpha_activate(wme)
+      def alpha_activate(wme, children: self.children)
+        # p alpha_activate: {class: self.class, object_id:, wme:}
         tokens.each do |token|
           next unless matches?(token, wme) && (@unsafe || !token.generated?(wme)) # feedback loop protection
 
           # order matters for proper invalidation
-          make_join_result(token, wme)
-          # token.delete_children #if token.neg_join_results.empty? # TODO why was this check here? it seems to break things
-          children.each do |child|
-            child.tokens.each do |t|
-              if t.parent == token
-                child.beta_deactivate t
-                # token.destroy
-              end
-            end
-          end
+          overlay.add_neg_join_result(NegJoinResult.new(token, wme))
+          beta_deactivate_children(token: token, children: children)
         end
       end
 
       def alpha_deactivate(wme)
-        wme.neg_join_results.dup.each do |njr|
+        # p alpha_deactivate: {class: self.class, object_id:, wme:}
+        overlay.neg_join_results_for(wme: wme).each do |njr|
           tokens.each do |token|
             next unless token == njr.token
 
-            njr.unlink
-            next unless token.neg_join_results.empty?
+            overlay.remove_neg_join_result(njr)
+            next unless overlay.neg_join_results_for(token: token).empty?
 
             children.each do |child|
-              child.beta_activate Token.new(child, token, nil, {})
+              child.beta_activate(Token.new(child, token, nil))
             end
           end
         end
       end
 
       def beta_activate(token)
-        return if tokens.find { |et| et.duplicate? token }
+        # p beta_activate: {class: self.class, object_id:, token:}
+        return if tokens.find { |t| t.duplicate? token }
+
+        overlay.add_token(token)
 
-        token.overlay.add_token(token, self)
-        alpha.wmes.each do |wme|
-          make_join_result(token, wme) if matches?(token, wme)
+        template = specialize(alpha.template, tests, token)
+        select_wmes(template).each do |wme|
+          overlay.add_neg_join_result(NegJoinResult.new(token, wme)) if matches?(token, wme)
         end
-        return unless token.neg_join_results.empty?
+        return if overlay.neg_join_results_for(token: token).any?
 
         children.each do |child|
-          child.beta_activate Token.new(child, token, nil, {})
+          child.beta_activate(Token.new(child, token, nil, {}))
         end
       end
 
       def beta_deactivate(token)
-        return nil unless tokens.find token
-
-        token.overlay.remove_token(token, self)
-        token.deleted!
-        if token.parent
-          token.parent.children.delete token # should this go into Token#destroy?
-        end
-        token.neg_join_results.each(&:unlink)
-        children.each do |child|
-          child.tokens.each do |t|
-            if t.parent == token
-              child.beta_deactivate t
-              # token.destroy
-            end
-          end
-        end
-        token
+        # p beta_deactivate: {class: self.class, object_id:, token:}
+        overlay.remove_token(token)
+        beta_deactivate_children(token: token)
       end
 
       def refresh_child(child)
         tokens.each do |token|
-          child.beta_activate Token.new(child, token, nil, {}) if token.neg_join_results.empty?
+          child.beta_activate(Token.new(child, token, nil, {})) if overlay.neg_join_results_for(token: token).empty?
         end
-        alpha.wmes.each do |wme|
-          alpha_activate wme
+        select_wmes(alpha.template).each do |wme|
+          alpha_activate wme, children: [child]
         end
       end
 
@@ -104,12 +80,6 @@ module Wongi
         end
         true
       end
-
-      def make_join_result(token, wme)
-        njr = NegJoinResult.new token, wme, self
-        token.neg_join_results << njr
-        wme.neg_join_results << njr
-      end
     end
   end
 end

data/lib/wongi-engine/beta/optional_node.rb

@@ -1,15 +1,8 @@
 module Wongi
   module Engine
-    OptionalJoinResult = Struct.new :token, :wme do
-      def unlink
-        wme.opt_join_results.delete self
-        token.opt_join_results.delete self
-      end
-    end
+    OptionalJoinResult = Struct.new :token, :wme
 
     class OptionalNode < BetaNode
-      include TokenContainer
-
       attr_reader :alpha, :tests, :assignment_pattern
 
       def initialize(parent, alpha, tests, assignments)
@@ -19,56 +12,53 @@ module Wongi
         @assignment_pattern = assignments
       end
 
-      def make_opt_result(token, wme)
-        jr = OptionalJoinResult.new token, wme
-        token.opt_join_results << jr
-        wme.opt_join_results << jr
-      end
-
-      def alpha_activate(wme)
+      def alpha_activate(wme, children: self.children)
         assignments = collect_assignments(wme)
         tokens.each do |token|
           next unless matches? token, wme
 
+          optional = overlay.opt_join_results_for(token: token).empty?
+
           children.each do |child|
-            if token.optional?
-              token.no_optional!
+            if optional
+              # we're going to change the optional state so the old ones need to be removed
               child.tokens.each do |ct|
                 child.beta_deactivate(ct) if ct.parent == token
               end
             end
             child.beta_activate Token.new(child, token, wme, assignments)
           end
-          make_opt_result token, wme
+          overlay.add_opt_join_result(OptionalJoinResult.new(token, wme))
         end
       end
 
       def alpha_deactivate(wme)
-        wme.opt_join_results.dup.each do |ojr|
+        # p alpha_deactivate: {wme:}
+        overlay.opt_join_results_for(wme: wme).each do |ojr|
           tokens.each do |token|
             next unless token == ojr.token
 
-            ojr.unlink
-            next unless token.opt_join_results.empty?
+            overlay.remove_opt_join_result(ojr)
+            next unless overlay.opt_join_results_for(token: token).empty?
 
             children.each do |child|
               child.tokens.each do |ct|
                 child.beta_deactivate(ct) if ct.parent == token
               end
-              token.optional!
               child.beta_activate Token.new(child, token, nil, {})
             end
           end
         end
       end
 
-      def beta_activate(t)
-        return if tokens.find { |token| token.parent == t }
+      def beta_activate(token)
+        return if tokens.find { |t| t.duplicate? token }
+
+        overlay.add_token(token)
 
-        token = Token.new(self, t, nil, {})
-        token.overlay.add_token(token, self)
         match = false
-        alpha.wmes.each do |wme|
+        template = specialize(alpha.template, tests, token)
+        select_wmes(template).each do |wme|
           assignments = collect_assignments(wme)
           next unless matches? token, wme
 
@@ -80,36 +70,24 @@ module Wongi
         end
         return if match
 
-        token.optional!
         children.each do |child|
           child.beta_activate Token.new(child, token, nil, {})
         end
       end
 
-      def beta_deactivate(t)
-        token = tokens.find { |own_token| own_token.parent == t }
-        return unless token
-
-        token.overlay.remove_token(token, self)
-        token.deleted!
-        token.parent.children.delete token if token.parent
-        token.opt_join_results.each(&:unlink)
-        children.each do |child|
-          child.tokens.each do |child_token|
-            child.beta_deactivate(child_token) if child_token.parent == token
-          end
-        end
-        token
+      def beta_deactivate(token)
+        # p beta_deactivate: {class: self.class, object_id:, token:}
+        overlay.remove_token(token)
+        beta_deactivate_children(token: token)
       end
 
       def refresh_child(child)
-        tmp = children
-        self.children = [child]
-        refresh # do the beta part
-        alpha.wmes.each do |wme|
-          alpha_activate wme
+        tokens.each do |token|
+          child.beta_activate(Token.new(child, token, nil, {}))
+        end
+        select_wmes(alpha.template).each do |wme|
+          alpha_activate wme, children: [child]
         end
-        self.children = tmp
       end
 
       private

data/lib/wongi-engine/beta/or_node.rb

@@ -1,6 +1,6 @@
 module Wongi
   module Engine
-    class OrNode < BetaMemory
+    class OrNode < BetaNode
       attr_reader :parents, :rete
 
       def initialize(parents)
@@ -24,11 +24,34 @@ module Wongi
         parents.map(&:depth).max + 1
       end
 
+      def beta_activate(token)
+        # p beta_activate: {class: self.class, object_id:, token:}
+        return if tokens.find { token.duplicate?(_1) }
+
+        overlay.add_token(token)
+
+        children.each do |child|
+          child.beta_activate(Token.new(child, token, nil))
+        end
+      end
+
+      def beta_deactivate(token)
+        # p beta_deactivate: {class: self.class, object_id:, token:}
+        overlay.remove_token(token)
+        beta_deactivate_children(token: token)
+      end
+
       def refresh
         parents.each do |parent|
           parent.refresh_child self
         end
       end
+
+      def refresh_child(child)
+        tokens.each do |token|
+          child.beta_activate(Token.new(child, token, nil))
+        end
+      end
     end
   end
 end

data/lib/wongi-engine/beta/production_node.rb

@@ -1,6 +1,6 @@
 module Wongi
   module Engine
-    class ProductionNode < BetaMemory
+    class ProductionNode < BetaNode
       attr_accessor :tracer, :compilation_context
 
       def initialize(parent, actions)
@@ -9,7 +9,10 @@ module Wongi
       end
 
       def beta_activate(token)
-        return unless super
+        # p beta_activate: {class: self.class, object_id:, token:}
+        return if tokens.find { |t| t.duplicate? token }
+
+        overlay.add_token(token)
 
         @actions.each do |action|
           action.execute token if action.respond_to? :execute
@@ -17,7 +20,10 @@ module Wongi
       end
 
       def beta_deactivate(token)
-        return unless super
+        # p beta_deactivate: {class: self.class, object_id:, token:}
+
+        # we should remove before the actions because otherwise the longer rule chains (like the infinite neg-gen cycle) don't work as expected
+        overlay.remove_token(token)
 
         @actions.each do |action|
           action.deexecute token if action.respond_to? :deexecute

data/lib/wongi-engine/beta/root_node.rb

@@ -0,0 +1,47 @@
+module Wongi::Engine
+  class RootNode < BetaNode
+    def seed(assignments = {})
+      @seed = assignments
+      t = Token.new(self, nil, nil, assignments)
+      rete.default_overlay.add_token(t)
+    end
+
+    def subst(valuations)
+      beta_deactivate(tokens.first)
+      token = Token.new(self, nil, nil, @seed)
+      valuations.each { |variable, value| token.subst variable, value }
+      beta_activate(token)
+    end
+
+    def beta_activate(token)
+      # existing = tokens.find { |et| et.duplicate? token }
+      # return if existing # TODO: really?
+
+      overlay.add_token(token)
+
+      children.each do |child|
+        child.beta_activate(Token.new(child, token, nil))
+      end
+
+      nil
+    end
+
+    def beta_deactivate(token)
+      return nil unless tokens.find token
+
+      overlay.remove_token(token)
+
+      children.each do |child|
+        child.tokens.select { _1.parent == token }.each { child.beta_deactivate(_1) }
+      end
+
+      nil
+    end
+
+    def refresh_child(child)
+      tokens.each do |token|
+        child.beta_activate(Token.new(child, token, nil))
+      end
+    end
+  end
+end

data/lib/wongi-engine/beta.rb

@@ -1,5 +1,5 @@
 require 'wongi-engine/beta/beta_node'
-require 'wongi-engine/beta/beta_memory'
+require 'wongi-engine/beta/root_node'
 require 'wongi-engine/beta/filter_node'
 require 'wongi-engine/beta/assignment_node'
 require 'wongi-engine/beta/join_node'

data/lib/wongi-engine/compiler.rb

@@ -24,37 +24,13 @@ module Wongi::Engine
       end
     end
 
-    # TODO: should the following be the responsibility of Compiler or of each individual DSL clause?
-
-    def beta_memory
-      return if node.is_a?(BetaMemory)
-
-      self.node = if (existing = node.children.find { |n| n.is_a?(BetaMemory) })
-                    existing
-                  else
-                    BetaMemory.new(node).tap(&:refresh)
-                  end
-    end
-
-    def singleton_beta_memory
-      return if node.is_a?(SingletonBetaMemory)
-
-      self.node = if (existing = node.children.find { |n| n.is_a?(SingletonBetaMemory) })
-                    existing
-                  else
-                    SingletonBetaMemory.new(node).tap(&:refresh)
-                  end
-    end
-
     def assignment_node(variable, body)
-      beta_memory
       self.node = AssignmentNode.new(node, variable, body).tap(&:refresh)
       declare(variable)
     end
 
     def join_node(condition, tests, assignment)
       alpha = rete.compile_alpha(condition)
-      beta_memory
       self.node = if (existing = node.children.find { |n| n.is_a?(JoinNode) && n.equivalent?(alpha, tests, assignment) && !n.children.map(&:class).include?(Wongi::Engine::OrNode) })
                     existing
                   else
@@ -63,6 +39,7 @@ module Wongi::Engine
                       alpha.betas << join unless alpha_deaf
                     end
                   end
+      node.tap(&:refresh)
     end
 
     def neg_node(condition, tests, unsafe)
@@ -75,24 +52,21 @@ module Wongi::Engine
 
     def opt_node(condition, tests, assignment)
       alpha = rete.compile_alpha(condition)
-      beta_memory
       self.node = OptionalNode.new(node, alpha, tests, assignment).tap do |node|
         alpha.betas << node unless alpha_deaf
+        node.refresh
       end
     end
 
     def aggregate_node(condition, tests, assignment, map, function, assign)
       declare(assign)
       alpha = rete.compile_alpha(condition)
-      beta_memory
       self.node = AggregateNode.new(node, alpha, tests, assignment, map, function, assign).tap do |node|
         alpha.betas << node unless alpha_deaf
-      end
-      beta_memory
+      end.tap(&:refresh)
     end
 
     def or_node(variants)
-      beta_memory
       subvariables = []
       branches = variants.map do |variant|
         subcompiler = Compiler.new(rete, node, variant.conditions, parameters, false)
@@ -110,7 +84,6 @@ module Wongi::Engine
     end
 
     def ncc_node(subrule, alpha_deaf)
-      beta_memory
       subcompiler = Compiler.new(rete, node, subrule.conditions, parameters, alpha_deaf)
       declared_variables.each { |v| subcompiler.declare(v) }
       bottom = subcompiler.compile
@@ -118,8 +91,8 @@ module Wongi::Engine
         self.node = existing
         return
       end
-      ncc = NccNode.new node
-      partner = NccPartner.new subcompiler.tap(&:beta_memory).node
+      ncc = NccNode.new(node)
+      partner = NccPartner.new(subcompiler.node)
       ncc.partner = partner
       partner.ncc = ncc
       partner.divergent = node
@@ -130,8 +103,7 @@ module Wongi::Engine
     end
 
     def filter_node(filter)
-      beta_memory
-      self.node = FilterNode.new(node, filter)
+      self.node = FilterNode.new(node, filter).tap(&:refresh)
     end
   end
 end

data/lib/wongi-engine/dsl/action/{base.rb → base_action.rb}

@@ -1,8 +1,12 @@
 module Wongi::Engine
   module DSL::Action
-    class Base
+    class BaseAction
       include CoreExt
       attr_accessor :production, :rule, :name, :rete
+
+      def overlay
+        rete.current_overlay
+      end
     end
   end
 end

data/lib/wongi-engine/dsl/action/error_generator.rb

@@ -1,6 +1,6 @@
 module Wongi::Engine
   module DSL::Action
-    class ErrorGenerator < Base
+    class ErrorGenerator < BaseAction
       def initialize(message = nil, &messenger)
         super()
         @message = message

data/lib/wongi-engine/dsl/action/simple_action.rb

@@ -1,6 +1,6 @@
 module Wongi::Engine
   module DSL::Action
-    class SimpleAction < Base
+    class SimpleAction < BaseAction
       def initialize(action = nil, *args, &block)
         super()
         @args = args

data/lib/wongi-engine/dsl/action/simple_collector.rb

@@ -1,6 +1,6 @@
 module Wongi::Engine
   module DSL::Action
-    class SimpleCollector < Base
+    class SimpleCollector < BaseAction
       def self.collector
         Class.new self
       end

data/lib/wongi-engine/dsl/action/statement_generator.rb

@@ -1,45 +1,44 @@
 module Wongi::Engine
   module DSL::Action
-    class StatementGenerator < Base
+    class StatementGenerator < BaseAction
+      GeneratorOrigin = Struct.new(:token, :action)
+
+      attr_reader :template
+      private :template
+
       def initialize(template)
         super()
         @template = template
       end
 
       def execute(token)
-        subject, predicate, object = @template.resolve!(token)
+        # p execute: {token:}
+        subject, predicate, object = template.resolve!(token)
+
+        wme = WME.new(subject, predicate, object)
 
-        # link to rete here to ensure proper linking with token
-        wme = WME.new subject, predicate, object, rete
-        wme.manual = false
-        wme.overlay = token.overlay
+        origin = GeneratorOrigin.new(token, self)
 
         production.tracer.trace(action: self, wme: wme) if production.tracer
-        if (existing = rete.exists?(wme))
-          generated = existing.generating_tokens.size
-          if generated.positive? && !token.generated_wmes.include?(existing)
+        if (existing = overlay.find(wme))
+          # do not mark purely manual tokens as generated, because a circular rule such as the symmetric friend generator this would cause both sides to become self-sustaining
+          # TODO: but this may have to be smarter, because there may be more indirect ways of creating such a situation
+          if overlay.generated?(wme)
             token.generated_wmes << existing
-            existing.generating_tokens << token
+            overlay.assert(existing, generator: origin)
           end
         else
           token.generated_wmes << wme
-          wme.generating_tokens << token
-          # this MUST be done after we link the wme and the token
-          # in order for neg rule invalidation to work
-          wme.overlay.assert wme
+          overlay.assert(wme, generator: origin)
         end
       end
 
       def deexecute(token)
-        generated = token.generated_wmes.reject(&:manual?)
-
-        wmes_for_deletion = generated.each_with_object([]) do |wme, acc|
-          wme.generating_tokens.delete token
-          acc << wme if wme.generating_tokens.empty?
-        end
+        origin = GeneratorOrigin.new(token, self)
 
-        wmes_for_deletion.each do |wme|
-          wme.overlay.retract wme, automatic: true
+        generated = token.generated_wmes.select { overlay.generators(_1).include?(origin) }
+        generated.each do |wme|
+          overlay.retract wme, generator: origin
         end
       end
     end

data/lib/wongi-engine/dsl/action/trace_action.rb

@@ -1,6 +1,6 @@
 module Wongi::Engine
   module DSL::Action
-    class TraceAction < Base
+    class TraceAction < BaseAction
       class DefaultTracer
         attr_accessor :action
 

data/lib/wongi-engine/dsl/clause/fact.rb

@@ -1,17 +1,13 @@
 module Wongi::Engine
   module DSL::Clause
-    Has = Struct.new(:subject, :predicate, :object, :time) do
+    Has = Struct.new(:subject, :predicate, :object) do
       include CoreExt
       attr_predicate :debug
 
       def initialize(s, p, o, options = {})
-        time = options[:time] || 0
         @unsafe = options[:unsafe] || false
         debug! if options[:debug]
-        raise "Cannot work with continuous time" unless time.integer?
-        raise "Cannot look into the future" if time.positive?
-
-        super(s, p, o, time)
+        super(s, p, o)
       end
 
       def compile(context)

data/lib/wongi-engine/dsl.rb

@@ -36,7 +36,7 @@ require 'wongi-engine/dsl/clause/fact'
 require 'wongi-engine/dsl/clause/aggregate'
 require 'wongi-engine/dsl/clause/assign'
 require 'wongi-engine/dsl/clause/gen'
-require 'wongi-engine/dsl/action/base'
+require 'wongi-engine/dsl/action/base_action'
 require 'wongi-engine/dsl/rule'
 require 'wongi-engine/dsl/ncc_subrule'
 require 'wongi-engine/dsl/any_rule'
@@ -110,30 +110,6 @@ module Wongi::Engine::DSL
     clause :assign, :introduce, :let
     accept Clause::Assign
 
-    clause :asserted, :added
-    body { |s, p, o|
-      has s, p, o, time: 0
-      missing s, p, o, time: -1
-    }
-
-    clause :retracted, :removed
-    body { |s, p, o|
-      has s, p, o, time: -1
-      missing s, p, o, time: 0
-    }
-
-    clause :kept, :still_has
-    body { |s, p, o|
-      has s, p, o, time: -1
-      has s, p, o, time: 0
-    }
-
-    clause :kept_missing, :still_missing
-    body { |s, p, o|
-      missing s, p, o, time: -1
-      missing s, p, o, time: 0
-    }
-
     clause :assuming
     accept Wongi::Engine::AssumingClause