decide.rb 0.5.4 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 67225cdb4ecbd0f8577bc2c9744e85958a6fc74252e29014bb957e0c927ee0d9
-  data.tar.gz: 62bf259ddc73c780bc7993e4b597c90e45a047a4981263e81afdc44dcf07399a
+  metadata.gz: cbe851f7fea959e98b1b98f0151962c495cfb36195307b4fb44a6116fe15f4a5
+  data.tar.gz: 5770da3f08fe829c42489195c9f0a16e4b3f8cef174c7793d4b057a6d8f3fe20
 SHA512:
-  metadata.gz: d7e5a790ab4d45b0d73a189ecdb19907ca139742a61f02dd146c38aa8e61619c55f744095085d89292f3f53976f60ecec17799b3dcc58166a0e5201eb3b8641a
-  data.tar.gz: f27228fda1b9ca07c19cb01d004576ef106de6a2c96c7ce19a4a4b7976b4a5260dca7c91bb59d2404009387152ccd0ce10537e00fe9e76d0e8054992946055d3
+  metadata.gz: 20757b12712eda8e22c8a63705ebf06aaa5aadd3489df5119af3ac63ca58858e00fb8e128088e33dc7832dc8f66cb8debf1283fdce32e1aebfad06ea9ff91fae
+  data.tar.gz: 7553cf027e1e79477ba67344bd65bb35d49db76863d52f680aeb59f4ae638ce8c948fb4f81b99e4e44aa7d8a00f8613323cbd10f3b980ce55e6a29c1e8fa5235

data/CHANGELOG.md

@@ -1,3 +1,98 @@
+# 0.6.0
+
+* All extensions takes decider as last argument
+
+```ruby
+# Before
+Decider.dimap_on_state(decider, fl:, fr:)
+Decider.dimap_on_event(decider, fl:, fr:)
+Decider.lmap_on_event(decider, fn)
+Decider.lmap_on_command(decider, fn)
+Decider.lmap_on_state(decider, fn)
+Decider.rmap_on_event(decider, fn)
+Decider.rmap_on_state(decider, fn)
+
+# After
+Decider.dimap_on_state(fl, fr, decider)
+Decider.dimap_on_event(fl, fr, decider)
+Decider.lmap_on_event(fn, decider)
+Decider.lmap_on_command(fn, decider)
+Decider.lmap_on_state(fn, decider)
+Decider.rmap_on_event(fn, decider)
+Decider.rmap_on_state(fn, decider)
+```
+
+# 0.5.5
+
+* Add `lmap_on_command` extension that takes proc that maps command and returns a new decider
+
+```ruby
+decider = Decider.define do
+  initial_state 0
+
+  decide :increase do
+    emit :increased
+  end
+end
+
+lmap = decider.lmap_on_command(->(command) { command.to_sym })
+lmap.decide("increase", 0)
+# => [:increased]
+```
+
+* Add `map` extension that works the same way as `rmap_on_state` but `Decider.map` takes function first
+
+```ruby
+# equivalent
+Decider.rmap_on_state(decider, fn)
+Decider.map(fn, decider)
+decider.rmap_on_state(fn)
+decider.map(fn)
+```
+
+* Add `map2` extension that takes function with two arguments and two deciders and returns a decider:
+
+```ruby
+dx = Decider.define do
+  initial_state({score: 0})
+
+  decide :score do
+    emit :scored
+  end
+
+  evolve :scored do
+    {score: state[:score] + 1}
+  end
+end
+
+dy = Decider.define do
+  initial_state({time: 0})
+
+  decide :tick do
+    emit :ticked
+  end
+
+  evolve :ticked do
+    {time: state[:time] + 1}
+  end
+end
+
+decider = Decider.map2(
+  ->(sx, sy) { {score: sx[:score], time: sy[:time]} }, dx, dy
+)
+
+decider.initial_state
+# => {score: 0, time: 0}
+decider.decide(:score, decider.initial_state)
+# => [:scored]
+decider.decide(:tick, decider.initial_state)
+# => [:ticked]
+decider.evolve(decider.initial_state, :scored)
+# => {score: 1, time: 0}
+decider.evolve(decider.initial_state, :ticked)
+# => {score: 0, time: 1}
+```
+
 # 0.5.4
 
 * Add `lmap_on_event` and `rmap_on_event` extensions that takes proc that maps event in or out and returns a new decider
@@ -7,7 +102,7 @@ decider = Decider.define do
   initial_state 0
 
   decide :increase do
-    :increased
+    emit :increased
   end
 
   evolve :increased do
@@ -84,7 +179,7 @@ inner = Decider.define do
   initial_state 0
 
   decide :increase do
-    :increased
+    emit :increased
   end
 
   evolve :increased do

data/lib/decider/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Decider
-  VERSION = "0.5.4"
+  VERSION = "0.6.0"
 end

data/lib/decider.rb

@@ -108,28 +108,36 @@ module Decider
         context.instance_exec(&terminal)
       end
 
+      define_method(:lmap_on_command) do |fn|
+        Decider.lmap_on_command(fn, self)
+      end
+
       define_method(:lmap_on_state) do |fn|
-        Decider.lmap_on_state(self, fn)
+        Decider.lmap_on_state(fn, self)
+      end
+
+      define_method(:map) do |fn|
+        Decider.map(fn, self)
       end
 
       define_method(:rmap_on_state) do |fn|
-        Decider.rmap_on_state(self, fn)
+        Decider.rmap_on_state(fn, self)
       end
 
       define_method(:dimap_on_state) do |fl:, fr:|
-        Decider.dimap_on_state(self, fl: fl, fr: fr)
+        Decider.dimap_on_state(fl, fr, self)
       end
 
       define_method(:lmap_on_event) do |fn|
-        Decider.lmap_on_event(self, fn)
+        Decider.lmap_on_event(fn, self)
       end
 
       define_method(:rmap_on_event) do |fn|
-        Decider.rmap_on_event(self, fn)
+        Decider.rmap_on_event(fn, self)
       end
 
       define_method(:dimap_on_event) do |fl:, fr:|
-        Decider.dimap_on_event(self, fl: fl, fr: fr)
+        Decider.dimap_on_event(fl, fr, self)
       end
     end
   end
@@ -227,15 +235,37 @@ module Decider
     end
   end
 
-  def self.lmap_on_state(decider, fn)
-    dimap_on_state(decider, fl: fn, fr: ->(state) { state })
+  def self.lmap_on_command(fn, decider)
+    define do
+      initial_state decider.initial_state
+
+      decide proc { true } do
+        decider.decide(fn.call(command), state).each(&method(:emit))
+      end
+
+      evolve proc { true } do
+        decider.evolve(state, event)
+      end
+
+      terminal? do
+        decider.terminal?(state)
+      end
+    end
   end
 
-  def self.rmap_on_state(decider, fn)
-    dimap_on_state(decider, fl: ->(state) { state }, fr: fn)
+  def self.lmap_on_state(fn, decider)
+    dimap_on_state(fn, ->(state) { state }, decider)
   end
 
-  def self.dimap_on_state(decider, fl:, fr:)
+  def self.map(fn, decider)
+    dimap_on_state(->(state) { state }, fn, decider)
+  end
+
+  def self.rmap_on_state(fn, decider)
+    dimap_on_state(->(state) { state }, fn, decider)
+  end
+
+  def self.dimap_on_state(fl, fr, decider)
     define do
       initial_state fr.call(decider.initial_state)
 
@@ -253,15 +283,15 @@ module Decider
     end
   end
 
-  def self.lmap_on_event(decider, fn)
-    dimap_on_event(decider, fl: fn, fr: ->(event) { event })
+  def self.lmap_on_event(fn, decider)
+    dimap_on_event(fn, ->(event) { event }, decider)
   end
 
-  def self.rmap_on_event(decider, fn)
-    dimap_on_event(decider, fl: ->(event) { event }, fr: fn)
+  def self.rmap_on_event(fn, decider)
+    dimap_on_event(->(event) { event }, fn, decider)
   end
 
-  def self.dimap_on_event(decider, fl:, fr:)
+  def self.dimap_on_event(fl, fr, decider)
     define do
       initial_state decider.initial_state
 
@@ -280,4 +310,26 @@ module Decider
       end
     end
   end
+
+  def self.map2(fn, dx, dy)
+    define do
+      initial_state fn.call(dx.initial_state, dy.initial_state)
+
+      decide proc { true } do
+        dx.decide(command, state).each(&method(:emit))
+        dy.decide(command, state).each(&method(:emit))
+      end
+
+      evolve proc { true } do
+        fn.call(
+          dx.evolve(state, event),
+          dy.evolve(state, event)
+        )
+      end
+
+      terminal? do
+        dx.terminal?(state) && dy.terminal?(state)
+      end
+    end
+  end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: decide.rb
 version: !ruby/object:Gem::Version
-  version: 0.5.4
+  version: 0.6.0
 platform: ruby
 authors:
 - Jan Dudulski
 bindir: exe
 cert_chain: []
-date: 2025-06-21 00:00:00.000000000 Z
+date: 2025-06-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby