wongi-engine 0.4.0.pre.alpha10 → 0.4.0.pre.alpha12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0dc2418ab6ffabbb410e83db899bed0479fc5912ec24bc6bf5c01f40ca306aa1
-  data.tar.gz: 4f22e6752c8dfe568eaae071cc7d10b062dee6ddaf8c8ddb2dc201773b7378a1
+  metadata.gz: 18bc1bfbc38b0ae08b505d3209fb6f0776c9abfa532d8c90b4ef8c6d26461c44
+  data.tar.gz: b10cc7b4fae950742ae4471d7385d745f23bb875d6436a80139c355e35c9370f
 SHA512:
-  metadata.gz: 6f0d335b747ae2495a2cb259d4d538cb4b66f7f97fabb41ffd8c7dc78750df54c04990e60eea1913155388488d867e7090c71aee1ae647d0fdcf20447c455e00
-  data.tar.gz: d1db63d17198447da1f6761897cda0e5db7af1dc880203146e0deae4c30de89fe0486049ece689e1394d773a9bac79c67cc85ecf45a2655eee84ec25eab7855a
+  metadata.gz: 2f480873ccb3c7292b143cfdff082829e8e52b9ab8424e86caa6a8929d544f1f6d0aa3bfbd266bf12d2c2cf1de42282a5183244db27a8d15e3e51d681f2a0bb6
+  data.tar.gz: 04dbbba150bbb6d01336fab7d041769d986e8602838ed79e4e321ebf2c9c914344377e5cf7e82a753d1324ac87daa730640006595ce645f259d572fe2fe5cd33

data/lib/wongi-engine/alpha_index.rb

@@ -25,27 +25,6 @@ module Wongi::Engine
       index[hashed_key(wme)]
     end
 
-    def collections_for_template(template)
-      return nil unless template_matches_pattern?(template)
-
-      # here we know that all fields on which we're indexing are concrete in the template
-      collection_for_wme(template)
-    end
-
-    private def template_matches_pattern?(template)
-      template_element_matches_pattern?(:subject, template.subject) &&
-      template_element_matches_pattern?(:predicate, template.predicate) &&
-      template_element_matches_pattern?(:object, template.object)
-    end
-
-    private def template_element_matches_pattern?(member, template_element)
-      if Template.concrete?(template_element)
-        pattern.include?(member)
-      else
-        !pattern.include?(member)
-      end
-    end
-
     private def key(wme)
       pattern.map { wme.public_send(_1) }
     end

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

@@ -61,12 +61,13 @@ module Wongi::Engine
         aggregated = aggregate.call(tokens.map(&map))
         assignment = { var => aggregated }
         children = child ? [child] : self.children
-        tokens.each do |token|
-          # TODO: optimize this to work with a diff of actual changes
-          beta_deactivate_children(token: token, children: children)
-        end
         children.each do |beta|
-          beta.beta_activate(Token.new(beta, tokens, nil, assignment))
+          new_token = Token.new(beta, tokens, nil, assignment)
+          # nothing changed, skip useless traversal
+          next if beta.tokens.find { _1.duplicate?(new_token) }
+
+          beta.tokens.select { |child| tokens.any? { child.child_of?(_1) } }.each { beta.beta_deactivate(_1) }
+          beta.beta_activate(new_token)
         end
       end
     end

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

@@ -58,7 +58,8 @@ module Wongi::Engine
     end
 
     private def select_wmes(template)
-      rete.current_overlay.select(template)
+      # capture the enumerator
+      rete.current_overlay.each(template).to_a
     end
 
     private def specialize(template, tests, token)

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

@@ -26,6 +26,8 @@ module Wongi::Engine
       end
 
       private def should_assert?(wme, token)
+        return true if rete.bypass_consistency_checks?
+
         considered_tokens = Set.new
         tokens_to_consider = [token]
         until tokens_to_consider.empty?
@@ -33,11 +35,17 @@ module Wongi::Engine
           considered_tokens.add(token)
 
           # self-affirming reasoning
-          return false if token.wme == wme
+          if token.wme == wme
+            # puts "detected self-affirming"
+            return false
+          end
 
           # asserting this WME would invalidate the match
           # TODO: clean up
-          return false if token.node.is_a?(NegNode) && wme =~ token.node.alpha.template && token.node.matches?(token, wme) # how much is actually necessary?
+          if token.node.is_a?(NegNode) && wme =~ token.node.alpha.template && token.node.matches?(token, wme) # how much is actually necessary?
+            # puts "detected self-negating"
+            return false
+          end
 
           token.parents.each { |parent| tokens_to_consider.push(parent) unless considered_tokens.include?(parent) }
 

data/lib/wongi-engine/entity_iterator.rb

@@ -0,0 +1,60 @@
+module Wongi::Engine
+  class EntityIterator
+
+    attr_reader :entity, :collection
+    private :entity, :collection
+
+    def initialize(entity, collection)
+      @entity = entity
+      @collection = collection
+    end
+
+    def each
+      if block_given?
+        @collection.each do |wme|
+          yield wme.predicate, wme.object
+        end
+      else
+        Enumerator.new do |y|
+          @collection.each do |wme|
+            y << [wme.predicate, wme.object]
+          end
+        end
+      end
+    end
+
+    def get(name)
+      each { |k, v| return v if k == name }
+      nil
+    end
+
+    def [](name)
+      get(name)
+    end
+
+    def get_all(name)
+      each.filter_map { |k, v| v if k == name }
+    end
+
+    def fetch(name, *args, &block)
+      each { |k, v| return v if k == name }
+      if args.first
+        args.first
+      elsif block
+        block.call(name)
+      else
+        raise KeyError
+      end
+    end
+
+    def method_missing(name)
+      each { |k, v| return v if k == name }
+      raise NoMethodError
+    end
+
+    def respond_to_missing?(name, _include_private)
+      each { |k, v| return true if k == name }
+      super
+    end
+  end
+end

data/lib/wongi-engine/network.rb

@@ -3,9 +3,12 @@ require 'wongi-engine/network/debug'
 
 module Wongi::Engine
   class Network
+    include CoreExt
     attr_accessor :alpha_top, :beta_top, :queries, :results, :alpha_hash
     attr_reader :productions, :overlays
 
+    attr_predicate :bypass_consistency_checks
+
     include NetworkParts::Collectable
     private :overlays
     private :alpha_hash, :alpha_hash=
@@ -106,6 +109,10 @@ module Wongi::Engine
       overlays.last
     end
 
+    def entity(subject)
+      current_overlay.entity(subject)
+    end
+
     def assert(wme)
       default_overlay.assert(wme)
     end
@@ -127,7 +134,7 @@ module Wongi::Engine
     end
 
     def wmes
-      current_overlay.select(:_, :_, :_)
+      each.to_a
     end
 
     alias statements wmes
@@ -165,6 +172,7 @@ module Wongi::Engine
         else
           raise Error, "I don't know how to accept a #{something.class}"
         end
+        self
       end
     end
 
@@ -202,9 +210,8 @@ module Wongi::Engine
       compile_alpha Template.new(s, p, o)
     end
 
-    # TODO: pick an alpha with fewer candidates to go through
     def initial_fill(alpha)
-      default_overlay.select(:_, :_, :_).each do |wme|
+      default_overlay.each(:_, :_, :_).to_a.each do |wme|
         alpha.activate wme if wme =~ alpha.template
       end
     end
@@ -232,37 +239,19 @@ module Wongi::Engine
     end
 
     def exists?(wme)
-      find(wme.subject, wme.predicate, wme.object)
+      !find(wme.subject, wme.predicate, wme.object).nil?
     end
 
     def each(*args, &block)
-      template = case args.length
-                 when 0
-                   Template.new(:_, :_, :_)
-                 when 3
-                   Template.new(*args)
-                 else
-                   raise Error, "Network#each expect a template or nothing at all"
-                 end
-      matching = current_overlay.select(template)
-      if block_given?
-        matching.each(&block)
-      else
-        matching.each
-      end
+      current_overlay.each(*args, &block)
     end
 
-    def select(s, p, o, &block)
-      matching = current_overlay.select(s, p, o)
-      if block_given?
-        matching.each(&block)
-      else
-        matching.each
-      end
+    def select(*args, &block)
+      each(*args, &block)
     end
 
-    def find(s, p, o)
-      current_overlay.select(s, p, o).first
+    def find(*args)
+      each(*args).first
     end
 
     protected

data/lib/wongi-engine/overlay.rb

@@ -22,12 +22,14 @@ module Wongi::Engine
 
       @wmes = Set.new
       @indexes = [
-        AlphaIndex.new(%i[subject]),
-        AlphaIndex.new(%i[predicate]),
+        nil,
         AlphaIndex.new(%i[object]),
-        AlphaIndex.new(%i[subject predicate]),
-        AlphaIndex.new(%i[subject object]),
+        AlphaIndex.new(%i[predicate]),
         AlphaIndex.new(%i[predicate object]),
+        AlphaIndex.new(%i[subject]),
+        AlphaIndex.new(%i[subject object]),
+        AlphaIndex.new(%i[subject predicate]),
+        nil,
       ]
       @hidden_parent_wmes = {}
 
@@ -69,6 +71,8 @@ module Wongi::Engine
       else
         raise Error, "overlays can only accept data"
       end
+
+      self
     end
 
     def assert(wme, generator: nil)
@@ -76,6 +80,8 @@ module Wongi::Engine
       queue.push(operation)
 
       run_queue if queue.length == 1
+
+      self
     end
 
     def retract(wme, options = {})
@@ -87,9 +93,11 @@ module Wongi::Engine
       queue.push(operation)
 
       run_queue if queue.length == 1
+
+      self
     end
 
-    def run_queue
+    private def run_queue
       until queue.empty?
         operation, wme, options = queue.shift
 
@@ -117,19 +125,6 @@ module Wongi::Engine
       self == rete.default_overlay
     end
 
-    # TODO: this is inconsistent.
-    # A WME retracted in-flight will be visible in active enumerators
-    # but a token will not.
-    # But this is how it works.
-
-    # def wmes(template)
-    #   DuplicatingEnumerator.new(index(template))
-    # end
-
-    # def tokens(beta)
-    #   DeleteSafeEnumerator.new(raw_tokens(beta))
-    # end
-
     def find(wme)
       if wme.is_a?(Array)
         wme = WME.new(*wme)
@@ -137,20 +132,35 @@ module Wongi::Engine
       find_wme(wme)
     end
 
-    def select(*args)
+    def each(*args, &block)
+      template = nil
       case args.length
+      when 0
+        template = Template.new(:_, :_, :_)
       when 1
-        case args.first
+        arg = args.first
+        case arg
+        when Array
+          template = Template.new(*arg)
         when Template
-          select_by_template(args.first)
+          template = arg
+        when WME
+          template = Template.new(arg.subject, arg.predicate, arg.object)
         else
           raise ArgumentError
         end
       when 3
-        select_by_template(Template.new(*args))
+        template = Template.new(*args)
       else
         raise ArgumentError
       end
+
+      each_by_template(template, &block)
+    end
+
+    def entity(subject)
+      # 4 is the bitmap for <s _ _>
+      EntityIterator.new(subject, indexes[4].collection_for_wme(Template.new(subject, :_, :_)))
     end
 
     def manual?(wme)
@@ -165,25 +175,21 @@ module Wongi::Engine
     end
 
     def generators(wme)
-      own_generators = generator_tracker.for_wme(wme)
-      parent_generators =
+      Enumerator.new do |y|
+        generator_tracker.for_wme(wme).each {  y << _1 }
         if parent
-          parent.generators(wme).reject { |t| hidden_token?(t) }.to_set
-        else
-          Set.new
+          parent.generators(wme).reject { hidden_token?(_1) }.each { y << _1 }
         end
-      own_generators.union(parent_generators)
+      end
     end
 
     def generated_wmes(token)
-      own_wmes = generator_tracker.for_token(token)
-      parent_wmes =
+      Enumerator.new do |y|
+        generator_tracker.for_token(token).each { y << _1 }
         if parent && !hidden_token?(token)
-          parent.generated_wmes(token).reject { hidden_wme?(_1) }.to_set
-        else
-          Set.new
+          parent.generated_wmes(token).reject { hidden_wme?(_1) }.each { y << _1 }
         end
-      own_wmes.union(parent_wmes)
+      end
     end
 
     private def own_manual?(wme)
@@ -202,7 +208,9 @@ module Wongi::Engine
       has_own_wme?(wme) ? wme : nil
     end
 
-    private def has_own_wme?(wme) = wmes.include?(wme)
+    private def has_own_wme?(wme)
+      wmes.include?(wme)
+    end
 
     private def find_parents_wme(wme)
       return unless parent
@@ -218,28 +226,27 @@ module Wongi::Engine
         end
     end
 
-    private def select_by_template(template)
-      select_parents_template(template) + select_own_template(template)
+    def each_by_template(template)
+      Enumerator.new do |y|
+        each_own_wme_by_template(template, y)
+        each_parent_wme_by_template(template, y)
+      end
     end
 
-    private def select_own_template(template)
+    private def each_own_wme_by_template(template, y)
       if template.concrete?
         wme = find_own_wme(WME.from_concrete_template(template))
-        wme ? [wme] : []
+        y << wme if wme
       elsif template.root?
-        wmes
+        wmes.each { y << _1 }
       else
-        indexes.map { |index|
-          index.collections_for_template(template)
-        }.compact.first
+        indexes[template.bitmap].collection_for_wme(template).each { y << _1 }
       end
     end
 
-    private def select_parents_template(template)
+    private def each_parent_wme_by_template(template, y)
       if parent
-        parent.select(template).reject { hidden_wme?(_1) }.to_set
-      else
-        Set.new
+        parent.each_by_template(template).reject { hidden_wme?(_1) }.each { y << _1 }
       end
     end
 
@@ -251,7 +258,7 @@ module Wongi::Engine
 
       unless has_own_wme?(wme)
         wmes.add(wme)
-        indexes.each { _1.add(wme) }
+        indexes[1..6].each { _1.add(wme) }
       end
 
       if generator
@@ -271,7 +278,7 @@ module Wongi::Engine
         # no remaining reasons to keep this WME around
         if !own_generated?(wme) && !own_manual?(wme)
           wmes.delete(wme)
-          indexes.each { _1.remove(wme) }
+          indexes[1..6].each { _1.remove(wme) }
         end
 
         neg_join_results.remove_wme(wme)
@@ -309,7 +316,8 @@ module Wongi::Engine
     def remove_token(token)
       # p remove_token: {token:}
 
-      wmes = generated_wmes(token)
+      # capture the entire enumerated state
+      wmes = generated_wmes(token).to_a
 
       if own_node_tokens(token.node).find { _1.equal?(token) }.nil?
         if parents_node_tokens(token.node).find { _1.equal?(token) }

data/lib/wongi-engine/template.rb

@@ -28,6 +28,10 @@ module Wongi::Engine
       Template.concrete?(subject) && Template.concrete?(predicate) && Template.concrete?(object)
     end
 
+    def bitmap
+      (Template.concrete?(subject) ? 4 : 0) | (Template.concrete?(predicate) ? 2 : 0) | (Template.concrete?(object) ? 1 : 0)
+    end
+
     def variables
       [].tap do |a|
         a << subject if Template.variable?(subject)

data/lib/wongi-engine/token.rb

@@ -27,12 +27,18 @@ module Wongi::Engine
       @assignments[variable] = value
     end
 
+    def own_assignments
+      @assignments
+    end
+
     def assignments
-      all_assignments
+      parents.each_with_object({}) do |parent, acc|
+        acc.merge!(parent.assignments)
+      end.merge(own_assignments)
     end
 
     def [](var)
-      a = assignments[var]
+      a = assignment(var)
       a.respond_to?(:call) ? a.call(self) : a
     end
 
@@ -40,8 +46,23 @@ module Wongi::Engine
       vars.map { self[_1] }
     end
 
+    def assignment(x)
+      return @assignments[x] if has_own_var?(x)
+
+      parents.each do |parent|
+        a = parent.assignment(x)
+        return a if a
+      end
+
+      nil
+    end
+
     def has_var?(x)
-      assignments.key? x
+      has_own_var?(x) || parents.any? { _1.has_var?(x) }
+    end
+
+    def has_own_var?(x)
+      @assignments.key?(x)
     end
 
     # TODO: ignore assignments?
@@ -49,12 +70,12 @@ module Wongi::Engine
       instance_of?(other.class) &&
         parents == other.parents &&
         wme == other.wme &&
-        assignments == other.assignments
+        own_assignments == other.own_assignments
     end
 
     def to_s
       str = "TOKEN [ #{object_id} ancestors=#{ancestors.map(&:object_id).map(&:to_s).join('.')} "
-      all_assignments.each_pair { |key, value| str << "#{key}=#{value.is_a?(TokenAssignment) ? "#{value.call} (#{value})" : value} " }
+      assignments.each_pair { |key, value| str << "#{key}=#{value.is_a?(TokenAssignment) ? "#{value.call} (#{value})" : value} " }
       str << "]"
       str
     end
@@ -62,13 +83,5 @@ module Wongi::Engine
     def inspect
       to_s
     end
-
-    protected
-
-    def all_assignments
-      parents.each_with_object({}) do |parent, acc|
-        acc.merge!(parent.assignments)
-      end.merge(@assignments)
-    end
   end
 end

data/lib/wongi-engine/version.rb

@@ -1,5 +1,5 @@
 module Wongi
   module Engine
-    VERSION = "0.4.0-alpha10".freeze
+    VERSION = "0.4.0-alpha12".freeze
   end
 end

data/lib/wongi-engine.rb

@@ -31,6 +31,7 @@ require 'wongi-engine/compiler'
 require 'wongi-engine/join_results'
 require 'wongi-engine/generator_tracker'
 require 'wongi-engine/overlay'
+require 'wongi-engine/entity_iterator'
 require 'wongi-engine/enumerators'
 require 'wongi-engine/network'
 require 'wongi-engine/graph'

data/spec/bug_specs/issue_4_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe "issue 4" do
-  it "correctlies retract pre-added items from within a rule" do
+  it "correctly retracts pre-added items from within a rule" do
     engine = Wongi::Engine.create
 
     10.times { |i| engine << [i, :is_number, true] }
@@ -22,11 +22,11 @@ describe "issue 4" do
     numbers = engine.select :_, :is_number, true
     evens = engine.select :_, :is_even, true
 
-    expect(numbers.size).to eq(0)
-    expect(evens.size).to eq(10)
+    expect(numbers.count).to eq(0)
+    expect(evens.count).to eq(10)
   end
 
-  it "correctlies retract post-added items from within a rule" do
+  it "correctly retracts post-added items from within a rule" do
     engine = Wongi::Engine.create
 
     engine.rule 'segregate' do
@@ -47,8 +47,8 @@ describe "issue 4" do
     numbers = engine.select :_, :is_number, true
     evens = engine.select :_, :is_even, true
 
-    expect(numbers.size).to eq(0)
-    expect(evens.size).to eq(5)
+    expect(numbers.count).to eq(0)
+    expect(evens.count).to eq(5)
   end
 
   # cascaded processing affects this
@@ -80,9 +80,9 @@ describe "issue 4" do
     evens = engine.select :_, :is_even, true
     odds = engine.select :_, :is_odd, true
 
-    expect(numbers.size).to eq(0)
-    expect(evens.size).to eq(5)
-    expect(odds.size).to eq(5)
+    expect(numbers.count).to eq(0)
+    expect(evens.count).to eq(5)
+    expect(odds.count).to eq(5)
   end
 
   it "does not lose track when another rule affects a set" do
@@ -126,8 +126,8 @@ describe "issue 4" do
     evens = engine.select :_, :is_even, true
     odds = engine.select :_, :is_odd, true
 
-    expect(numbers.size).to eq(5)
-    expect(evens.size).to eq(5)
-    expect(odds.size).to eq(5)
+    expect(numbers.count).to eq(5)
+    expect(evens.count).to eq(5)
+    expect(odds.count).to eq(5)
   end
 end

data/spec/entity_iterator_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+describe Wongi::Engine::EntityIterator do
+  let(:engine) { Wongi::Engine.create }
+  let(:x) { engine.entity(:x) }
+  let(:y) { engine.entity(:y) }
+
+  before do
+    engine << [:x, :prop1, 1]
+    engine << [:x, :prop1, 2]
+    engine << [:x, :prop2, :y]
+    engine << [:y, :prop3, 3]
+  end
+
+  describe "#each" do
+    it 'returns an enumerator' do
+      expect(x.each.to_h).to eq(prop1: 2, prop2: :y)
+    end
+
+    it 'iterates over properties' do
+      results = {}
+      x.each { |k, v| results[k] = v }
+      expect(results).to eq(prop1: 2, prop2: :y)
+    end
+  end
+
+  describe "#get" do
+    specify do
+      expect(x.get(:prop1)).to eq(1)
+      expect(x.get(:prop2)).to eq(:y)
+      expect(x.get(:prop3)).to eq(nil)
+
+      expect(y.get(:prop3)).to eq(3)
+    end
+  end
+
+  describe "#[]" do
+    specify do
+      expect(x[:prop1]).to eq(1)
+      expect(x[:prop2]).to eq(:y)
+      expect(x[:prop3]).to eq(nil)
+
+      expect(y[:prop3]).to eq(3)
+    end
+  end
+
+  describe "#fetch" do
+    specify do
+      expect(x.fetch(:prop1)).to eq(1)
+      expect(x.fetch(:prop2)).to eq(:y)
+      expect(x.fetch(:prop3, 42)).to eq(42)
+      expect(x.fetch(:prop3) { 42 }).to eq(42)
+      expect { x.fetch(:prop3) }.to raise_error(KeyError)
+
+      expect(y.fetch(:prop3)).to eq(3)
+    end
+  end
+
+  describe "#get_all" do
+    it 'returns all matching values' do
+      expect(x.get_all(:prop1)).to eq([1, 2])
+      expect(x.get_all(:prop2)).to eq([:y])
+      expect(x.get_all(:prop3)).to eq([])
+
+      expect(y.get_all(:prop3)).to eq([3])
+    end
+  end
+
+  describe "#method_missing" do
+    it 'can access properties directly' do
+      expect(x.prop1).to eq(1)
+      expect(x.prop2).to eq(:y)
+      expect { x.prop3 }.to raise_error(NoMethodError)
+
+      expect(y.prop3).to eq(3)
+    end
+  end
+
+  describe "#respond_to_missing?" do
+    specify do
+      expect(x.respond_to?(:prop1)).to be true
+      expect(x.respond_to?(:prop2)).to be true
+      expect(x.respond_to?(:prop3)).to be false
+
+      expect(y.respond_to?(:prop3)).to be true
+    end
+  end
+end

data/spec/high_level_spec.rb

@@ -115,10 +115,10 @@ describe Wongi::Engine::Network do
     engine << ["Bob", :age, 43]
 
     items = engine.select "Alice", :younger, "Bob"
-    expect(items.size).to eq(1)
+    expect(items.count).to eq(1)
 
     items = engine.select "Bob", :older, "Alice"
-    expect(items.size).to eq(1)
+    expect(items.count).to eq(1)
   end
 
   it 'uses collectors' do

data/spec/overlay_spec.rb

@@ -52,21 +52,21 @@ describe Wongi::Engine::Overlay do
       ]
       wmes.each { overlay.assert(_1) }
 
-      expect(overlay.select(1, :_, :_)).to have(5).items
-      expect(overlay.select(2, :_, :_)).to have(4).items
-      expect(overlay.select(3, :_, :_)).to have(3).items
-      expect(overlay.select(1, 11, :_)).to have(3).items
-      expect(overlay.select(:_, 11, :_)).to have(5).items
-      expect(overlay.select(:_, :_, 113)).to have(2).items
-      expect(overlay.select(:_, 22, :_)).to have(2).items
-      expect(overlay.select(:_, 22, 222)).to have(1).items
-      expect(overlay.select(:_, :_, 222)).to have(2).items
-      expect(overlay.select(:_, :_, 223)).to have(1).items
-
-      expect(overlay.select(:_, :_, :_)).to have(wmes.length).items
-
-      expect(overlay.select(1, 11, 111)).to have(1).items
-      expect(overlay.select(1, 11, 111).first).to eq(wmes.first)
+      expect(overlay.each(1, :_, :_)).to have(5).items
+      expect(overlay.each(2, :_, :_)).to have(4).items
+      expect(overlay.each(3, :_, :_)).to have(3).items
+      expect(overlay.each(1, 11, :_)).to have(3).items
+      expect(overlay.each(:_, 11, :_)).to have(5).items
+      expect(overlay.each(:_, :_, 113)).to have(2).items
+      expect(overlay.each(:_, 22, :_)).to have(2).items
+      expect(overlay.each(:_, 22, 222)).to have(1).items
+      expect(overlay.each(:_, :_, 222)).to have(2).items
+      expect(overlay.each(:_, :_, 223)).to have(1).items
+
+      expect(overlay.each(:_, :_, :_)).to have(wmes.length).items
+
+      expect(overlay.each(1, 11, 111)).to have(1).items
+      expect(overlay.each(1, 11, 111).first).to eq(wmes.first)
     end
   end
 
@@ -85,10 +85,10 @@ describe Wongi::Engine::Overlay do
       wme = Wongi::Engine::WME.new(1, 11, 111)
 
       overlay.assert(wme)
-      expect(overlay.select(:_, :_, :_)).to have(1).items
+      expect(overlay.each(:_, :_, :_)).to have(1).items
 
       overlay.retract(wme)
-      expect(overlay.select(:_, :_, :_)).to have(0).items
+      expect(overlay.each(:_, :_, :_)).to have(0).items
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wongi-engine
 version: !ruby/object:Gem::Version
-  version: 0.4.0.pre.alpha10
+  version: 0.4.0.pre.alpha12
 platform: ruby
 authors:
 - Valeri Sokolov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-11-05 00:00:00.000000000 Z
+date: 2022-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -128,6 +128,7 @@ files:
 - lib/wongi-engine/dsl/ncc_subrule.rb
 - lib/wongi-engine/dsl/query.rb
 - lib/wongi-engine/dsl/rule.rb
+- lib/wongi-engine/entity_iterator.rb
 - lib/wongi-engine/enumerators.rb
 - lib/wongi-engine/error.rb
 - lib/wongi-engine/filter.rb
@@ -163,6 +164,7 @@ files:
 - spec/beta_node_spec.rb
 - spec/bug_specs/issue_4_spec.rb
 - spec/dataset_spec.rb
+- spec/entity_iterator_spec.rb
 - spec/generation_spec.rb
 - spec/greater_than_equality_test_spec.rb
 - spec/high_level_spec.rb