remap 2.2.46 → 2.2.50

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 71b1a0f8a9cb714d568939ace38b13d053e4c1ddf9131a6040630ff4a1479e4a
-  data.tar.gz: fe768a12f868c085839145d28a609a707c4aacb10a18c16e2276e51b23de0fb5
+  metadata.gz: a036948beb3769bca586002c771569e54639a3a60314bac615a8f2dbb25a546b
+  data.tar.gz: 966315eb1929aa681d95d477e72a4545bdc435a4a4e3583d1cec875e8061d479
 SHA512:
-  metadata.gz: 2f5f657a29f997cf1161eda204a2ddd38f1c6dcc991c8467732d367bc31302c7bafd1e05f5a7655cc5ef46dea5498b9caec6fb9d75d2bd1e9aa5c7f34f7a8ec9
-  data.tar.gz: 9263defd99a669a7bcee25381df7a74698cb2ab691b5a2cf22e7cfdb83a8898956b1a17e329e7560e920ad762093822b85c40587dd6bdcf77ab2433188857474
+  metadata.gz: f9afa516dd3d8248b714744598c847d04525f1d2d0e0f320128c6b785281b0a40e93d1b444cca6b4d1b6199bdb85dffa5fe4cda1c1d9ef97ec58f348a4994271
+  data.tar.gz: 72c2bfaaecc2553b3097f5b464cb03772314dab2127b5154d64b6e99e7e0c028ccba987c94acda788c7fa9229f48a626c895d558a6a974d8cbf95ae16b2d7ea5

data/lib/remap/base.rb

@@ -34,33 +34,33 @@ module Remap
   #   Mapper.call({}) # => { api_key: "ABC-123" }
   #
   # @example Maps ["A", "B", "C"] to ["A", "C"]
-  #   class Mapper < Remap::Base
+  #   class IfNotMapper < Remap::Base
   #     define do
   #       each do
-  #         map?.if_not do
+  #         map?.if_not do |value|
   #           value.include?("B")
   #         end
   #       end
   #     end
   #   end
   #
-  #   Mapper.call(["A", "B", "C"]) # => ["A", "C"]
+  #   IfNotMapper.call(["A", "B", "C"]) # => ["A", "C"]
   #
   # @example Maps ["A", "B", "C"] to ["B"]
-  #   class Mapper < Remap::Base
+  #   class IfMapper < Remap::Base
   #     define do
   #       each do
-  #         map?.if do
+  #         map?.if do |value|
   #           value.include?("B")
   #         end
   #       end
   #     end
   #   end
   #
-  #   Mapper.call(["A", "B", "C"]) # => ["B"]
+  #   IfMapper.call(["A", "B", "C"]) # => ["B"]
   #
   # @example Maps { a: { b: "A" } } to "A"
-  #   class Mapper < Remap::Base
+  #   class EnumMapper < Remap::Base
   #     define do
   #       map(:a, :b).enum do
   #         value "A", "B"
@@ -68,11 +68,11 @@ module Remap
   #     end
   #   end
   #
-  #   Mapper.call({ a: { b: "A" } }) # => "A"
-  #   Mapper.call({ a: { b: "B" } }) # => "B"
+  #   EnumMapper.call({ a: { b: "A" } }) # => "A"
+  #   EnumMapper.call({ a: { b: "B" } }) # => "B"
   #
   # @example Map { people: [{ name: "John" }] } to { names: ["John"] }
-  #   class Mapper < Remap::Base
+  #   class PeopleMapper < Remap::Base
   #     define do
   #       map :people, to: :names do
   #         each do
@@ -82,12 +82,12 @@ module Remap
   #     end
   #   end
   #
-  #   Mapper.call({ people: [{ name: "John" }] }) # => { names: ["John"] }
+  #   PeopleMapper.call({ people: [{ name: "John" }] }) # => { names: ["John"] }
   #
   # @example Map "Hello" to "Hello!"
   #   class HelloMapper < Remap::Base
   #     define do
-  #       map.adjust do
+  #       map.adjust do |value|
   #         "#{value}!"
   #       end
   #     end
@@ -105,6 +105,7 @@ module Remap
   #   Mapper.call([1, 2, 3]) # => 2
   class Base < Mapper
     include ActiveSupport::Configurable
+    include Dry::Core::Memoizable
     include Dry::Core::Constants
     include Catchable
     extend Mapper::API
@@ -239,7 +240,7 @@ module Remap
     # @return [void]
     # rubocop:disable Layout/LineLength
     def self.define(target = Nothing, method: :new, strategy: :argument, backtrace: caller, &context)
-      unless block_given?
+      unless context
         raise ArgumentError, "#{self}.define requires a block"
       end
 
@@ -318,5 +319,7 @@ module Remap
     def validation
       Contract.call(attributes: attributes, contract: contract, options: options, rules: rules)
     end
+
+    memoize :validation
   end
 end

data/lib/remap/compiler.rb

@@ -32,7 +32,7 @@ module Remap
     #
     # @return [Rule]
     def self.call(backtrace: caller, &block)
-      unless block_given?
+      unless block
         return Rule::VOID
       end
 
@@ -317,7 +317,7 @@ module Remap
     # @return [Rule::Each]]
     # @raise [ArgumentError] if no block given
     def each(backtrace: caller, &block)
-      unless block_given?
+      unless block
         raise ArgumentError, "#each requires a block"
       end
 
@@ -350,7 +350,7 @@ module Remap
     # @return [Rule::Wrap]
     # @raise [ArgumentError] if type is not :array
     def wrap(type, backtrace: caller, &block)
-      unless block_given?
+      unless block
         raise ArgumentError, "#wrap requires a block"
       end
 

data/lib/remap/extensions/enumerable.rb

@@ -33,15 +33,13 @@ module Remap
 
           key = path.first
 
-          unless block_given?
+          unless fallback
             return get(*path, trace: trace) do
-              raise PathError, trace + [key]
+              throw :ignore, trace + [key]
             end
           end
 
           fetch(key, &fallback).get(*path[1..], trace: trace + [key], &fallback)
-        rescue TypeError
-          raise PathError, trace + [key]
         end
       end
     end

data/lib/remap/extensions/object.rb

@@ -38,9 +38,9 @@ module Remap
         def get(*path, trace: [], &fallback)
           return self if path.empty?
 
-          unless block_given?
+          unless fallback
             return get(*path, trace: trace) do
-              raise PathError, trace
+              throw :ignore, trace + path
             end
           end
 

data/lib/remap/failure.rb

@@ -17,7 +17,7 @@ module Remap
         ]
       end
 
-      failure = attributes.deep_merge(other.attributes) do |key, value1, value2|
+      failure = attributes.merge(other.attributes) do |key, value1, value2|
         case [key, value1, value2]
         in [:failures | :notices, Array, Array]
           value1 + value2

data/lib/remap/mapper/support/api.rb

@@ -22,7 +22,7 @@ module Remap
       #
       # @return [Any, T]
       def call(input, backtrace: caller, **options, &error)
-        unless block_given?
+        unless error
           return call(input, **options) do |failure|
             raise failure.exception(backtrace)
           end

data/lib/remap/path/input.rb

@@ -25,7 +25,7 @@ module Remap
       #
       # @return [State]
       def call(state, &iterator)
-        unless block_given?
+        unless iterator
           raise ArgumentError, "Input path requires an iterator block"
         end
 

data/lib/remap/rule/block.rb

@@ -26,8 +26,11 @@ module Remap
           s2 = state.set(fatal_id: fatal_id)
 
           catch_ignored(s1) do |s3, id:|
-            rules.reduce(s3) do |s4, rule|
-              s5 = rule.call(s2)
+            states = rules.map do |rule|
+              rule.call(s2)
+            end
+
+            states.reduce(s3) do |s4, s5|
               s6 = s5.set(id: id)
               s4.combine(s6)
             end

data/lib/remap/rule/map/enum.rb

@@ -4,13 +4,9 @@ module Remap
   class Rule
     class Map
       class Enum < Proxy
-        include Dry::Monads[:maybe]
-
         # @return [Hash]
-        option :mappings, default: -> { Hash.new { default } }
-
-        # @return [Maybe]
-        option :default, default: -> { None() }
+        option :table, default: -> { {} }
+        option :default, default: -> { Undefined }
 
         alias execute instance_eval
 
@@ -37,7 +33,7 @@ module Remap
           new.tap { _1.execute(&block) }
         end
 
-        # Translates key into a value using predefined mappings
+        # Translates key into a value using predefined table
         #
         # @param key [#hash]
         #
@@ -50,24 +46,21 @@ module Remap
             return get(key) { raise Error, _1 }
           end
 
-          self[key].bind { return _1 }.or do
-            error["Enum key [#{key}] not found among [#{mappings.keys.inspect}]"]
+          table.fetch(key) do
+            unless default == Undefined
+              return default
+            end
+
+            error["Enum key [#{key}] not found among [#{table.keys.inspect}]"]
           end
         end
         alias call get
 
-        # @return [Maybe]
-        def [](key)
-          mappings[key]
-        end
-
         # @return [void]
         def from(*keys, to:)
-          value = Some(to)
-
           keys.each do |key|
-            mappings[key] = value
-            mappings[to] = value
+            table[key] = to
+            table[to] = to
           end
         end
 
@@ -80,7 +73,7 @@ module Remap
 
         # @return [void]
         def otherwise(value)
-          mappings.default = Some(value)
+          @default = value
         end
       end
     end

data/lib/remap/rule/map/required.rb

@@ -16,7 +16,7 @@ module Remap
             end
 
             s3 = s2.then(&path.output)
-            s4 = s3.set(path: state.path)
+            s4 = s3.merge(path: state.path)
 
             s4.except(:key)
           end

data/lib/remap/rule/map.rb

@@ -117,7 +117,7 @@ module Remap
       # Keeps map, only if block is true
       #
       # @example Keep if value contains "A"
-      #   map = Remap::Rule::Map::Optional.call(backtrace: caller).if do
+      #   map = Remap::Rule::Map::Optional.call(backtrace: caller).if do |value|
       #     value.include?("A")
       #   end
       #
@@ -145,7 +145,7 @@ module Remap
       #
 
       # @example Keep unless value contains "A"
-      #   map = Remap::Rule::Map::Optional.new(backtrace: caller).if_not do
+      #   map = Remap::Rule::Map::Optional.new(backtrace: caller).if_not do |value|
       #     value.include?("A")
       #   end
       #

data/lib/remap/selector/all.rb

@@ -15,28 +15,28 @@ module Remap
     #   end
     #   result.fetch(:value) # => [Hash, Hash]
     class All < Concrete
-      requirement Types::Enumerable
-
       # Iterates over state and passes each value to block
       #
-      # @param outer_state [State<Enumerable<T>>]
+      # @param state [State<Enumerable<T>>]
       #
       # @yieldparam [State<T>]
       # @yieldreturn [State<U>]
       #
       # @return [State<U>]
-      def call(outer_state, &block)
-        unless block_given?
+      def call(state, &block)
+        unless block
           raise ArgumentError, "All selector requires an iteration block"
         end
 
-        outer_state.bind(quantifier: "*") do |enum, state|
-          requirement[enum] do
-            state.fatal!("Expected enumerable")
-          end
+        value = state.fetch(:value) do
+          return state
+        end
 
-          state.map(&block)
+        unless value.is_a?(Enumerable)
+          state.fatal!("Not an enumerator")
         end
+
+        state.map(&block)
       end
     end
   end

data/lib/remap/selector/index.rb

@@ -20,8 +20,6 @@ module Remap
       # @return [Integer]
       attribute :index, Integer
 
-      requirement Types::Array
-
       # Selects the {#index}th element from state and passes it to block
       #
       # @param state [State<Array<T>>]
@@ -31,21 +29,21 @@ module Remap
       #
       # @return [State<U>]
       def call(state, &block)
-        unless block_given?
+        unless block
           raise ArgumentError, "The index selector requires an iteration block"
         end
 
-        state.bind(index: index) do |array, s|
-          requirement[array] do
-            s.fatal!("Expected an array")
-          end
+        array = state.fetch(:value) { return state }
 
-          element = array.fetch(index) do
-            s.ignore!("Index not found")
-          end
+        unless array.is_a?(Array)
+          state.fatal!("Expected an array got %s", array.class)
+        end
 
-          state.set(element, index: index).then(&block)
+        value = array.fetch(index) do
+          state.ignore!("Index [%s] (%s) not found", index, index.class)
         end
+
+        state.set(value, index: index).then(&block)
       end
     end
   end

data/lib/remap/selector/key.rb

@@ -17,8 +17,6 @@ module Remap
       # @return [#hash
       attribute :key, Types::Key
 
-      requirement Types::Hash
-
       # Selects {#key} from state and passes it to block
       #
       # @param state [State<Hash<K, V>>]
@@ -28,21 +26,21 @@ module Remap
       #
       # @return [State<U>]
       def call(state, &block)
-        unless block_given?
+        unless block
           raise ArgumentError, "The key selector requires an iteration block"
         end
 
-        state.bind(key: key) do |hash, s|
-          requirement[hash] do
-            s.fatal!("Expected hash")
-          end
+        hash = state.fetch(:value) { return state }
 
-          value = hash.fetch(key) do
-            s.ignore!("Key not found")
-          end
+        unless hash.is_a?(Hash)
+          state.fatal!("Expected hash got %s", hash.class)
+        end
 
-          state.set(value, key: key).then(&block)
+        value = hash.fetch(key) do
+          state.ignore!("Key [%s] (%s) not found", key, key.class)
         end
+
+        state.set(value, key: key).then(&block)
       end
     end
   end

data/lib/remap/selector.rb

@@ -4,9 +4,6 @@ module Remap
   # Defines how a path element, or selector
   # Specifies how a value is extracted from a state
   class Selector < Dry::Interface
-    defines :requirement, type: Types::Any.constrained(type: Dry::Types::Type)
-    requirement Types::Any
-
     # Selects value from state, package it as a state and passes it to block
     #
     # @param state [State]
@@ -20,12 +17,5 @@ module Remap
     def call(state)
       raise NotImplementedError, "#{self.class}#call not implemented"
     end
-
-    private
-
-    # @return [Dry::Types::Type]
-    def requirement
-      self.class.requirement
-    end
   end
 end

data/lib/remap/state/extension.rb

@@ -46,11 +46,7 @@ module Remap
         # @returns [Hash] a hash containing the given path
         # @raise Europace::Error when path doesn't exist
         def only(*path)
-          path.reduce(EMPTY_HASH) do |hash, key|
-            next hash unless key?(key)
-
-            hash.deep_merge(key => fetch(key))
-          end
+          dup.extract!(*path)
         end
 
         # @see #notice
@@ -112,11 +108,30 @@ module Remap
         #
         # @return [State]
         def map(&block)
-          bind do |value, state|
-            Iteration.call(state: state, value: value).call do |other, **options|
-              state.set(other, **options).then(&block)
-            end.except(:index, :element, :key)
+          result = case self
+          in { value: Array => array }
+            array.each_with_index.each_with_object([]) do |(value, index), array|
+              s1 = block[set(value, index: index)]
+
+              if s1.key?(:value)
+                array << s1[:value]
+              end
+            end
+          in { value: Hash => hash }
+            hash.each_with_object({}) do |(key, value), acc|
+              s1 = block[set(value, key: key)]
+
+              if s1.key?(:value)
+                acc[key] = s1[:value]
+              end
+            end
+          in { value: }
+            fatal!("Expected an enumerable got %s", value.class)
+          else
+            return self
           end
+
+          set(result)
         end
 
         # @return [String]
@@ -130,10 +145,14 @@ module Remap
         #
         # @return [State]
         def combine(other)
-          deep_merge(other) do |key, value1, value2|
+          merge(other) do |key, value1, value2|
             case [key, value1, value2]
-            in [:value, Array => list1, Array => list2]
-              list1 + list2
+            in [_, Hash => left, Hash => right]
+              left.merge(right)
+            in [:ids | :fatal_ids, _, right]
+              right
+            in [_, Array => left, Array => right]
+              left + right
             in [:value, left, right]
               other.fatal!(
                 "Could not merge [%s] (%s) with [%s] (%s)",
@@ -142,15 +161,6 @@ module Remap
                 right.formatted,
                 right.class
               )
-            in [:notices, Array => n1, Array => n2]
-              n1 + n2
-            in [:ids, i1, i2] if i1.all? { i2.include?(_1) }
-              i2
-            in [:ids, i1, i2] if i2.all? { i1.include?(_1) }
-              i1
-            in [:ids, i1, i2]
-              other.fatal!("Could not merge #ids [%s] (%s) with [%s] (%s)", i1, i1.class, i2,
-                           i2.class)
             in [Symbol, _, value]
               value
             end
@@ -160,31 +170,39 @@ module Remap
         # @todo Merge with {#remove_fatal_id}
         # @return [State]
         def remove_id
-          case self
+          state = dup
+
+          case state
           in { ids: [], id: }
-            except(:id)
+            state.except!(:id)
           in { ids:, id: }
-            merge(ids: ids[1...], id: ids[0])
+            state.merge!(ids: ids[1...], id: ids[0])
           in { ids: [] }
-            self
+            state
           in { ids: }
             raise ArgumentError, "[BUG] #ids for state are set, but not #id: %s" % formatted
-          end._
+          end
+
+          state
         end
 
         # @todo Merge with {#remove_id}
         # @return [State]
         def remove_fatal_id
-          case self
+          state = dup
+
+          case state
           in { fatal_ids: [], fatal_id: }
-            except(:fatal_id)
-          in { fatal_ids: ids, fatal_id: id }
-            merge(fatal_ids: ids[1...], fatal_id: ids[0])
+            state.except!(:fatal_id)
+          in { fatal_ids: ids, fatal_id: }
+            state.merge!(fatal_ids: ids[1...], fatal_id: ids[0])
           in { fatal_ids: [] }
-            self
+            state
           in { fatal_ids: }
             raise ArgumentError, "[BUG] #ids for state are set, but not #id: %s" % formatted
-          end._
+          end
+
+          state
         end
 
         # Creates a new state with params
@@ -198,24 +216,32 @@ module Remap
             return set(**options, value: value)
           end
 
-          case [self, options]
-          in [{notices:}, {notice: notice, **rest}]
-            merge(notices: notices + [notice]).set(**rest)
-          in [{value:}, {mapper:, **rest}]
-            merge(scope: value, mapper: mapper).set(**rest)
-          in [{path:}, {key:, **rest}]
-            merge(path: path + [key], key: key).set(**rest)
-          in [{path:}, {index:, value:, **rest}]
-            merge(path: path + [index], element: value, index: index, value: value).set(**rest)
-          in [{path:}, {index:, **rest}]
-            merge(path: path + [index], index: index).set(**rest)
-          in [{ids:, id: old_id}, {id: new_id, **rest}]
-            merge(ids: [old_id] + ids, id: new_id).set(**rest)
-          in [{fatal_ids:, fatal_id: old_id}, {fatal_id: new_id, **rest}]
-            merge(fatal_ids: [old_id] + fatal_ids, fatal_id: new_id).set(**rest)
+          state = dup
+
+          case [state, options]
+          in [{notices:}, {notice: notice}]
+            state.merge!(notices: notices + [notice])
+          in [{value:}, {mapper:}]
+            state.merge!(scope: value, mapper: mapper)
+          in [{path: p1}, {path: p2}]
+            state.merge!(path: p1 + p2)
+          in [{path:}, {key:, value:}]
+            state.merge!(path: path + [key], key: key, value: value)
+          in [{path:}, {key:}]
+            state.merge!(path: path + [key], key: key)
+          in [{path:}, {index:, value:}]
+            state.merge!(path: path + [index], element: value, index: index, value: value)
+          in [{path:}, {index:}]
+            state.merge!(path: path + [index], index: index)
+          in [{ids:, id: old_id}, {id: new_id}]
+            state.merge!(ids: [old_id] + ids, id: new_id)
+          in [{fatal_ids:, fatal_id: old_id}, {fatal_id: new_id}]
+            state.merge!(fatal_ids: [old_id] + fatal_ids, fatal_id: new_id)
           else
-            merge(options)
+            state.merge!(options)
           end
+
+          state
         end
 
         # Passes {#value} to block, if defined
@@ -235,22 +261,6 @@ module Remap
           end
         end
 
-        # Creates a failure to be used in {Remap::Base} & {Remap::Mapper}
-        #
-        # @param reason [#to_s]
-        #
-        # @see State::Schema
-        #
-        # @return [Failure]
-
-        # class Failure < Dry::Interface
-        #   attribute :notices, [Notice], min_size: 1
-        # end
-
-        def failure(reason = Undefined)
-          raise NotImplementedError, "Not implemented"
-        end
-
         # Passes {#value} to block, if defined
         # {options} are combine into the final state
         #
@@ -262,7 +272,7 @@ module Remap
         #
         # @return [Y]
         def bind(**options, &block)
-          unless block_given?
+          unless block
             raise ArgumentError, "State#bind requires a block"
           end
 
@@ -281,21 +291,33 @@ module Remap
         #
         # @return [State<U>]
         def execute(&block)
-          bind do |value|
-            result = context(value).instance_exec(value, &block)
+          value = fetch(:value) { return self }
+
+          path = catch :ignore do
+            names = block.parameters.reduce([]) do |acc, (type, name)|
+              case type
+              in :keyreq
+                acc + [name]
+              else
+                acc
+              end
+            end
+
+            n1 = options.only(*names)
+            n2 = only(*names)
 
-            if result.equal?(Dry::Core::Constants::Undefined)
-              ignore!("Undefined returned, skipping!")
+            result = block[value, **n2, **n1] do |reason|
+              return ignore!(reason)
             end
 
-            set(result)
-          rescue KeyError => e
-            set(path: path + [e.key]).ignore!(e.message)
-          rescue IndexError => e
-            ignore!(e.message)
-          rescue PathError => e
-            set(path: path + e.path).ignore!("Undefined path")
+            return set(result)
           end
+
+          set(path: path).ignore!("Undefined path")
+        rescue KeyError => e
+          set(path: [e.key]).ignore!(e.message)
+        rescue IndexError => e
+          ignore!(e.message)
         end
 
         # Passes {#value} to block and returns {self}
@@ -416,27 +438,6 @@ module Remap
 
           throw id, remove_id
         end
-
-        private
-
-        # Creates a context containing {options} and {self}
-        #
-        # @param value [Any]
-        #
-        # @yieldparam reason [T]
-        #
-        # @return [Struct]
-        def context(value, context: self)
-          ::Struct.new(*except(:id).keys, *options.keys, :state, keyword_init: true) do
-            define_method :method_missing do |name, *|
-              context.fatal!("Method [%s] not defined", name)
-            end
-
-            define_method(:skip!) do |message = "Manual skip!"|
-              context.ignore!(message)
-            end
-          end.new(**to_hash, **options, value: value, state: self)
-        end
       end
     end
   end

data/lib/remap/state.rb

@@ -31,11 +31,11 @@ module Remap
     # @return [Hash] A valid state
     def self.call(value, mapper: Dummy, options: EMPTY_HASH)
       {
-        fatal_ids: EMPTY_ARRAY,
-        notices: EMPTY_ARRAY,
-        path: EMPTY_ARRAY,
+        fatal_ids: [],
+        notices: [],
+        path: [],
         options: options,
-        ids: EMPTY_ARRAY,
+        ids: [],
         mapper: mapper,
         values: value,
         value: value,

data/lib/remap/types.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "dry/monads/maybe"
 require "dry/logic/operations/negation"
 require "dry/logic"
 

data/lib/remap.rb

@@ -5,11 +5,11 @@ require "active_support/core_ext/enumerable"
 require "active_support/core_ext/array/wrap"
 require "active_support/proxy_object"
 
+require "dry/core/memoizable"
 require "dry/validation"
 require "dry/interface"
 require "dry/schema"
 require "dry/struct"
-require "dry/monads"
 require "dry/types"
 
 require "neatjson"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: remap
 version: !ruby/object:Gem::Version
-  version: 2.2.46
+  version: 2.2.50
 platform: ruby
 authors:
 - Linus Oleander
@@ -66,20 +66,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 1.0.3
-- !ruby/object:Gem::Dependency
-  name: dry-monads
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.4.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.4.0
 - !ruby/object:Gem::Dependency
   name: dry-schema
   requirement: !ruby/object:Gem::Requirement
@@ -264,10 +250,6 @@ files:
 - lib/remap/extensions/object.rb
 - lib/remap/failure.rb
 - lib/remap/failure/error.rb
-- lib/remap/iteration.rb
-- lib/remap/iteration/array.rb
-- lib/remap/iteration/hash.rb
-- lib/remap/iteration/other.rb
 - lib/remap/mapper.rb
 - lib/remap/mapper/and.rb
 - lib/remap/mapper/binary.rb

data/lib/remap/iteration/array.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module Remap
-  class Iteration
-    using State::Extension
-
-    # Implements an array iterator which defines index in state
-    class Array < Concrete
-      # @return [Array<T>]
-      attribute :value, Types::Array, alias: :array
-
-      # @return [State<Array<T>>]
-      attribute :state, Types::State
-
-      # @see Iteration#map
-      def call(&block)
-        array.each_with_index.reduce(init) do |state, (value, index)|
-          reduce(state, value, index, &block)
-        end
-      end
-
-      private
-
-      def init
-        state.set(EMPTY_ARRAY)
-      end
-
-      def reduce(state, value, index, &block)
-        s0 = block[value, index: index]
-        s1 = s0.set(**state.only(:ids, :fatal_id))
-        state.combine(s1.fmap { [_1] })
-      end
-    end
-  end
-end

data/lib/remap/iteration/hash.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module Remap
-  class Iteration
-    using State::Extension
-
-    # Implements a hash iterator which defines key in state
-    class Hash < Concrete
-      # @return [Hash]
-      attribute :value, Types::Hash, alias: :hash
-
-      # @return [State<Hash>]
-      attribute :state, Types::State
-
-      # @see Iteration#map
-      def call(&block)
-        hash.reduce(init) do |state, (key, value)|
-          reduce(state, key, value, &block)
-        end
-      end
-
-      private
-
-      def reduce(state, key, value, &block)
-        s0 = block[value, key: key]
-        s1 = s0.set(fatal_id: state.fatal_id, ids: state.ids)
-        state.combine(s1.fmap { { key => _1 } })
-      end
-
-      def init
-        state.set(EMPTY_HASH)
-      end
-    end
-  end
-end

data/lib/remap/iteration/other.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module Remap
-  class Iteration
-    using State::Extension
-
-    # Default iterator which doesn't do anything
-    class Other < Concrete
-      attribute :value, Types::Any, alias: :other
-      attribute :state, Types::State
-
-      # @see Iteration#map
-      def call(&block)
-        state.fatal!("Expected an enumerable")
-      end
-    end
-  end
-end

data/lib/remap/iteration.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module Remap
-  class Iteration < Dry::Interface
-    # @return [State<T>]
-    attribute :state, Types::State
-
-    # @return [T]
-    attribute :value, Types::Any
-
-    # Maps every element in {#value}
-    #
-    # @abstract
-    #
-    # @yieldparam element [V]
-    # @yieldparam key [K, Integer]
-    # @yieldreturn [Array<V>, Hash<V, K>]
-    #
-    # @return [Array<V>, Hash<V, K>]
-    def call(state)
-      raise NotImplementedError, "#{self.class}#call not implemented"
-    end
-
-    order :Hash, :Array, :Other
-  end
-end