bcdd-result 0.11.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c0043be8de0b26bac0d803f067537fbc65e4a54f3a38a2644c01bd987d87c7b5
-  data.tar.gz: f152ac78abb8847721f2b2ec3c3fd1db66016c421f5348f038a79501a86f761a
+  metadata.gz: 677f88c68eb0f745246a910bbf4a659103a5695f3c5bd74f6ac6f0ba9ff3729f
+  data.tar.gz: 2966e659671b84bed72b2fb7ab4daaa19a1572a5480af3c19ab2a41b720d1265
 SHA512:
-  metadata.gz: 17abccc11ad3c7ccd2cedc6f9634659decee457e08ef1c8dfb13d59d2afc7390fdeb6fc1d48749362d691815c41b789197d2bf79b5f57f9e7e07ad770ddbb304
-  data.tar.gz: 2e0b67fbc99ef2a3a8187a2d42212e8cbadca22a2c2625c3be8e7bbfb5d2b92689b9a27b7592a295863e89437e912d34cb8f6e5a2e77e9c0afdbcbf7c4591bd6
+  metadata.gz: ee78777c66384e185ff7c1c816ea9fa2787ab14cde530a2fb2a9ec943755b86846a0a03cbc2742c2530cf9487380e9d23ce47663de366483d77af4bfe1fa3c8c
+  data.tar.gz: 7396cf7283c4d22dd7b03be855cf6f3a8e9c15ebbf8ef5194c34de762b99e9d6a41345066f7990be5a0e47e50da4bf38811191eb06916803881a12fab7a854b1

data/CHANGELOG.md

@@ -1,41 +1,61 @@
 - [\[Unreleased\]](#unreleased)
-- [\[0.11.0\] - 2024-01-02](#0110---2024-01-02)
+- [\[0.12.0\] - 2024-01-07](#0120---2024-01-07)
   - [Added](#added)
   - [Changed](#changed)
-- [\[0.10.0\] - 2023-12-31](#0100---2023-12-31)
+- [\[0.11.0\] - 2024-01-02](#0110---2024-01-02)
   - [Added](#added-1)
-- [\[0.9.1\] - 2023-12-12](#091---2023-12-12)
   - [Changed](#changed-1)
-  - [Fixed](#fixed)
-- [\[0.9.0\] - 2023-12-12](#090---2023-12-12)
+- [\[0.10.0\] - 2023-12-31](#0100---2023-12-31)
   - [Added](#added-2)
+- [\[0.9.1\] - 2023-12-12](#091---2023-12-12)
   - [Changed](#changed-2)
-- [\[0.8.0\] - 2023-12-11](#080---2023-12-11)
+  - [Fixed](#fixed)
+- [\[0.9.0\] - 2023-12-12](#090---2023-12-12)
   - [Added](#added-3)
   - [Changed](#changed-3)
-  - [Removed](#removed)
-- [\[0.7.0\] - 2023-10-27](#070---2023-10-27)
+- [\[0.8.0\] - 2023-12-11](#080---2023-12-11)
   - [Added](#added-4)
   - [Changed](#changed-4)
-- [\[0.6.0\] - 2023-10-11](#060---2023-10-11)
+  - [Removed](#removed)
+- [\[0.7.0\] - 2023-10-27](#070---2023-10-27)
   - [Added](#added-5)
   - [Changed](#changed-5)
-- [\[0.5.0\] - 2023-10-09](#050---2023-10-09)
+- [\[0.6.0\] - 2023-10-11](#060---2023-10-11)
   - [Added](#added-6)
-- [\[0.4.0\] - 2023-09-28](#040---2023-09-28)
-  - [Added](#added-7)
   - [Changed](#changed-6)
+- [\[0.5.0\] - 2023-10-09](#050---2023-10-09)
+  - [Added](#added-7)
+- [\[0.4.0\] - 2023-09-28](#040---2023-09-28)
+  - [Added](#added-8)
+  - [Changed](#changed-7)
   - [Removed](#removed-1)
 - [\[0.3.0\] - 2023-09-26](#030---2023-09-26)
-  - [Added](#added-8)
-- [\[0.2.0\] - 2023-09-26](#020---2023-09-26)
   - [Added](#added-9)
+- [\[0.2.0\] - 2023-09-26](#020---2023-09-26)
+  - [Added](#added-10)
   - [Removed](#removed-2)
 - [\[0.1.0\] - 2023-09-25](#010---2023-09-25)
-  - [Added](#added-10)
+  - [Added](#added-11)
 
 ## [Unreleased]
 
+## [0.12.0] - 2024-01-07
+
+### Added
+
+- Add `BCDD::Result#and_then!` and `BCDD::Result::Context#and_then!` to execute a callable object (any object that responds to `#call`) to produce a result. The main difference between the `#and_then` and `#and_then!` is that the latter does not check the result source.
+  - **Attention:** to ensure the correct behavior, do not mix `#and_then` and `#and_then!` in the same result chain.
+  - This feature is turned off by default. You can enable it through the `BCDD::Result.config.feature.enable!(:and_then!)`.
+  - The method called by default (`:call`) can be changed through `BCDD::Result.config.and_then!.default_method_name_to_call=`.
+
+### Changed
+
+- **(BREAKING)** Renames the subject concept/term to `source`. When a mixin is included/extended, it defines the `Success()` and `Failure()` methods. Since the results are generated in a context (instance or singleton where the mixin was used), they will have a defined source (instance or singleton itself).
+  > Definition of source
+  >
+  > From dictionary:
+  > * a place, person, or thing from which something comes or can be obtained.
+
 ## [0.11.0] - 2024-01-02
 
 ### Added
@@ -45,6 +65,14 @@
 ### Changed
 
 - **(BREAKING)** Rename halted concept to terminal. Failures are terminal by default, but you can make a success terminal by enabling the `:continue` addon.
+  > Definition of terminal
+  >
+  > From dictionary:
+  > * of, forming, or situated at the end or extremity of something.
+  > * the end of a railroad or other transport route, or a station at such a point.
+  >
+  > From Wikipedia:
+  > * A "terminus" or "terminal" is a station at the end of a railway line.
 
 - **(BREAKING)** Rename `BCDD::Result::Context::Success#and_expose` halted keyword argument to `terminal`.
 

data/README.md

@@ -78,6 +78,12 @@ Use it to enable the [Railway Oriented Programming](https://fsharpforfunandprofi
     - [`config.pattern_matching.disable!(:nil_as_valid_value_checking)`](#configpattern_matchingdisablenil_as_valid_value_checking)
     - [`config.feature.disable!(:expectations)`](#configfeaturedisableexpectations)
   - [`BCDD::Result.config`](#bcddresultconfig)
+- [`BCDD::Result#and_then!`](#bcddresultand_then)
+    - [Dependency Injection](#dependency-injection-1)
+    - [Configuration](#configuration-1)
+    - [Analysis: Why is `and_then!` an Anti-pattern?](#analysis-why-is-and_then-an-anti-pattern)
+    - [`#and_then` versus `#and_then!`](#and_then-versus-and_then)
+    - [Analysis: Why is `#and_then` the antidote/standard?](#analysis-why-is-and_then-the-antidotestandard)
 - [About](#about)
 - [Development](#development)
 - [Contributing](#contributing)
@@ -649,9 +655,9 @@ Divide.call(2, 2)
 
 This method generates a module that any object can include or extend. It adds two methods to the target object: `Success()` and `Failure()`.
 
-The main difference between these methods and `BCDD::Result::Success()`/`BCDD::Result::Failure()` is that the former will utilize the target object (which has received the include/extend) as the result's subject.
+The main difference between these methods and `BCDD::Result::Success()`/`BCDD::Result::Failure()` is that the former will utilize the target object (which has received the include/extend) as the result's source.
 
-Because the result has a subject, the `#and_then` method can call methods from it.
+Because the result has a source, the `#and_then` method can call methods from it.
 
 ##### Class example (Instance Methods)
 
@@ -746,9 +752,9 @@ Divide.call(4, '2') #<BCDD::Result::Failure type=:invalid_arg value="arg2 must b
 
 To use the `#and_then` method to call methods, they must use `Success()` and `Failure()` to produce the results.
 
-If you try to use `BCDD::Result::Subject()`/`BCDD::Result::Failure()`, or results from another `BCDD::Result.mixin` instance with `#and_then`, it will raise an error because the subjects will be different.
+If you try to use `BCDD::Result::Success()`/`BCDD::Result::Failure()`, or results from another `BCDD::Result.mixin` instance with `#and_then`, it will raise an error because the sources are different.
 
-**Note:** You can still use the block syntax, but all the results must be produced by the subject's `Success()` and `Failure()` methods.
+**Note:** You can still use the block syntax, but all the results must be produced by the source's `Success()` and `Failure()` methods.
 
 ```ruby
 module ValidateNonzero
@@ -794,13 +800,13 @@ Look at the error produced by the code above:
 ```ruby
 Divide.call(2, 0)
 
-# You cannot call #and_then and return a result that does not belong to the subject! (BCDD::Result::Error::InvalidResultSubject)
-# Expected subject: Divide
-# Given subject: ValidateNonzero
+# You cannot call #and_then and return a result that does not belong to the same source! (BCDD::Result::Error::InvalidResultSource)
+# Expected source: Divide
+# Given source: ValidateNonzero
 # Given result: #<BCDD::Result::Failure type=:division_by_zero value="arg2 must not be zero">
 ```
 
-In order to fix this, you must handle the result produced by `ValidateNonzero.call()` and return a result that belongs to the subject.
+In order to fix this, you must handle the result produced by `ValidateNonzero.call()` and return a result that belongs to the same source.
 
 ```ruby
 module ValidateNonzero
@@ -832,7 +838,8 @@ module Divide
   end
 
   def validate_nonzero(numbers)
-    # In this case we are handling the other subject result and returning our own
+    # In this case we are handling the result from other source
+    # and returning our own
     ValidateNonzero.call(numbers).handle do |on|
       on.success { |numbers| Success(:ok, numbers) }
 
@@ -858,8 +865,8 @@ Divide.call(2, 0)
 
 ##### Dependency Injection
 
-The `BCDD::Result#and_then` accepts a second argument that will be used to share a value with the subject's method.
-To receive this argument, the subject's method must have an arity of two, where the first argument will be the result value and the second will be the shared value.
+The `BCDD::Result#and_then` accepts a second argument that will be used to share a value with the source's method.
+To receive this argument, the source's method must have an arity of two, where the first argument will be the result value and the second will be the injected value.
 
 ```ruby
 require 'logger'
@@ -1863,7 +1870,7 @@ result.transitions
       :parent=>{:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
       :current=>{:id=>1, :name=>"Division", :desc=>"divide two numbers"},
       :result=>{:kind=>:success, :type=>:continued, :value=>[20, 2]},
-      :and_then=>{:type=>:method, :arg=>nil, :subject=><Division:0x0000000106099028>, :method_name=>:require_numbers},
+      :and_then=>{:type=>:method, :arg=>nil, :source=><Division:0x0000000106099028>, :method_name=>:require_numbers},
       :time=>2024-01-02 03:35:11.248558 UTC
     },
     {
@@ -1871,7 +1878,7 @@ result.transitions
       :parent=>{:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
       :current=>{:id=>1, :name=>"Division", :desc=>"divide two numbers"},
       :result=>{:kind=>:success, :type=>:continued, :value=>[20, 2]},
-      :and_then=>{:type=>:method, :arg=>nil, :subject=><Division:0x0000000106099028>, :method_name=>:check_for_zeros},
+      :and_then=>{:type=>:method, :arg=>nil, :source=><Division:0x0000000106099028>, :method_name=>:check_for_zeros},
       :time=>2024-01-02 03:35:11.248587 UTC
     },
     {
@@ -1879,7 +1886,7 @@ result.transitions
       :parent=>{:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
       :current=>{:id=>1, :name=>"Division", :desc=>"divide two numbers"},
       :result=>{:kind=>:success, :type=>:division_completed, :value=>10},
-      :and_then=>{:type=>:method, :arg=>nil, :subject=><Division:0x0000000106099028>, :method_name=>:divide},
+      :and_then=>{:type=>:method, :arg=>nil, :source=><Division:0x0000000106099028>, :method_name=>:divide},
       :time=>2024-01-02 03:35:11.248607 UTC
     },
     {
@@ -1895,7 +1902,7 @@ result.transitions
       :parent=>{:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
       :current=>{:id=>2, :name=>"Division", :desc=>"divide two numbers"},
       :result=>{:kind=>:success, :type=>:continued, :value=>[10, 2]},
-      :and_then=>{:type=>:method, :arg=>nil, :subject=><Division:0x0000000106097ed0>, :method_name=>:require_numbers},
+      :and_then=>{:type=>:method, :arg=>nil, :source=><Division:0x0000000106097ed0>, :method_name=>:require_numbers},
       :time=>2024-01-02 03:35:11.248661 UTC
     },
     {
@@ -1903,7 +1910,7 @@ result.transitions
       :parent=>{:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
       :current=>{:id=>2, :name=>"Division", :desc=>"divide two numbers"},
       :result=>{:kind=>:success, :type=>:continued, :value=>[10, 2]},
-      :and_then=>{:type=>:method, :arg=>nil, :subject=><Division:0x0000000106097ed0>, :method_name=>:check_for_zeros},
+      :and_then=>{:type=>:method, :arg=>nil, :source=><Division:0x0000000106097ed0>, :method_name=>:check_for_zeros},
       :time=>2024-01-02 03:35:11.248672 UTC
     },
     {
@@ -1911,7 +1918,7 @@ result.transitions
       :parent=>{:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
       :current=>{:id=>2, :name=>"Division", :desc=>"divide two numbers"},
       :result=>{:kind=>:success, :type=>:division_completed, :value=>5},
-      :and_then=>{:type=>:method, :arg=>nil, :subject=><Division:0x0000000106097ed0>, :method_name=>:divide},
+      :and_then=>{:type=>:method, :arg=>nil, :source=><Division:0x0000000106097ed0>, :method_name=>:divide},
       :time=>2024-01-02 03:35:11.248682 UTC
     },
     {
@@ -2078,10 +2085,206 @@ BCDD::Result.config.feature.options
 #       "BCDD::Result",
 #       "BCDD::Result::Context"
 #     ]
-#   }
+#   },
+#   :and_then!=>{
+#     :enabled=>false,
+#     :affects=>[
+#       "BCDD::Result",
+#       "BCDD::Result::Context"
+#     ]
+#   },
 # }
 ```
 
+<p align="right"><a href="#-bcddresult">⬆️ &nbsp;back to top</a></p>
+
+## `BCDD::Result#and_then!`
+
+In the Ruby ecosystem, several gems facilitate operation composition using classes and modules. Two notable examples are the `interactor` gem and the `u-case` gem.
+
+**`interactor` gem example**
+
+```ruby
+class PlaceOrder
+  include Interactor::Organizer
+
+  organize CreateOrder,
+           PayOrder,
+           SendOrderConfirmation,
+           NotifyAdmins
+end
+```
+
+**`u-case` gem example**
+
+```ruby
+class PlaceOrder < Micro::Case
+  flow CreateOrder, PayOrder, SendOrderConfirmation, NotifyAdmins
+end
+
+# Alternative approach
+class PlaceOrder < Micro::Case
+  def call!
+    call(CreateOrder)
+      .then(PayOrder)
+      .then(SendOrderConfirmation)
+      .then(NotifyAdmins)
+  end
+end
+```
+
+To facilitate migration for users accustomed to the above approaches, `bcdd-result` includes the `BCDD::Result#and_then!`/`BCDD::Result::Context#and_then!` methods, which will invoke the method `call` of the given operation and expect it to return a `BCDD::Result`/`BCDD::Result::Context` object.
+
+```ruby
+BCDD::Result.configure do |config|
+  config.feature.enable!(:and_then!)
+end
+
+class PlaceOrder
+  include BCDD::Result::Context.mixin
+
+  def call(**input)
+    Given(input)
+      .and_then!(CreateOrder.new)
+      .and_then!(PayOrder.new)
+      .and_then!(SendOrderConfirmation.new)
+      .and_then!(NotifyAdmins.new)
+  end
+end
+```
+
+<p align="right"><a href="#-bcddresult">⬆️ &nbsp;back to top</a></p>
+
+#### Dependency Injection
+
+Like `#and_then`, `#and_then!` also supports an additional argument for dependency injection.
+
+**In BCDD::Result**
+
+```ruby
+class PlaceOrder
+  include BCDD::Result.mixin
+
+  def call(input, logger:)
+    Given(input)
+      .and_then!(CreateOrder.new, logger)
+      # Further method chaining...
+  end
+end
+```
+
+**In BCDD::Result::Context**
+
+```ruby
+class PlaceOrder
+  include BCDD::Result::Context.mixin
+
+  def call(logger:, **input)
+    Given(input)
+      .and_then!(CreateOrder.new, logger:)
+      # Further method chaining...
+  end
+end
+```
+
+<p align="right"><a href="#-bcddresult">⬆️ &nbsp;back to top</a></p>
+
+#### Configuration
+
+```ruby
+BCDD::Result.configure do |config|
+  config.feature.enable!(:and_then!)
+
+  config.and_then!.default_method_name_to_call = :perform
+end
+```
+
+**Explanation:**
+
+- `enable!(:and_then!)`: Activates the `and_then!` feature.
+
+- `default_method_name_to_call`: Sets a default method other than `:call` for `and_then!`.
+
+<p align="right"><a href="#-bcddresult">⬆️ &nbsp;back to top</a></p>
+
+#### Analysis: Why is `and_then!` an Anti-pattern?
+
+The `and_then!` approach, despite its brevity, introduces several issues:
+
+- **Lack of Clarity:** The input/output relationship between the steps is not apparent.
+
+- **Steps Coupling:** Each operation becomes interdependent (high coupling), complicating implementation and compromising the reusability of these operations.
+
+We recommend cautious use of `#and_then!`. Due to these issues, it is turned off by default and considered an antipattern.
+
+It should be a temporary solution, primarily for assisting in migration from another to gem to `bcdd-result`.
+
+<p align="right"><a href="#-bcddresult">⬆️ &nbsp;back to top</a></p>
+
+#### `#and_then` versus `#and_then!`
+
+The main difference between the `#and_then` and `#and_then!` is that the latter does not check the result source. However, as a drawback, the result source will change.
+
+Attention: to ensure the correct behavior, do not mix `#and_then` and `#and_then!` in the same result chain.
+
+<p align="right"><a href="#-bcddresult">⬆️ &nbsp;back to top</a></p>
+
+#### Analysis: Why is `#and_then` the antidote/standard?
+
+The `BCDD::Result#and_then`/`BCDD::Result::Context#and_then` methods diverge from the above approach by requiring explicit invocation and mapping of the outcomes at each process step. This approach has the following advantages:
+
+- **Clarity:** The input/output relationship between the steps is apparent and highly understandable.
+
+- **Steps uncoupling:** Each operation becomes independent (low coupling). You can even map a failure result to a success (and vice versa).
+
+See this example to understand what your code should look like:
+
+```ruby
+class PlaceOrder
+  include BCDD::Result::Context.mixin(config: { addon: { continue: true } })
+
+  def call(**input)
+    Given(input)
+      .and_then(:create_order)
+      .and_then(:pay_order)
+      .and_then(:send_order_confirmation)
+      .and_then(:notify_admins)
+      .and_expose(:order_placed, %i[order])
+  end
+
+  private
+
+  def create_order(customer:, products:)
+    CreateOrder.new.call(customer:, products:).handle do |on|
+      on.success { |output| Continue(order: output[:order]) }
+      on.failure { |error| Failure(:order_creation_failed, error:) }
+    end
+  end
+
+  def pay_order(customer:, order:, payment_method:, **)
+    PayOrder.new.call(customer:, payment_method:, order:).handle do |on|
+      on.success { |output| Continue(payment: output[:payment]) }
+      on.failure { |error| Failure(:order_payment_failed, error:) }
+    end
+  end
+
+  def send_order_confirmation(customer:, order:, payment:, **)
+    SendOrderConfirmation.new.call(customer:, order:, payment:).handle do |on|
+      on.success { Continue() }
+      on.failure { |error| Failure(:order_confirmation_failed, error:) }
+    end
+  end
+
+  def notify_admins(customer:, order:, payment:, **)
+    NotifyAdmins.new.call(customer:, order:, payment:)
+
+    Continue()
+  end
+end
+```
+
+<p align="right"><a href="#-bcddresult">⬆️ &nbsp;back to top</a></p>
+
 ## About
 
 [Rodrigo Serradura](https://github.com/serradura) created this project. He is the B/CDD process/method creator and has already made similar gems like the [u-case](https://github.com/serradura/u-case) and [kind](https://github.com/serradura/kind/blob/main/lib/kind/result.rb). This gem is a general-purpose abstraction/monad, but it also contains key features that serve as facilitators for adopting B/CDD in the code.

data/lib/bcdd/result/callable_and_then/caller.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+class BCDD::Result
+  class CallableAndThen::Caller
+    def self.call(source, value:, injected_value:, method_name:)
+      method = callable_method(source, method_name)
+
+      Transitions.tracking.record_and_then(method, injected_value, source) do
+        result =
+          if source.is_a?(::Proc)
+            call_proc!(source, value, injected_value)
+          else
+            call_method!(source, method, value, injected_value)
+          end
+
+        ensure_result_object(source, value, result)
+      end
+    end
+
+    def self.call_proc!(source, value, injected_value)
+      case source.arity
+      when 1 then source.call(value)
+      when 2 then source.call(value, injected_value)
+      else raise CallableAndThen::Error::InvalidArity.build(source: source, method: :call, arity: '1..2')
+      end
+    end
+
+    def self.call_method!(source, method, value, injected_value)
+      case method.arity
+      when 1 then source.send(method.name, value)
+      when 2 then source.send(method.name, value, injected_value)
+      else raise CallableAndThen::Error::InvalidArity.build(source: source, method: method.name, arity: '1..2')
+      end
+    end
+
+    def self.callable_method(source, method_name)
+      source.method(method_name || Config.instance.and_then!.default_method_name_to_call)
+    end
+
+    def self.ensure_result_object(source, _value, result)
+      return result if result.is_a?(::BCDD::Result)
+
+      raise Error::UnexpectedOutcome.build(outcome: result, origin: source)
+    end
+
+    private_class_method :new, :allocate
+    private_class_method :call_proc!, :call_method!, :callable_method, :ensure_result_object
+  end
+end

data/lib/bcdd/result/callable_and_then/config.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class BCDD::Result
+  class CallableAndThen::Config
+    attr_accessor :default_method_name_to_call
+
+    def initialize
+      self.default_method_name_to_call = :call
+    end
+
+    def options
+      { default_method_name_to_call: default_method_name_to_call }
+    end
+  end
+end

data/lib/bcdd/result/callable_and_then/error.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class BCDD::Result
+  class CallableAndThen::Error < Error
+    class InvalidArity < self
+      def self.build(source:, method:, arity:)
+        new("Invalid arity for #{source.class}##{method} method. Expected arity: #{arity}")
+      end
+    end
+  end
+end

data/lib/bcdd/result/callable_and_then.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class BCDD::Result
+  module CallableAndThen
+    require_relative 'callable_and_then/error'
+    require_relative 'callable_and_then/config'
+    require_relative 'callable_and_then/caller'
+  end
+end

data/lib/bcdd/result/config/switchers/features.rb

@@ -10,7 +10,11 @@ class BCDD::Result
         },
         transitions: {
           default: true,
-          affects: %w[BCDD::Result BCDD::Result::Context]
+          affects: %w[BCDD::Result BCDD::Result::Context BCDD::Result::Expectations BCDD::Result::Context::Expectations]
+        },
+        and_then!: {
+          default: false,
+          affects: %w[BCDD::Result BCDD::Result::Context BCDD::Result::Expectations BCDD::Result::Context::Expectations]
         }
       }.transform_values!(&:freeze).freeze
 

data/lib/bcdd/result/config.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'singleton'
-
 require_relative 'config/options'
 require_relative 'config/switcher'
 require_relative 'config/switchers/addons'
@@ -20,6 +18,11 @@ class BCDD::Result
       @feature = Features.switcher
       @constant_alias = ConstantAliases.switcher
       @pattern_matching = PatternMatching.switcher
+      @and_then_ = CallableAndThen::Config.new
+    end
+
+    def and_then!
+      @and_then_
     end
 
     def freeze
@@ -27,6 +30,7 @@ class BCDD::Result
       feature.freeze
       constant_alias.freeze
       pattern_matching.freeze
+      and_then!.freeze
 
       super
     end
@@ -45,7 +49,9 @@ class BCDD::Result
     end
 
     def inspect
-      "#<#{self.class.name} options=#{options.keys.sort.inspect}>"
+      "#<#{self.class.name} " \
+        "options=#{options.keys.sort.inspect} " \
+        "and_then!=#{and_then!.options.inspect}>"
     end
   end
 end

data/lib/bcdd/result/context/callable_and_then.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+class BCDD::Result
+  module Context::CallableAndThen
+    class Caller < CallableAndThen::Caller
+      module KeyArgs
+        def self.parameters?(source)
+          parameters = source.parameters.map(&:first)
+
+          !parameters.empty? && parameters.all?(/\Akey/)
+        end
+
+        def self.invalid_arity(source, method)
+          CallableAndThen::Error::InvalidArity.build(source: source, method: method, arity: 'only keyword args')
+        end
+      end
+
+      def self.call_proc!(source, value, _injected_value)
+        return source.call(**value) if KeyArgs.parameters?(source)
+
+        raise KeyArgs.invalid_arity(source, :call)
+      end
+
+      def self.call_method!(source, method, value, _injected_value)
+        return source.send(method.name, **value) if KeyArgs.parameters?(method)
+
+        raise KeyArgs.invalid_arity(source, method.name)
+      end
+
+      def self.ensure_result_object(source, value, result)
+        return result.tap { result.send(:acc).then { _1.merge!(value.merge(_1)) } } if result.is_a?(Context)
+
+        raise Error::UnexpectedOutcome.build(outcome: result, origin: source, expected: Context::EXPECTED_OUTCOME)
+      end
+
+      private_class_method :call_proc!, :call_method!
+    end
+  end
+end

data/lib/bcdd/result/context/expectations/mixin.rb

@@ -9,7 +9,7 @@ class BCDD::Result::Context
     module Addons
       module Continue
         private def Continue(**value)
-          Success.new(type: :continued, value: value, subject: self)
+          Success.new(type: :continued, value: value, source: self)
         end
       end
 
@@ -17,7 +17,7 @@ class BCDD::Result::Context
         private def Given(*values)
           value = values.map(&:to_h).reduce({}) { |acc, val| acc.merge(val) }
 
-          Success.new(type: :given, value: value, subject: self)
+          Success.new(type: :given, value: value, source: self)
         end
       end
 

data/lib/bcdd/result/context/mixin.rb

@@ -14,7 +14,7 @@ class BCDD::Result::Context
       end
 
       private def _ResultAs(kind_class, type, value, terminal: nil)
-        kind_class.new(type: type, value: value, subject: self, terminal: terminal)
+        kind_class.new(type: type, value: value, source: self, terminal: terminal)
       end
     end
 

data/lib/bcdd/result/context/success.rb

@@ -1,15 +1,19 @@
 # frozen_string_literal: true
 
-class BCDD::Result::Context::Success < BCDD::Result::Context
-  include ::BCDD::Result::Success::Methods
+class BCDD::Result
+  class Context::Success < Context
+    include ::BCDD::Result::Success::Methods
 
-  def and_expose(type, keys, terminal: true)
-    unless keys.is_a?(::Array) && !keys.empty? && keys.all?(::Symbol)
-      raise ::ArgumentError, 'keys must be an Array of Symbols'
-    end
+    def and_expose(type, keys, terminal: true)
+      unless keys.is_a?(::Array) && !keys.empty? && keys.all?(::Symbol)
+        raise ::ArgumentError, 'keys must be an Array of Symbols'
+      end
+
+      Transitions.tracking.reset_and_then!
 
-    exposed_value = acc.merge(value).slice(*keys)
+      exposed_value = acc.merge(value).slice(*keys)
 
-    self.class.new(type: type, value: exposed_value, subject: subject, terminal: terminal)
+      self.class.new(type: type, value: exposed_value, source: source, terminal: terminal)
+    end
   end
 end