functional-light-service 6.0.0 → 6.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a02972ac6e701ec1ed5ceafcea5880e961ccbaf23ff886fe8f490c5bb514e6e1
-  data.tar.gz: 0a35af1df1d0820de886bae015cc84846dc0809d4602d12528c7f716b537a2f9
+  metadata.gz: 436934533c3db4aa6ac6e3ce7410b67454fe0e7f3f8b516e9b6ba7674e86fc29
+  data.tar.gz: c4a36634905f4253a0d32bf9068b70a236f67291e43e20d02f3617679a797ef7
 SHA512:
-  metadata.gz: 1ec467e5b62e74629391dfaf9b2e0ede5534338b3ce1411f9c0f7c4a9c38b7aa880701ddd98e4fd5f8a61fa7e8dc741633c626a6b422c544084c825e883b1453
-  data.tar.gz: e526d9bd6c3736ea555db60add374336dd6a9e957f7fae265bee44282ffe0dbb2fb43bba03eaafd210aab7bcf1f9d1f7af96391fa34b680dacfe4cd148fff4ca
+  metadata.gz: 8ba109d1688a3e2e3c1904682d55e800cd841fa7870364f04916d9f5528ac0e954fe28f650261b1217c0d0819f0df0c1143331fd82f72a1dfc6726549a95cc82
+  data.tar.gz: 4da5cc5beae3e452b7400ce696a05a7ab5e69c354d27cd3c3e918c86ef47166789a7349a9967215ca53f35cb4d00dac986ac109d673cee00e07abace42b6569f

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+## 6.1.0 (2026-07-03)
+
+### Added
+-  Sequencer: do-notation per Result con in_sequence/get/let/and_then/observe/and_yield, portato dalla gem deterministic (MIT) e incluso nel Prelude ( 2026-07-03 ) [ sphynx79]
+
+
+
 ## 6.0.0 (2026-07-03)
 
 Release maggiore guidata da un audit tecnico completo (vedi `AUDIT-functional-light-service.md`

data/README.md

@@ -28,6 +28,7 @@
   * [Usage](#functional-usage)
     * [Result: Success & Failure](#functional-usage-success-failure)
     * [Result Chaining](#functional-usage-chaining)
+    * [Sequencing (do-notation)](#functional-usage-sequencing)
     * [Complex Example in a Builder Action](#functional-usage-complex-action)
     * [Pattern matching](#functional-usage-pattern-matching)
     * [Option](#functional-usage-option)
@@ -1150,6 +1151,39 @@ Success(params) >>
   build_response
 ```
 
+### Sequencing (do-notation) – `in_sequence` <a name="functional-usage-sequencing"></a>
+
+When a pipeline needs the intermediate values of earlier steps, chaining alone
+gets awkward. `in_sequence` (ported from the [deterministic](https://github.com/pzol/deterministic)
+gem, MIT License) gives you a do-notation style block: each step returns a
+`Result`, the sequence short-circuits on the first `Failure`, and values bound
+with `get`/`let` are available to all subsequent steps by name.
+
+```ruby
+class DownloadRemit
+  include FunctionalLightService::Prelude
+
+  def call(row)
+    in_sequence do
+      get(:url)      { extract_url(row) }        # binds the Success value to :url
+      get(:file)     { fetch(url) }              # :url is available here
+      let(:name)     { File.basename(url) }      # binds a plain (non-Result) value
+      and_then       { validate(file) }          # step without binding
+      observe        { logger.info("got #{name}") } # side effect, return value ignored
+      and_yield      { Success(name) }           # final result of the sequence
+    end
+  end
+end
+```
+
+* `get(:name) { ... }` – runs a step returning a `Result`; on `Success` binds the
+  unwrapped value to `name`, on `Failure` stops the sequence and returns it.
+* `let(:name) { ... }` – binds the block's plain return value (no `Result` involved).
+* `and_then { ... }` – runs a step returning a `Result` without binding its value.
+* `observe { ... }` – runs a side effect; its return value is ignored.
+* `and_yield { ... }` – mandatory final step; its `Result` is the value of the
+  whole `in_sequence` block.
+
 #### Complex Example in a Builder Action <a name="functional-usage-complex-action"></a>
 
 ```ruby

data/lib/functional-light-service/functional/sequencer.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require 'delegate'
+
+module FunctionalLightService
+  # Do-notation for Result: chains steps that return Success/Failure,
+  # short-circuiting on the first Failure. Ported from the deterministic
+  # gem (MIT License, Copyright (c) Piotr Zolnierek and contributors,
+  # https://github.com/pzol/deterministic).
+  #
+  #   in_sequence do
+  #     get(:user)  { fetch_user(id) }      # binds the Success value to :user
+  #     let(:name)  { user.fetch(:name) }   # binds a plain (non-Result) value
+  #     and_then    { validate(user) }      # step without binding
+  #     observe     { log(name) }           # side effect, return value ignored
+  #     and_yield   { Success(name) }       # final result of the sequence
+  #   end
+  module Sequencer
+    class InvalidSequenceError < StandardError; end
+
+    module Operation
+      Get = Struct.new(:block, :name)
+      Let = Struct.new(:block, :name)
+      AndThen = Struct.new(:block)
+      Observe = Struct.new(:block)
+      AndYield = Struct.new(:block)
+    end
+
+    def in_sequence(&)
+      sequencer = Sequencer.new(self)
+      sequencer.instance_eval(&)
+      sequencer.yield
+    end
+
+    class Sequencer
+      def initialize(instance)
+        @operations = []
+        @operation_wrapper = OperationWrapper.new(instance)
+      end
+
+      def get(name, &block)
+        raise ArgumentError, 'no block given' unless block_given?
+        raise InvalidSequenceError, 'and_yield already called' if @sequenced_operations
+
+        @operations << Operation::Get.new(block, name)
+      end
+
+      def let(name, &block)
+        raise ArgumentError, 'no block given' unless block_given?
+        raise InvalidSequenceError, 'and_yield already called' if @sequenced_operations
+
+        @operations << Operation::Let.new(block, name)
+      end
+
+      def and_then(&block)
+        raise ArgumentError, 'no block given' unless block_given?
+        raise InvalidSequenceError, 'and_yield already called' if @sequenced_operations
+
+        @operations << Operation::AndThen.new(block)
+      end
+
+      def observe(&block)
+        raise ArgumentError, 'no block given' unless block_given?
+        raise InvalidSequenceError, 'and_yield already called' if @sequenced_operations
+
+        @operations << Operation::Observe.new(block)
+      end
+
+      def and_yield(&block)
+        raise ArgumentError, 'no block given' unless block_given?
+        raise InvalidSequenceError, 'and_yield already called' if @sequenced_operations
+
+        @operations << Operation::AndYield.new(block)
+
+        prepare_sequenced_operations
+      end
+
+      def yield
+        raise InvalidSequenceError, 'and_yield not called' unless @sequenced_operations
+
+        @operation_wrapper.instance_eval(&@sequenced_operations)
+      end
+
+      private
+
+      # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
+      def prepare_sequenced_operations
+        operations = @operations
+
+        @sequenced_operations = ->(_) do
+          operations.reduce(Result::Success.new(nil)) do |last_result, operation|
+            last_result.map do
+              case operation
+              when Operation::Get
+                result = instance_eval(&operation.block)
+                result.map do |output|
+                  # Runs in the context of the OperationWrapper, so the
+                  # bound value is stored within the wrapper itself.
+                  @gotten_results[operation.name] = output
+                  result
+                end
+              when Operation::Let
+                @gotten_results[operation.name] = instance_eval(&operation.block)
+                last_result
+              when Operation::Observe
+                instance_eval(&operation.block)
+                last_result
+              when Operation::AndThen, Operation::AndYield
+                instance_eval(&operation.block)
+              end
+            end
+          end
+        end
+      end
+      # rubocop:enable Metrics/MethodLength, Metrics/CyclomaticComplexity
+    end
+
+    # OperationWrapper proxies all method calls to the wrapped instance, but
+    # first checks if the name of the called method matches a value stored
+    # within @gotten_results and returns the value if it does.
+    class OperationWrapper < SimpleDelegator
+      def initialize(*args)
+        super
+        @gotten_results = {}
+      end
+
+      def method_missing(name, *args, **kwargs, &)
+        if @gotten_results.key?(name)
+          @gotten_results[name]
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        @gotten_results.key?(name) || super
+      end
+    end
+  end
+
+  module Prelude
+    include Sequencer
+  end
+end

data/lib/functional-light-service/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module FunctionalLightService
-  VERSION = "6.0.0"
+  VERSION = "6.1.0"
 end

data/lib/functional-light-service.rb

@@ -12,6 +12,7 @@ require 'functional-light-service/functional/enum'
 require 'functional-light-service/functional/result'
 require 'functional-light-service/functional/option'
 require 'functional-light-service/functional/null'
+require 'functional-light-service/functional/sequencer'
 require 'functional-light-service/errors'
 require 'functional-light-service/configuration'
 require 'functional-light-service/localization_adapter'

data/spec/lib/deterministic/sequencer_spec.rb

@@ -0,0 +1,506 @@
+require 'spec_helper'
+
+describe FunctionalLightService::Sequencer do
+  include FunctionalLightService::Prelude::Result
+
+  let(:test_class) { Class.new { include FunctionalLightService::Sequencer } }
+  let(:test_instance) { test_class.new }
+  let(:arbitrary_success) { Success(double) }
+
+  # This mock method makes #arbitrary_success available within the operations
+  # in the test sequences
+  before { allow(test_instance).to receive(:arbitrary_success).and_return(arbitrary_success) }
+
+  it 'requires #and_yield to be specified' do
+    expect do
+      in_sequence do
+        get(:_) { arbitrary_success }
+      end
+    end.to raise_error(described_class::InvalidSequenceError, 'and_yield not called')
+  end
+
+  it 'does not allow calling #and_yield multiple times' do
+    expect do
+      in_sequence do
+        and_yield { arbitrary_success }
+        and_yield { arbitrary_success }
+      end
+    end.to raise_error(described_class::InvalidSequenceError, 'and_yield already called')
+  end
+
+  it 'does not allow calling #get after #and_yield' do
+    expect do
+      in_sequence do
+        and_yield { arbitrary_success }
+        get(:_) { arbitrary_success }
+      end
+    end.to raise_error(described_class::InvalidSequenceError, 'and_yield already called')
+  end
+
+  it 'does not allow calling #let after #and_yield' do
+    expect do
+      in_sequence do
+        and_yield { arbitrary_success }
+        let(:_) { arbitrary_success }
+      end
+    end.to raise_error(described_class::InvalidSequenceError, 'and_yield already called')
+  end
+
+  it 'does not allow calling #and_then after #and_yield' do
+    expect do
+      in_sequence do
+        and_yield { arbitrary_success }
+        and_then { arbitrary_success }
+      end
+    end.to raise_error(described_class::InvalidSequenceError, 'and_yield already called')
+  end
+
+  it 'does not allow calling #observe after #and_yield' do
+    expect do
+      in_sequence do
+        and_yield { arbitrary_success }
+        observe { arbitrary_success }
+      end
+    end.to raise_error(described_class::InvalidSequenceError, 'and_yield already called')
+  end
+
+  it 'requires a block for every operation' do
+    expect { in_sequence { get(:_) } }.to raise_error(ArgumentError, 'no block given')
+    expect { in_sequence { let(:_) } }.to raise_error(ArgumentError, 'no block given')
+    expect { in_sequence { and_then } }.to raise_error(ArgumentError, 'no block given')
+    expect { in_sequence { observe } }.to raise_error(ArgumentError, 'no block given')
+    expect { in_sequence { and_yield } }.to raise_error(ArgumentError, 'no block given')
+  end
+
+  context 'when #and_yield succeeds' do
+    let(:yielder_result) { Success('yield') }
+    before { allow(test_instance).to receive(:yielder).and_return(yielder_result) }
+
+    it "returns and_yield's result" do
+      result = in_sequence do
+        and_yield { yielder }
+      end
+      expect(result).to eq(yielder_result)
+    end
+
+    it 'ignores the return value of the #in_sequence block' do
+      result = in_sequence do
+        and_yield { yielder }
+        'a different return value'
+      end
+      expect(result).to eq(yielder_result)
+    end
+  end
+
+  context 'when #and_yield fails' do
+    let(:yielder_result) { Failure('yield') }
+    before { allow(test_instance).to receive(:yielder).and_return(yielder_result) }
+
+    it "returns and_yield's result" do
+      result = in_sequence do
+        and_yield { yielder }
+      end
+      expect(result).to eq(yielder_result)
+    end
+  end
+
+  context 'when #get succeeds' do
+    let(:getter_result) { Success('get') }
+    before { allow(test_instance).to receive(:getter).and_return(getter_result) }
+
+    it 'its result is available in a subsequent #get' do
+      allow(test_instance).to receive(:second_getter).and_return(arbitrary_success)
+
+      in_sequence do
+        get(:get_result) { getter }
+        get(:_) { second_getter(get_result) }
+        and_yield { arbitrary_success }
+      end
+
+      expect(test_instance).to have_received(:second_getter).with(getter_result.value)
+    end
+
+    it 'its result is not available in a previous #get' do
+      allow(test_instance).to receive(:second_getter)
+
+      expect do
+        in_sequence do
+          get(:_) { second_getter(get_result) }
+          get(:get_result) { getter }
+          and_yield { arbitrary_success }
+        end
+      end.to raise_error(NameError)
+    end
+
+    it 'its result is available in a subsequent #and_then' do
+      allow(test_instance).to receive(:and_then_function).and_return(arbitrary_success)
+
+      in_sequence do
+        get(:get_result) { getter }
+        and_then { and_then_function(get_result) }
+        and_yield { arbitrary_success }
+      end
+
+      expect(test_instance).to have_received(:and_then_function).with(getter_result.value)
+    end
+
+    it 'its result is available in a subsequent #observe' do
+      allow(test_instance).to receive(:observer)
+
+      in_sequence do
+        get(:get_result) { getter }
+        observe { observer(get_result) }
+        and_yield { arbitrary_success }
+      end
+
+      expect(test_instance).to have_received(:observer).with(getter_result.value)
+    end
+
+    it 'its result is available in #and_yield' do
+      allow(test_instance).to receive(:yielder).and_return(arbitrary_success)
+
+      in_sequence do
+        get(:get_result) { getter }
+        and_yield { yielder(get_result) }
+      end
+
+      expect(test_instance).to have_received(:yielder).with(getter_result.value)
+    end
+  end
+
+  context 'when multiple #gets succeed' do
+    let(:first_getter_result) { Success('get1') }
+    let(:second_getter_result) { Success('get2') }
+
+    before do
+      allow(test_instance).to receive(:first_getter).and_return(first_getter_result)
+      allow(test_instance).to receive(:second_getter).and_return(second_getter_result)
+    end
+
+    it 'both results are available in subsequent operations' do
+      allow(test_instance).to receive(:yielder).and_return(arbitrary_success)
+
+      in_sequence do
+        get(:first_get_result) { first_getter }
+        get(:second_get_result) { second_getter }
+        and_yield { yielder(first_get_result, second_get_result) }
+      end
+
+      expect(test_instance).to have_received(:yielder)
+        .with(first_getter_result.value, second_getter_result.value)
+    end
+  end
+
+  context 'when #get fails' do
+    let(:getter_result) { Failure('get') }
+    before { allow(test_instance).to receive(:getter).and_return(getter_result) }
+
+    it 'does not invoke subsequent #gets' do
+      allow(test_instance).to receive(:second_getter).and_return(arbitrary_success)
+
+      in_sequence do
+        get(:get_result) { getter }
+        get(:_) { second_getter(get_result) }
+        and_yield { arbitrary_success }
+      end
+
+      expect(test_instance).not_to have_received(:second_getter)
+    end
+
+    it 'does not invoke subsequent #and_thens' do
+      allow(test_instance).to receive(:and_then_function).and_return(arbitrary_success)
+
+      in_sequence do
+        get(:get_result) { getter }
+        and_then { and_then_function(get_result) }
+        and_yield { arbitrary_success }
+      end
+
+      expect(test_instance).not_to have_received(:and_then_function)
+    end
+
+    it 'does not invoke subsequent #observes' do
+      allow(test_instance).to receive(:observer)
+
+      in_sequence do
+        get(:get_result) { getter }
+        observe { observer(get_result) }
+        and_yield { arbitrary_success }
+      end
+
+      expect(test_instance).not_to have_received(:observer)
+    end
+
+    it 'does not invoke #and_yield' do
+      allow(test_instance).to receive(:yielder).and_return(arbitrary_success)
+
+      in_sequence do
+        get(:get_result) { getter }
+        and_yield { yielder }
+      end
+
+      expect(test_instance).not_to have_received(:yielder)
+    end
+
+    it 'returns the failure' do
+      result = in_sequence do
+        get(:get_result) { getter }
+        and_yield { arbitrary_success }
+      end
+
+      expect(result).to eq(getter_result)
+    end
+  end
+
+  context 'when #let succeeds' do
+    let(:object) { { :a => 'a' } }
+    before { allow(test_instance).to receive(:object).and_return(object) }
+
+    it 'its result is available in a subsequent #let' do
+      allow(test_instance).to receive(:test_function)
+
+      in_sequence do
+        let(:a) { object.fetch(:a) }
+        let(:_) { test_function(a) }
+        and_yield { arbitrary_success }
+      end
+
+      expect(test_instance).to have_received(:test_function).with(object.fetch(:a))
+    end
+
+    it 'its result is available in a subsequent #and_then' do
+      allow(test_instance).to receive(:and_then_function).and_return(arbitrary_success)
+
+      in_sequence do
+        let(:a) { object.fetch(:a) }
+        and_then { and_then_function(a) }
+        and_yield { arbitrary_success }
+      end
+
+      expect(test_instance).to have_received(:and_then_function).with(object.fetch(:a))
+    end
+
+    it 'its result is available in a subsequent #observe' do
+      allow(test_instance).to receive(:observer)
+
+      in_sequence do
+        let(:a) { object.fetch(:a) }
+        observe { observer(a) }
+        and_yield { arbitrary_success }
+      end
+
+      expect(test_instance).to have_received(:observer).with(object.fetch(:a))
+    end
+
+    it 'its result is available in #and_yield' do
+      allow(test_instance).to receive(:yielder).and_return(arbitrary_success)
+
+      in_sequence do
+        let(:a) { object.fetch(:a) }
+        and_yield { yielder(a) }
+      end
+
+      expect(test_instance).to have_received(:yielder).with(object.fetch(:a))
+    end
+  end
+
+  context 'when #let raises an error' do
+    let(:object) { { :a => 'a' } }
+    before { allow(test_instance).to receive(:object).and_return(object) }
+
+    it 'bubbles the raised error' do
+      expect do
+        in_sequence do
+          let(:b) { object.fetch(:b) }
+          and_yield { arbitrary_success }
+        end
+      end.to raise_error(KeyError)
+    end
+
+    it 'does not invoke #and_yield' do
+      allow(test_instance).to receive(:yielder).and_return(arbitrary_success)
+
+      begin
+        in_sequence do
+          let(:b) { object.fetch(:b) }
+          and_yield { yielder }
+        end
+      rescue KeyError
+        # Ignore
+      end
+
+      expect(test_instance).not_to have_received(:yielder)
+    end
+  end
+
+  context 'when #and_then succeeds' do
+    let(:and_then_result) { Success('and_then') }
+    before { allow(test_instance).to receive(:and_then_function).and_return(and_then_result) }
+
+    it 'continues the sequence' do
+      allow(test_instance).to receive(:another_step).and_return(arbitrary_success)
+
+      in_sequence do
+        and_then { and_then_function }
+        and_then { another_step }
+        and_yield { arbitrary_success }
+      end
+
+      expect(test_instance).to have_received(:another_step)
+    end
+  end
+
+  context 'when #and_then fails' do
+    let(:and_then_result) { Failure('and_then') }
+    before { allow(test_instance).to receive(:and_then_function).and_return(and_then_result) }
+
+    it 'does not continue the sequence' do
+      allow(test_instance).to receive(:another_step).and_return(arbitrary_success)
+
+      in_sequence do
+        and_then { and_then_function }
+        and_then { another_step }
+        and_yield { arbitrary_success }
+      end
+
+      expect(test_instance).not_to have_received(:another_step)
+    end
+
+    it 'returns the failure' do
+      result = in_sequence do
+        and_then { and_then_function }
+        and_yield { arbitrary_success }
+      end
+
+      expect(result).to eq(and_then_result)
+    end
+  end
+
+  context 'when #observe returns a failure' do
+    let(:observe_result) { Failure('observe') }
+    before { allow(test_instance).to receive(:observer).and_return(observe_result) }
+
+    it 'its return value is ignored and the sequence continues' do
+      allow(test_instance).to receive(:another_step).and_return(arbitrary_success)
+
+      in_sequence do
+        observe { observer }
+        and_then { another_step }
+        and_yield { arbitrary_success }
+      end
+
+      expect(test_instance).to have_received(:another_step)
+    end
+  end
+
+  it 'does not allow calling methods outside of the wrapped instance' do
+    expect do
+      in_sequence do
+        and_yield { top_level_test_method }
+      end
+    end.to raise_error(NameError)
+  end
+
+  context 'when including FunctionalLightService::Prelude' do
+    let(:test_class) { Class.new { include FunctionalLightService::Prelude } }
+
+    it '#in_sequence is available' do
+      expect do
+        in_sequence do
+          and_yield { arbitrary_success }
+        end
+      end.not_to raise_error
+    end
+  end
+
+  context 'readme example' do
+    let(:test_class) do
+      Class.new do
+        include FunctionalLightService::Prelude
+
+        # rubocop:disable Metrics/AbcSize
+        def call(input)
+          in_sequence do
+            get(:sanitized_input) { sanitize(input) }
+            and_then              { validate(sanitized_input) }
+            get(:user)            { get_user_from_db(sanitized_input) }
+            let(:name)            { user.fetch(:name) }
+            observe               { log('user name', name) }
+            get(:request)         { build_request(sanitized_input, user) }
+            observe               { log('sending request', request) }
+            get(:response)        { send_request(request) }
+            observe               { log('got response', response) }
+            and_yield             { format_response(response) }
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        def sanitize(input)
+          sanitized_input = input
+          Success(sanitized_input)
+        end
+
+        def validate(sanitized_input)
+          Success(sanitized_input)
+        end
+
+        def get_user_from_db(sanitized_input)
+          Success(:type => :admin, :id => sanitized_input.fetch(:id), :name => 'John')
+        end
+
+        def build_request(sanitized_input, user)
+          Success(:input => sanitized_input, :user => user)
+        end
+
+        def log(message, data)
+          # logger.info(message, data)
+        end
+
+        def send_request(_request)
+          Success(:status => 200)
+        end
+
+        def format_response(response)
+          Success(:response => response, :message => 'it worked')
+        end
+      end
+    end
+
+    it 'returns expected result' do
+      result = test_instance.call(:id => 1)
+
+      expect(result).to eq(Success(
+                             :response => { :status => 200 },
+                             :message => 'it worked'
+                           ))
+    end
+
+    it 'logs expected values' do
+      allow(test_instance).to receive(:log).and_call_original
+
+      test_instance.call(:id => 1)
+
+      expect(test_instance).to have_received(:log)
+        .with('user name', 'John')
+        .ordered
+      expect(test_instance).to have_received(:log)
+        .with('sending request',
+              :input => { :id => 1 },
+              :user => { :type => :admin, :id => 1, :name => 'John' })
+        .ordered
+      expect(test_instance).to have_received(:log)
+        .with('got response', :status => 200)
+        .ordered
+    end
+  end
+
+  def in_sequence(&block)
+    test_instance.instance_eval do
+      in_sequence(&block)
+    end
+  end
+end
+
+def top_level_test_method
+  :empty
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: functional-light-service
 version: !ruby/object:Gem::Version
-  version: 6.0.0
+  version: 6.1.0
 platform: ruby
 authors:
 - Boscolo Michele
@@ -231,6 +231,7 @@ files:
 - lib/functional-light-service/functional/null.rb
 - lib/functional-light-service/functional/option.rb
 - lib/functional-light-service/functional/result.rb
+- lib/functional-light-service/functional/sequencer.rb
 - lib/functional-light-service/localization_adapter.rb
 - lib/functional-light-service/organizer.rb
 - lib/functional-light-service/organizer/execute.rb
@@ -290,6 +291,7 @@ files:
 - spec/lib/deterministic/result/result_shared.rb
 - spec/lib/deterministic/result/success_spec.rb
 - spec/lib/deterministic/result_spec.rb
+- spec/lib/deterministic/sequencer_spec.rb
 - spec/lib/edge_cases_spec.rb
 - spec/lib/enum_spec.rb
 - spec/lib/native_pattern_matching_spec.rb
@@ -332,7 +334,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.3
 specification_version: 4
 summary: A service skeleton with an emphasis on simplicity with a pinch a functional
   programming