wongi-engine 0.4.0.pre.alpha3 → 0.4.0.pre.alpha4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d3401b29a9b186b8594549d45feddda88e885dae9a03d42f7006ad7e6fecbd0b
-  data.tar.gz: c315eb40f0c2a05d6a5995016fd700b6ecdb7795588fa929b81b68d86722c481
+  metadata.gz: 566bc82ac763603c9e6a5556677364af9e57449bcb839c00865c3dd8cefbc1dc
+  data.tar.gz: d8285247fbe76bcf603740f7e6a6dd603226ea5c1e47564223b851c087a148e6
 SHA512:
-  metadata.gz: ac9b80adde1174fec2361b6411d500a2c5c3c4c2659bac11d42bc630b088ccede7e3bf7d407560d099206daec5da97b0379d4c949e9891c9981d2f5847a815aa
-  data.tar.gz: 03fa343a219317c31384446debde04894d00841bd6b780a45af31968fc5a1af8fb5ca04f2d6bf17bd445e046ab8de76828c797da47ac89f68715405e128a404a
+  metadata.gz: a88bbad2800cf1701d66277cbffc646fe92e0a283bb6da8f3bc828fbfdea001d3f4040be35a039372d7db4680c7acb763ccfe91e94f233be90b5182697f24602
+  data.tar.gz: b00126ee326301079e7c257548b6ce650682f0d8637056445760a3f0cc25da96411d4be8fc50edea8f343cdf1523f9ab82ec8d719a20a232128e7622f99ae331

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

@@ -1,41 +1,37 @@
 module Wongi::Engine
   class AggregateNode < BetaNode
-    attr_reader :alpha, :tests, :assignment_pattern, :map, :function, :assign
+    attr_reader :var, :over, :partition, :aggregate, :map
 
-    def initialize(parent, alpha, tests, assignment, map, function, assign)
+    def initialize(parent, var, over, partition, aggregate, map)
       super(parent)
-      @alpha = alpha
-      @tests = tests
-      @assignment_pattern = assignment
-      @map = map
-      @function = function
-      @assign = assign
+      @var = var
+      @over = over
+      @partition = make_partition_fn(partition)
+      @aggregate = make_aggregate_fn(aggregate)
+      @map = make_map_fn(map)
     end
 
-    def equivalent?(alpha, tests, assignment_pattern)
-      return false if self.alpha != alpha
-      return false if self.assignment_pattern != assignment_pattern
-      return true if self.tests.empty? && tests.empty?
-      return false if self.tests.length != tests.length
+    def make_partition_fn(partition)
+      return nil if partition.nil?
 
-      self.tests.all? { |my_test|
-        tests.any? { |new_test|
-          my_test.equivalent? new_test
-        }
-      }
+      if Template.variable?(partition)
+        ->(token) { token[partition] }
+      elsif partition.is_a?(Array) && partition.all? { Template.variable?(_1) }
+        ->(token) { token.values_at(*partition) }
+      else
+        partition
+      end
     end
 
-    def alpha_activate(wme)
-      # we need to re-run all WMEs through the aggregator, so the new incoming one doesn't matter
-      tokens.each do |token|
-        evaluate(wme: wme, token: token)
-      end
+    def make_aggregate_fn(agg)
+      agg
     end
 
-    def alpha_deactivate(wme)
-      # we need to re-run all WMEs through the aggregator, so the new incoming one doesn't matter
-      tokens.each do |token|
-        evaluate(wme: wme, token: token)
+    def make_map_fn(map)
+      if map.nil?
+        ->(token) { token[over] }
+      else
+        map
       end
     end
 
@@ -43,42 +39,37 @@ module Wongi::Engine
       return if tokens.find { |t| t.duplicate? token }
 
       overlay.add_token(token)
-      evaluate(wme: nil, token: token)
+      evaluate
     end
 
     def beta_deactivate(token)
       overlay.remove_token(token)
-      beta_deactivate_children(token: token)
+      beta_deactivate_children(token:)
+      evaluate
     end
 
     def refresh_child(child)
-      tokens.each do |token|
-        evaluate(wme: nil, token: token, child: child)
-      end
+      evaluate(child: child)
     end
 
-    def evaluate(wme:, token:, child: nil)
-      # clean up previous decisions
-      # # TODO: optimise: only clean up if the value changed
-      beta_deactivate_children(token: token)
-
-      template = specialize(alpha.template, tests, token)
-      candidates = select_wmes(template) { |asserted_wme| matches?(token, asserted_wme) }
-
-      return if candidates.empty?
-
-      mapped = candidates.map(&map)
-      value = if function.is_a?(Symbol) && mapped.respond_to?(function)
-                mapped.send(function)
-              else
-                function.call(mapped)
-              end
-      assignments = { assign => value }
-      if child
-        child.beta_activate(Token.new(child, token, wme, assignments))
+    def evaluate(child: nil)
+      groups = if partition
+        tokens.group_by(&partition).values
       else
-        children.each do |beta|
-          beta.beta_activate(Token.new(beta, token, wme, assignments))
+        # just a single group of everything
+        [tokens]
+      end
+
+      groups.each do |tokens|
+        aggregated = self.aggregate.call(tokens.map(&self.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:, children:)
+          children.each do |beta|
+            beta.beta_activate(Token.new(beta, token, nil, assignment))
+          end
         end
       end
     end

data/lib/wongi-engine/compiler.rb

@@ -58,12 +58,9 @@ module Wongi::Engine
       end
     end
 
-    def aggregate_node(condition, tests, assignment, map, function, assign)
-      declare(assign)
-      alpha = rete.compile_alpha(condition)
-      self.node = AggregateNode.new(node, alpha, tests, assignment, map, function, assign).tap do |node|
-        alpha.betas << node unless alpha_deaf
-      end.tap(&:refresh)
+    def aggregate_node(var, over, partition, aggregate, map)
+      declare(var)
+      self.node = AggregateNode.new(node, var, over, partition, aggregate, map).tap(&:refresh)
     end
 
     def or_node(variants)

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

@@ -1,20 +1,18 @@
 module Wongi::Engine
   module DSL::Clause
-    class Aggregate < Has
-      attr_reader :map, :function, :assign
+    class Aggregate
+      attr_reader :var, :over, :partition, :aggregate, :map
 
-      def initialize(s, p, o, options = {})
-        member = options[:on]
+      def initialize(var, options = {})
+        @var = var
+        @over = options[:over]
+        @partition = options[:partition]
+        @aggregate = options[:using]
         @map = options[:map]
-        @function = options[:function]
-        @assign = options[:assign]
-        @map ||= ->(wme) { wme.send(member) }
-        super
       end
 
       def compile(context)
-        tests, assignment = parse_variables(context)
-        context.tap { |c| c.aggregate_node(self, tests, assignment, map, function, assign) }
+        context.tap { |c| c.aggregate_node(var, over, partition, aggregate, map) }
       end
     end
   end

data/lib/wongi-engine/dsl.rb

@@ -89,19 +89,29 @@ module Wongi::Engine::DSL
     clause :aggregate
     accept Clause::Aggregate
 
-    clause :least, :min
-    body { |s, p, o, opts|
-      aggregate s, p, o, on: opts[:on], function: :min, assign: opts[:assign]
+    clause :min
+    body { |var, opts|
+      aggregate var, opts.merge(using: ->(collection) { collection.min })
     }
 
-    clause :greatest, :max
-    body { |s, p, o, opts|
-      aggregate s, p, o, on: opts[:on], function: :max, assign: opts[:assign]
+    clause :max
+    body { |var, opts|
+      aggregate var, opts.merge(using: ->(collection) { collection.max })
     }
 
     clause :count
-    body { |s, p, o, opts|
-      aggregate s, p, o, map: ->(_) { 1 }, function: ->(collection) { collection.inject(&:+) }, assign: opts[:assign]
+    body { |var, opts = {}|
+      aggregate var, opts.merge(using: ->(collection) { collection.count })
+    }
+
+    clause :sum
+    body { |var, opts|
+      aggregate var, opts.merge(using: ->(collection) { collection.inject(:+) })
+    }
+
+    clause :product
+    body { |var, opts|
+      aggregate var, opts.merge(using: ->(collection) { collection.inject(:*) })
     }
 
     clause :assert, :dynamic

data/lib/wongi-engine/token.rb

@@ -40,6 +40,10 @@ module Wongi::Engine
       a.respond_to?(:call) ? a.call(self) : a
     end
 
+    def values_at(*vars)
+      vars.map { self[_1] }
+    end
+
     def has_var?(x)
       assignments.key? x
     end

data/lib/wongi-engine/version.rb

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

data/spec/aggregate_spec.rb

@@ -8,190 +8,173 @@ describe 'aggregate' do
   let(:rule_name) { SecureRandom.alphanumeric(16) }
   let(:production) { engine.productions[rule_name] }
 
-  context 'generic clause' do
-    it 'returns a single token' do
+  context 'min' do
+    it 'works' do
       engine << rule(rule_name) do
         forall {
-          aggregate :_, :weight, :_, on: :object, function: :min, assign: :X
+          has :_, :weight, :Weight
+          min :X, over: :Weight
+          has :Fruit, :weight, :X
         }
       end
 
-      expect(production.size).to be == 0
-
       engine << [:apple, :weight, 5]
       expect(production.size).to be == 1
-      expect(production.tokens.first[:X]).to be == 5
+      production.tokens.each do |token|
+        expect(token[:X]).to be == 5
+        expect(token[:Fruit]).to be == :apple
+      end
 
       engine << [:pea, :weight, 2]
-      expect(production.size).to be == 1
-      expect(production.tokens.first[:X]).to be == 2
-
-      engine << [:melon, :weight, 15]
-      expect(production.size).to be == 1
-      expect(production.tokens.first[:X]).to be == 2
+      expect(production.size).to be == 2
+      production.tokens.each do |token|
+        expect(token[:X]).to be == 2
+        expect(token[:Fruit]).to be == :pea
+      end
 
       engine.retract [:pea, :weight, 2]
       expect(production.size).to be == 1
-      expect(production.tokens.first[:X]).to be == 5
-
-      engine.retract [:apple, :weight, 5]
-      expect(production.size).to be == 1
-      expect(production.tokens.first[:X]).to be == 15
-
-      engine.retract [:melon, :weight, 15]
-      expect(production.size).to be == 0
+      production.tokens.each do |token|
+        expect(token[:X]).to be == 5
+        expect(token[:Fruit]).to be == :apple
+      end
     end
   end
 
-  context 'least' do
+  context 'max' do
     it 'works' do
       engine << rule(rule_name) do
         forall {
-          least :_, :weight, :_, on: :object, assign: :X
+          has :_, :weight, :Weight
+          max :X, over: :Weight
           has :Fruit, :weight, :X
         }
       end
 
-      engine << [:apple, :weight, 5]
-      expect(production.size).to be == 1
-      expect(production.tokens.first[:X]).to be == 5
-      expect(production.tokens.first[:Fruit]).to be == :apple
-
       engine << [:pea, :weight, 2]
       expect(production.size).to be == 1
-      expect(production.tokens.first[:X]).to be == 2
-      expect(production.tokens.first[:Fruit]).to be == :pea
-
-      engine.retract [:pea, :weight, 2]
-      expect(production.size).to be == 1
-      expect(production.tokens.first[:X]).to be == 5
-      expect(production.tokens.first[:Fruit]).to be == :apple
-    end
-  end
-
-  context 'min' do
-    it 'works' do
-      engine << rule(rule_name) do
-        forall {
-          min :_, :weight, :_, on: :object, assign: :X
-          has :Fruit, :weight, :X
-        }
+      production.tokens.each do |token|
+        expect(token[:X]).to be == 2
+        expect(token[:Fruit]).to be == :pea
       end
 
       engine << [:apple, :weight, 5]
-      expect(production.size).to be == 1
-      expect(production.tokens.first[:X]).to be == 5
-      expect(production.tokens.first[:Fruit]).to be == :apple
-
-      engine << [:pea, :weight, 2]
-      expect(production.size).to be == 1
-      expect(production.tokens.first[:X]).to be == 2
-      expect(production.tokens.first[:Fruit]).to be == :pea
+      expect(production.size).to be == 2
+      production.tokens.each do |token|
+        expect(token[:X]).to be == 5
+        expect(token[:Fruit]).to be == :apple
+      end
 
-      engine.retract [:pea, :weight, 2]
+      engine.retract [:apple, :weight, 5]
       expect(production.size).to be == 1
-      expect(production.tokens.first[:X]).to be == 5
-      expect(production.tokens.first[:Fruit]).to be == :apple
+      production.tokens.each do |token|
+        expect(token[:X]).to be == 2
+        expect(token[:Fruit]).to be == :pea
+      end
     end
   end
 
-  context 'greatest' do
+  context 'count' do
     it 'works' do
       engine << rule(rule_name) do
         forall {
-          greatest :_, :weight, :_, on: :object, assign: :X
-          has :Fruit, :weight, :X
+          has :_, :weight, :Weight
+          count :Count
         }
       end
 
-      engine << [:pea, :weight, 2]
+      engine << [:pea, :weight, 1]
       expect(production.size).to be == 1
-      expect(production.tokens.first[:X]).to be == 2
-      expect(production.tokens.first[:Fruit]).to be == :pea
+      production.tokens.each do |token|
+        expect(token[:Count]).to be == 1
+      end
 
       engine << [:apple, :weight, 5]
-      expect(production.size).to be == 1
-      expect(production.tokens.first[:X]).to be == 5
-      expect(production.tokens.first[:Fruit]).to be == :apple
+      expect(production.size).to be == 2
+      production.tokens.each do |token|
+        expect(token[:Count]).to be == 2
+      end
+
+      engine << [:watermelon, :weight, 15]
+      expect(production.size).to be == 3
+      production.tokens.each do |token|
+        expect(token[:Count]).to be == 3
+      end
 
       engine.retract [:apple, :weight, 5]
-      expect(production.size).to be == 1
-      expect(production.tokens.first[:X]).to be == 2
-      expect(production.tokens.first[:Fruit]).to be == :pea
+      expect(production.size).to be == 2
+      production.tokens.each do |token|
+        expect(token[:Count]).to be == 2
+      end
     end
-  end
 
-  context 'max' do
-    it 'works' do
+    it 'works with a post-filter' do
       engine << rule(rule_name) do
         forall {
-          max :_, :weight, :_, on: :object, assign: :X
-          has :Fruit, :weight, :X
+          has :_, :weight, :Weight
+          count :Count
+          gte :Count, 3 # pass if at least 3 matching facts exist
         }
       end
 
-      engine << [:pea, :weight, 2]
-      expect(production.size).to be == 1
-      expect(production.tokens.first[:X]).to be == 2
-      expect(production.tokens.first[:Fruit]).to be == :pea
+      engine << [:pea, :weight, 1]
+      expect(production.size).to be == 0
 
       engine << [:apple, :weight, 5]
-      expect(production.size).to be == 1
-      expect(production.tokens.first[:X]).to be == 5
-      expect(production.tokens.first[:Fruit]).to be == :apple
+      expect(production.size).to be == 0
+
+      engine << [:watermelon, :weight, 15]
+      expect(production.size).to be == 3
+      production.tokens.each do |token|
+        expect(token[:Count]).to be == 3
+      end
 
       engine.retract [:apple, :weight, 5]
-      expect(production.size).to be == 1
-      expect(production.tokens.first[:X]).to be == 2
-      expect(production.tokens.first[:Fruit]).to be == :pea
+      expect(production.size).to be == 0
     end
   end
 
-  context 'count' do
+  context 'partitioning by a single var' do
     it 'works' do
       engine << rule(rule_name) do
         forall {
-          count :_, :weight, :_, assign: :Count
+          has :factor, :Number, :Factor
+          product :Product, over: :Factor, partition: :Number
         }
       end
 
-      engine << [:pea, :weight, 1]
-      expect(production.size).to be == 1
-      expect(production.tokens.first[:Count]).to be == 1
-
-      engine << [:apple, :weight, 5]
-      expect(production.size).to be == 1
-      expect(production.tokens.first[:Count]).to be == 2
-
-      engine << [:watermelon, :weight, 15]
-      expect(production.size).to be == 1
-      expect(production.tokens.first[:Count]).to be == 3
+      engine << [:factor, 10, 2]
+      engine << [:factor, 10, 5]
+      engine << [:factor, 12, 3]
+      engine << [:factor, 12, 4]
 
-      engine.retract [:apple, :weight, 5]
-      expect(production.size).to be == 1
-      expect(production.tokens.first[:Count]).to be == 2
+      expect(production).to have(4).tokens
+      production.tokens.each do |token|
+        expect(token[:Product]).to be_a(Integer)
+        expect(token[:Product]).to eq(token[:Number])
+      end
     end
+  end
 
-    it 'works with a post-filter' do
+  context 'partitioning by a list' do
+    it 'works' do
       engine << rule(rule_name) do
         forall {
-          count :_, :weight, :_, assign: :Count
-          gte :Count, 3 # pass if at least 3 matching facts exist
+          has :factor, :Number, :Factor
+          product :Product, over: :Factor, partition: [:Number]
         }
       end
 
-      engine << [:pea, :weight, 1]
-      expect(production.size).to be == 0
-
-      engine << [:apple, :weight, 5]
-      expect(production.size).to be == 0
-
-      engine << [:watermelon, :weight, 15]
-      expect(production.size).to be == 1
-      expect(production.tokens.first[:Count]).to be == 3
+      engine << [:factor, 10, 2]
+      engine << [:factor, 10, 5]
+      engine << [:factor, 12, 3]
+      engine << [:factor, 12, 4]
 
-      engine.retract [:apple, :weight, 5]
-      expect(production.size).to be == 0
+      expect(production).to have(4).tokens
+      production.tokens.each do |token|
+        expect(token[:Product]).to be_a(Integer)
+        expect(token[:Product]).to eq(token[:Number])
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wongi-engine
 version: !ruby/object:Gem::Version
-  version: 0.4.0.pre.alpha3
+  version: 0.4.0.pre.alpha4
 platform: ruby
 authors:
 - Valeri Sokolov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-11-01 00:00:00.000000000 Z
+date: 2022-11-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry