decide.rb 0.5.3 → 0.5.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d34cbcdaf2713fe8bd44d975d9d9bd40801af014cc84e3e37c69bee8ef14b1b2
-  data.tar.gz: 8f82294e16473b2ae75040cd5b1da79c3ddca4d77f103ea86c57a498f004b1d4
+  metadata.gz: a644014eccc9464b607d16d44c6181de06b712c1aab8e2d33d407de838723fe8
+  data.tar.gz: 1dbdd3c6a7b3b7efa189d857afa28da43d4f72ac1cc3ca72801bb86b854dfa73
 SHA512:
-  metadata.gz: 400fb7bb3bb77f17578bf15b36f4d88213694562c1626736c0433ddce2b1fa43ad84dd3a87b6b8eb641f862838aff0848210fe40caeffb20234779aa6db0b8be
-  data.tar.gz: 7b8ecedf12b070c414aa7a41d30675d0038f439f6d892990ad74a9289ad3d2df006c78ea402557b3f80c2ec36343d434563b44d58f267b30af919d848ded3469
+  metadata.gz: 751a52fb88eef2b129cd439765c6d9083759fd3eda0727b831202d4a903e86532fc41ba4633753f0a3318aa197d64a974d612c3d8abedc0fe102d1c28a101fd7
+  data.tar.gz: 2b658d6758c820c6d199c59a0275ea4cf49eee221570c4c8447f72b240207e9f717e1f3537da02f67512baf3976e448d7611ca49bbf5088032f88e79b2b89989

data/CHANGELOG.md

@@ -1,3 +1,138 @@
+# 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
+
+```ruby
+decider = Decider.define do
+  initial_state 0
+
+  decide :increase do
+    emit :increased
+  end
+
+  evolve :increased do
+    state + 1
+  end
+end
+
+lmap = decider.lmap_on_event(->(event) { event.to_sym })
+lmap.evolve(0, "increased")
+# => 1
+
+rmap = decider.rmap_on_event(->(event) { event.to_s })
+rmap.decide(:increase, 0)
+# => "increased"
+```
+
+* Add `lmap_on_state` and `rmap_on_state` extensions that takes proc that maps state in or out and returns a new decider
+
+```ruby
+decider = Decider.define do
+  initial_state :symbol
+
+  decide :command, :state do
+    emit :called
+  end
+
+  evolve :state, :called do
+    :new_state
+  end
+end
+decider.initial_state
+# => :symbol
+
+lmap = decider.lmap_on_state(
+  ->(state) { state.to_sym }
+)
+lmap.initial_state
+# => :symbol
+lmap.decide(:command, "symbol")
+# => [:called]
+lmap.evolve("symbol", :called)
+# => :new_state
+
+rmap = inner.rmap_on_state(
+  ->(state) { state.to_s }
+)
+rmap.initial_state
+# => "symbol"
+rmap.decide(:command, :symbol)
+# => [:called]
+rmap.evolve(:symbol, :called)
+# => "new_state"
+```
+
 # 0.5.3
 
 * Add shortcut for evolving:
@@ -20,7 +155,7 @@ inner = Decider.define do
   initial_state 0
 
   decide :increase do
-    :increased
+    emit :increased
   end
 
   evolve :increased do
@@ -28,7 +163,7 @@ inner = Decider.define do
   end
 end
 
-outer = decider.dimap_on_event(
+outer = inner.dimap_on_event(
   fl: ->(event) { event.to_sym },
   fr: ->(event) { event.to_s }
 )
@@ -51,7 +186,7 @@ end
 inner.initial_state
 # => :symbol
 
-outer = decider.dimap_on_state(
+outer = inner.dimap_on_state(
   fl: ->(state) { state.to_sym },
   fr: ->(state) { state.to_s }
 )

data/examples/decide.md

@@ -18,7 +18,7 @@ decider = Decider.define do
 end
 
 decider.decide Command.new(value: 10), decider.initial_state
-#> [Event.new(value: 15)]
+#> [#<data Event value=15>]
 ```
 
 ## Match by command and state
@@ -138,7 +138,7 @@ decider = Decider.define do
     emit [:started, command.value]
   end
 
-  decide proc { [command, state] in [Stop, [:started, _]] } do
+  decide proc { [command, state] in [Stop, :started] } do
     emit :stopped
   end
 end

data/examples/evolve.md

@@ -1,25 +1,88 @@
 # Evolve
 
-## Handling unknown events
+## Match by event
 
 ```ruby
+Event = Data.define(:value)
+
 decider = Decider.define do
   initial_state :initial
+
+  evolve Event do
+    event.value
+  end
 end
+
+decider.evolve decider.initial_state, Event.new(value: :changed)
+#> :changed
 ```
 
-Return state (nothing changed) by default:
+## Match by state and event
 
 ```ruby
+decider = Decider.define do
+  initial_state :turned_off
+
+  evolve :turned_on, :turned_off do
+    event
+  end
+
+  evolve :turned_off, :turned_on do
+    event
+  end
+end
+
+decider.evolve decider.initial_state, :turned_on
+#> :turned_on
+decider.evolve :turned_on, :turned_off
+#> :turned_off
+decider.evolve :turned_on, :unknown
+#> :turned_on
+```
+
+## Match by pattern matching
+
+```ruby
+State = Data.define(:value)
+Event = Data.define(:value)
+
+decider = Decider.define do
+  initial_state State.new(value: :turned_off)
+
+  evolve proc { [state, event] in [State(value: :turned_off), Event(value: :turned_on)] } do
+    state.with(value: event.value)
+  end
+end
+
+decider.evolve decider.initial_state, Event.new(value: :turned_on)
+#> #<data State value=:turned_on>
 decider.evolve decider.initial_state, :unknown
+#> #<data State value=:turned_off>
+```
+
+## Handling unknown events
+
+```ruby
+decider = Decider.define do
+  initial_state :initial
+end
+
+decider.decide decider.initial_state, :initial
 #> :initial
 ```
 
-Raise error when using `evolve!`:
+If you want to raise error, define a catch-all as last one:
 
 ```ruby
-decider.evolve! decider.initial_state, :unknown
-#> raise ArgumentError, Unknown event
+decider = Decider.define do
+  initial_state :initial
+
+  evolve proc { true } do
+    raise ArgumentError, "Unknown event #{event}"
+  end
+end
+decider.evolve decider.initial_state, :unknown
+#> Unknown event unknown (ArgumentError)
 ```
 
 ## Events
@@ -30,11 +93,11 @@ Events can be primitives like symbols:
 decider = Decider.define do
   initial_state :initial
 
-  evolve :started do |state, event|
+  evolve :started do
     :started
   end
 
-  evolve :stopped do |state, event|
+  evolve :stopped do
     :stopped
   end
 end
@@ -50,13 +113,38 @@ Stopped = Data.define
 decider = Decider.define do
   initial_state State.new(speed: 0)
 
-  evolve Started do |state, event|
-    State.new(speed: event.speed)
+  evolve State, Started do
+    state.with(speed: event.speed)
   end
 
-  evolve Stopped do |state, event|
+  evolve State, Stopped do
     State.new(speed: 0)
   end
 end
 ```
 
+## Calculate state
+
+In most cases you want to take a collection of events and reduce them with `evolve` to calculate the state, like:
+
+```ruby
+decider = Decider.define do
+  initial_state 0
+
+  evolve :increased do
+    state + 1
+  end
+end
+
+[:increased, :increased].reduce(decider.initial_state) { |state, event| decider.evolve(state, event) }
+#> 2
+```
+
+You can shortcut that with `&`:
+
+```ruby
+[:increased, :increased].reduce(decider.initial_state, &decider.method(:evolve))
+#> 2
+[:increased, :increased].reduce(decider.initial_state, &decider.evolve)
+#> 2
+```

data/examples/state.md

@@ -8,11 +8,11 @@ State = Data.define(:value)
 decider = Decider.define do
   initial_state State.new(value: 0)
 
-  decide Commands::Command do |command, state|
-    [Events::Event.new(value: command.value)]
+  decide Commands::Command do
+    emit Events::Event.new(value: command.value)
   end
 
-  evolve Events::Event do |state, event|
+  evolve Events::Event do
     state.with(value: state.value + 1)
   end
 end
@@ -24,26 +24,16 @@ end
 decider = Decider.define do
   initial_state :turned_off
 
-  decide Commands::TurnOn do |_command, state|
-    case state
-    in :turned_off
-      [Events::TurnedOn.new]
-    else
-      []
-    end
+  decide Commands::TurnOn, :turned_off do
+    emit Events::TurnedOn.new
   end
 
-  decide Commands::TurnOff do |_command, state|
-    case state
-    in :turned_on
-      [Events::TurnedOn.new]
-    else
-      []
-    end
+  decide Commands::TurnOff, :turned_on do
+    emit Events::TurnedOff.new
   end
 
-  evolve Events::TurnedOn do |_state, _event|
-    :turned_off
+  evolve Events::TurnedOn do
+    :turned_on
   end
 end
 ```
@@ -54,12 +44,12 @@ end
 decider = Decider.define do
   initial_state []
 
-  decide Commands::Command do |command, _state|
-    [Events::Event.new(value: command.value)]
+  decide Commands::Command, [] do
+    emit Events::Event.new(value: command.value)
   end
 
-  evolve Events::Event do |state, event|
-    state = state + [event]
+  evolve Events::Event do
+    state + [event]
   end
 end
 ```

data/lib/decider/version.rb

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

data/lib/decider.rb

@@ -108,10 +108,34 @@ module Decider
         context.instance_exec(&terminal)
       end
 
+      define_method(:lmap_on_command) do |fn|
+        Decider.lmap_on_command(self, fn)
+      end
+
+      define_method(:lmap_on_state) do |fn|
+        Decider.lmap_on_state(self, fn)
+      end
+
+      define_method(:map) do |fn|
+        Decider.map(fn, self)
+      end
+
+      define_method(:rmap_on_state) do |fn|
+        Decider.rmap_on_state(self, fn)
+      end
+
       define_method(:dimap_on_state) do |fl:, fr:|
         Decider.dimap_on_state(self, fl: fl, fr: fr)
       end
 
+      define_method(:lmap_on_event) do |fn|
+        Decider.lmap_on_event(self, fn)
+      end
+
+      define_method(:rmap_on_event) do |fn|
+        Decider.rmap_on_event(self, fn)
+      end
+
       define_method(:dimap_on_event) do |fl:, fr:|
         Decider.dimap_on_event(self, fl: fl, fr: fr)
       end
@@ -211,6 +235,36 @@ module Decider
     end
   end
 
+  def self.lmap_on_command(decider, fn)
+    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.lmap_on_state(decider, fn)
+    dimap_on_state(decider, fl: fn, fr: ->(state) { state })
+  end
+
+  def self.map(fn, decider)
+    dimap_on_state(decider, fl: ->(state) { state }, fr: fn)
+  end
+
+  def self.rmap_on_state(decider, fn)
+    dimap_on_state(decider, fl: ->(state) { state }, fr: fn)
+  end
+
   def self.dimap_on_state(decider, fl:, fr:)
     define do
       initial_state fr.call(decider.initial_state)
@@ -229,6 +283,14 @@ module Decider
     end
   end
 
+  def self.lmap_on_event(decider, fn)
+    dimap_on_event(decider, fl: fn, fr: ->(event) { event })
+  end
+
+  def self.rmap_on_event(decider, fn)
+    dimap_on_event(decider, fl: ->(event) { event }, fr: fn)
+  end
+
   def self.dimap_on_event(decider, fl:, fr:)
     define do
       initial_state decider.initial_state
@@ -248,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.3
+  version: 0.5.5
 platform: ruby
 authors:
 - Jan Dudulski
 bindir: exe
 cert_chain: []
-date: 2025-04-15 00:00:00.000000000 Z
+date: 2025-06-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby