hecks 3.4.2 → 3.6.0

data/lib/hecks/runtime/reaction_invocation/target_resolution.rb

@@ -0,0 +1,88 @@
+require_relative "../../naming"
+require_relative "../errors"
+
+module Hecks
+  module Runtime
+    module ReactionInvocation
+      # Finds what a reaction's target verb names (an aggregate command, an entity command or a
+      # port operation) and which receiver the triggering event can lend it. Extended onto
+      # {ReactionInvocation}.
+      module TargetResolution
+        private
+
+        def resolve_target(registry, verb)
+          domain, aggregate_name, command_path = Naming.split_verb(verb)
+          raise UnknownVerb, "reaction target #{verb.inspect} is not a qualified command" unless command_path
+
+          aggregate = registry.bluebook(domain)&.aggregate(aggregate_name)
+          raise UnknownVerb, "reaction target #{verb.inspect} does not resolve to an aggregate" unless aggregate
+
+          *entity_names, command_name = command_path.split(".")
+
+          # A port operation shares the two-segment tail shape an entity command
+          # uses ("Head.Rest"); checked first, matching the order
+          # `Dispatcher#dispatch` already resolves a live verb in.
+          port_target(aggregate, entity_names, command_name, verb) ||
+            entity_target(aggregate, entity_names, command_name, verb)
+        end
+
+        def port_target(aggregate, entity_names, command_name, verb)
+          return unless entity_names.one? && (port = aggregate.port(entity_names.first))
+
+          operation = port.operation(command_name)
+          raise UnknownVerb, "reaction target #{verb.inspect} does not resolve to a declared port operation" unless operation
+
+          Target.new(aggregate: aggregate, entities: [], command: operation)
+        end
+
+        def entity_target(aggregate, entity_names, command_name, verb)
+          entities = entity_chain(aggregate, entity_names, verb)
+          command  = (entities.last || aggregate).command(command_name)
+          raise UnknownVerb, "reaction target #{verb.inspect} does not resolve to a command" unless command
+
+          Target.new(aggregate: aggregate, entities: entities, command: command)
+        end
+
+        # The entities `entity_names` walks down from the aggregate, each owned by the one before.
+        def entity_chain(aggregate, entity_names, verb)
+          owner = aggregate
+          entity_names.map do |entity_name|
+            owner = owner.entities.find { |candidate| candidate.hecks_name == entity_name } ||
+                    raise(UnknownVerb, "reaction target #{verb.inspect} does not resolve entity #{entity_name.inspect}")
+          end
+        end
+
+        def command_facts(command, args)
+          declared = command.attributes.map { |attribute| attribute.name.to_sym }
+          args.slice(*declared)
+        end
+
+        def aggregate_aliases(target)
+          aliases = [:aggregate, Naming.reference_key(target.aggregate.name)]
+          aliases.unshift(target.command.addressing_key_for(target.aggregate.name)) if target.entities.empty?
+          aliases.compact.uniq
+        end
+
+        # An event's own identity can supply the receiver of a non-creating command on
+        # the same aggregate root; it never addresses another aggregate or an entity.
+        def source_receiver_for(target, source_receiver)
+          return nil unless source_receiver
+          # `target.command.creates?` alone misreads every entity command, which always
+          # answers true for `creates?` though it never creates anything (Behaviour::
+          # Command#creates?) — checked as the same compound condition `build` uses below.
+          return nil if target.entities.empty? && target.command.creates?
+
+          source = source_receiver.transform_keys(&:to_sym)
+          return nil unless same_aggregate?(target, source[:aggregate].to_s)
+
+          identity = source[:identity]
+          identity.to_s unless blank_identity?(identity)
+        end
+
+        def same_aggregate?(target, source_aggregate)
+          source_aggregate == (source_aggregate.include?("::") ? target.aggregate.hecks_fqn : target.aggregate.hecks_name)
+        end
+      end
+    end
+  end
+end

data/lib/hecks/runtime/reaction_invocation.rb

@@ -2,6 +2,8 @@ require_relative "../naming"
 require_relative "errors"
 require_relative "identity"
 require_relative "value"
+require_relative "reaction_invocation/target_resolution"
+require_relative "reaction_invocation/identities"
 
 module Hecks
   module Runtime
@@ -42,10 +44,7 @@ module Hecks
       # @raise [Runtime::UnknownArgument] if a Symbol source is visible in no binding or scope
       def resolve_mapping(with_spec:, scopes:, bindings: {}, label: "reaction")
         normalized_bindings = bindings.transform_keys(&:to_sym)
-        normalized_scopes = scopes.map do |scope|
-          scope = Scope.new(name: scope.first, facts: scope.last) unless scope.is_a?(Scope)
-          Scope.new(name: scope.name.to_s, facts: scope.facts.transform_keys(&:to_sym))
-        end
+        normalized_scopes = normalized_scopes(scopes)
 
         with_spec.to_h do |key, source|
           value = resolved_mapping_value(source, normalized_bindings, normalized_scopes, label)
@@ -53,25 +52,35 @@ module Hecks
         end
       end
 
+      def normalized_scopes(scopes)
+        scopes.map do |scope|
+          scope = Scope.new(name: scope.first, facts: scope.last) unless scope.is_a?(Scope)
+          Scope.new(name: scope.name.to_s, facts: scope.facts.transform_keys(&:to_sym))
+        end
+      end
+      private_class_method :normalized_scopes
+
       def resolved_mapping_value(source, bindings, scopes, label)
         return source unless source.is_a?(Symbol)
         return bindings.fetch(source) if bindings.key?(source)
 
         visible = scopes.find { |scope| scope.facts.key?(source) }
-        unless visible
-          names = scopes.map(&:name).join(" then ")
-          # Names every visible option so a caller isn't left guessing at fields.
-          offered = scopes.map { |scope| "#{scope.name}: #{scope.facts.keys.sort.join(', ')}" }.join("; ")
-          raise UnknownArgument,
-                "#{label}'s with: reads :#{source}, which is not visible in #{names} (visible — #{offered})"
-        end
+        refuse_invisible!(source, scopes, label) unless visible
         visible.facts.fetch(source)
       end
       private_class_method :resolved_mapping_value
 
-      # A reaction without an explicit `with:` projection forwards its payload
-      # wholesale; an explicit one builds a strict `{to:, with:}` envelope instead.
-      # rubocop:disable-next Metrics/MethodLength, Metrics/PerceivedComplexity
+      def refuse_invisible!(source, scopes, label)
+        names = scopes.map(&:name).join(" then ")
+        # Names every visible option so a caller isn't left guessing at fields.
+        offered = scopes.map { |scope| "#{scope.name}: #{scope.facts.keys.sort.join(", ")}" }.join("; ")
+        raise UnknownArgument,
+              "#{label}'s with: reads :#{source}, which is not visible in #{names} (visible — #{offered})"
+      end
+      private_class_method :refuse_invisible!
+
+      # Forwards the payload wholesale, or builds a strict `{to:, with:}` envelope when explicit.
+      #
       # @param verb [String] the fully qualified target command verb
       # @param projected [Hash] resolved facts, or the raw payload when not `explicit`
       # @param explicit [Boolean] whether the reaction declared its own `with:` projection
@@ -81,30 +90,44 @@ module Hecks
       # @raise [Runtime::UnknownVerb] if `verb` does not resolve (only when `explicit`)
       # @raise [Runtime::TypeMismatch] if no receiver identity resolves for an explicit target
       # @raise [Runtime::UnknownArgument] if an explicit projection has an undeclared fact
+      # rubocop:disable-next Metrics/ParameterLists -- the keyword door both interpreters call
       def build(registry:, verb:, projected:, explicit:, passthrough: [], source_receiver: nil)
         args = projected.transform_keys(&:to_sym)
-        unless explicit
-          return args unless source_receiver
+        return forwarded(registry, verb, args, source_receiver) unless explicit
 
-          # Compatibility calls still belong to Dispatcher when the target is
-          # absent: it owns the canonical UnknownVerb wording. Resolution here
-          # is only an optional opportunity to lift same-aggregate Event.id.
-          begin
-            target = resolve_target(registry, verb)
-          rescue UnknownVerb
-            return args
-          end
-          # An entity target's receiver needs `{aggregate:, entities:}`, but nothing
-          # here can invent the entity's own identity — so no receiver is lifted here;
-          # the payload forwards wholesale, same as with no `source_receiver` at all.
-          return args unless target.entities.empty?
+        explicit_envelope(registry, verb, args, passthrough, source_receiver)
+      end
 
-          inherited_receiver = source_receiver_for(target, source_receiver)
-          return inherited_receiver ? args.merge(to: inherited_receiver) : args
-        end
+      # A compatibility call: the payload forwards wholesale, with the triggering event's own
+      # identity lent as the receiver when the target can take it.
+      def forwarded(registry, verb, args, source_receiver)
+        return args unless source_receiver
+
+        # Compatibility calls still belong to Dispatcher when the target is
+        # absent: it owns the canonical UnknownVerb wording. Resolution here
+        # is only an optional opportunity to lift same-aggregate Event.id.
+        target = optional_target(registry, verb)
+        # An entity target's receiver needs `{aggregate:, entities:}`, but nothing
+        # here can invent the entity's own identity — so no receiver is lifted here;
+        # the payload forwards wholesale, same as with no `source_receiver` at all.
+        return args unless target&.entities&.empty?
 
-        target = resolve_target(registry, verb)
         inherited_receiver = source_receiver_for(target, source_receiver)
+        inherited_receiver ? args.merge(to: inherited_receiver) : args
+      end
+      private_class_method :forwarded
+
+      def optional_target(registry, verb)
+        resolve_target(registry, verb)
+      rescue UnknownVerb
+        nil
+      end
+      private_class_method :optional_target
+
+      # The strict `{to:, with:}` envelope: the declared facts, and the receiver the target's
+      # identity resolves to.
+      def explicit_envelope(registry, verb, args, passthrough, source_receiver)
+        target = resolve_target(registry, verb)
         facts = command_facts(target.command, args)
         consumed = facts.keys
 
@@ -113,164 +136,24 @@ module Hecks
           return { with: facts }
         end
 
-        aggregate_identity, aggregate_keys = identity_for(
-          target.aggregate,
-          args,
-          aliases:     aggregate_aliases(target),
-          value_owner: target.aggregate
-        )
-        aggregate_identity ||= inherited_receiver
-        require_identity!(verb, target.aggregate, aggregate_identity)
-        consumed.concat(aggregate_keys)
-
-        entity_identities = target.entities.map do |entity|
-          identity, keys = identity_for(
-            entity,
-            args,
-            aliases:     [Naming.reference_key(entity.hecks_name)],
-            value_owner: target.aggregate
-          )
-          require_identity!(verb, entity, identity)
-          consumed.concat(keys)
-          identity
-        end
-
+        route = receiver_route(verb, target, args, source_receiver_for(target, source_receiver), consumed)
         refuse_unconsumed!(target.command, args, consumed, passthrough)
-
-        route = if entity_identities.empty?
-                  aggregate_identity
-                else
-                  { aggregate: aggregate_identity, entities: entity_identities }
-                end
         { to: route, with: facts }
       end
+      private_class_method :explicit_envelope
 
-      def resolve_target(registry, verb)
-        domain, aggregate_name, command_path = Naming.split_verb(verb)
-        raise UnknownVerb, "reaction target #{verb.inspect} is not a qualified command" unless command_path
-
-        bluebook = registry.bluebook(domain)
-        aggregate = bluebook&.aggregate(aggregate_name)
-        raise UnknownVerb, "reaction target #{verb.inspect} does not resolve to an aggregate" unless aggregate
-
-        *entity_names, command_name = command_path.split(".")
-
-        # A port operation shares the two-segment tail shape an entity command
-        # uses ("Head.Rest"); checked first, matching the order
-        # `Dispatcher#dispatch` already resolves a live verb in.
-        if entity_names.one? && (port = aggregate.port(entity_names.first))
-          operation = port.operation(command_name)
-          raise UnknownVerb, "reaction target #{verb.inspect} does not resolve to a declared port operation" unless operation
-
-          return Target.new(aggregate: aggregate, entities: [], command: operation)
-        end
+      # The aggregate's identity, or the aggregate's and each entity's when the target is one.
+      def receiver_route(verb, target, args, inherited_receiver, consumed)
+        aggregate_identity = aggregate_identity_for(verb, target, args, inherited_receiver, consumed)
+        entity_identities = target.entities.map { |entity| entity_identity(verb, entity, target, args, consumed) }
+        return aggregate_identity if entity_identities.empty?
 
-        owner = aggregate
-        entities = entity_names.map do |entity_name|
-          entity = owner.entities.find { |candidate| candidate.hecks_name == entity_name }
-          raise UnknownVerb, "reaction target #{verb.inspect} does not resolve entity #{entity_name.inspect}" unless entity
-
-          owner = entity
-          entity
-        end
-        command = owner.command(command_name)
-        raise UnknownVerb, "reaction target #{verb.inspect} does not resolve to a command" unless command
-
-        Target.new(aggregate: aggregate, entities: entities, command: command)
-      end
-      private_class_method :resolve_target
-
-      def command_facts(command, args)
-        declared = command.attributes.map { |attribute| attribute.name.to_sym }
-        args.slice(*declared)
-      end
-      private_class_method :command_facts
-
-      def aggregate_aliases(target)
-        aliases = [:aggregate, Naming.reference_key(target.aggregate.name)]
-        aliases.unshift(target.command.addressing_key_for(target.aggregate.name)) if target.entities.empty?
-        aliases.compact.uniq
-      end
-      private_class_method :aggregate_aliases
-
-      # An event's own identity can supply the receiver of a non-creating command on
-      # the same aggregate root; it never addresses another aggregate or an entity.
-      def source_receiver_for(target, source_receiver)
-        return nil unless source_receiver
-        # `target.command.creates?` alone misreads every entity command, which always
-        # answers true for `creates?` though it never creates anything (Behaviour::
-        # Command#creates?) — checked as the same compound condition `build` uses below.
-        return nil if target.entities.empty? && target.command.creates?
-
-        source = source_receiver.transform_keys(&:to_sym)
-        source_aggregate = source[:aggregate].to_s
-        same_aggregate = source_aggregate == if source_aggregate.include?("::")
-                                               target.aggregate.hecks_fqn
-                                             else
-                                               target.aggregate.hecks_name
-                                             end
-        return nil unless same_aggregate
-
-        identity = source[:identity]
-        identity.to_s unless identity.nil? || identity.to_s.empty?
-      end
-      private_class_method :source_receiver_for
-
-      def identity_for(construct, args, aliases:, value_owner:)
-        identity = Identity.of(construct, args, value_owner: value_owner)
-        return [identity, construct.identity_heads] if identity
-
-        aliases.each do |key|
-          key = key.to_sym
-          next unless args.key?(key)
-
-          identity = identity_from_alias(construct, args[key], value_owner)
-          return [identity, [key]] if identity
-        end
-
-        return [args[:id].to_s, [:id]] if args.key?(:id) && !args[:id].to_s.empty?
-
-        [nil, []]
+        { aggregate: aggregate_identity, entities: entity_identities }
       end
-      private_class_method :identity_for
-
-      def identity_from_alias(construct, held, value_owner)
-        materialized = Value.materialize(held)
-        if materialized.is_a?(Hash)
-          keyed = materialized.transform_keys(&:to_sym)
-          nested = Identity.of(construct, keyed, value_owner: value_owner)
-          return nested if nested
+      private_class_method :receiver_route
 
-          if construct.identity_paths.one?
-            scalar = Identity.scalar(construct.identity_paths.first, keyed)
-            return scalar.to_s unless scalar.nil? || scalar.to_s.empty?
-          end
-
-          return nil
-        end
-
-        materialized.to_s unless materialized.nil? || materialized.to_s.empty?
-      end
-      private_class_method :identity_from_alias
-
-      def require_identity!(verb, construct, identity)
-        return if identity
-
-        raise TypeMismatch,
-              "reaction target #{verb} needs #{construct.hecks_name}'s receiver identity outside command facts"
-      end
-      private_class_method :require_identity!
-
-      def refuse_unconsumed!(command, args, consumed, passthrough)
-        allowed = consumed.map(&:to_sym) + Array(passthrough).map(&:to_sym)
-        unknown = args.keys - allowed
-        return if unknown.empty?
-
-        raise UnknownArgument,
-              "#{command.hecks_name} reaction projection contains neither receiver identity nor declared command facts: " \
-              "#{unknown.sort.join(', ')}"
-      end
-      private_class_method :refuse_unconsumed!
+      extend TargetResolution
+      extend Identities
     end
   end
 end

data/lib/hecks/runtime/reaction_outcome.rb

@@ -33,12 +33,16 @@ module Hecks
       # @return [Array<Hash{Symbol => Object}>] `{ policy:, trigger:, reason: }` per blocker
       def blocking(entries, event_of: nil)
         rows = Array(entries).map { |entry| Row.new(entry.transform_keys(&:to_sym), event_of&.call(entry)) }
-        rows.select { |row| row.delivered == false && !row.fields[:defect] }
-            .reject { |row| already_there?(row) }
-            .reject { |row| rows.any? { |other| alternative?(row, other) } }
+        rows.select { |row| blocks?(row, rows) }
             .map { |row| row.fields.slice(:policy, :trigger, :reason) }
       end
 
+      # Whether `row` is a refusal by the domain that no sibling reaction excuses.
+      def blocks?(row, rows)
+        row.delivered == false && !row.fields[:defect] &&
+          !already_there?(row) && rows.none? { |other| alternative?(row, other) }
+      end
+
       # Whether `row` is its own creating command reporting the record already exists.
       def already_there?(row)
         RefusalWording.already_exists?(row.fields[:reason], **creating(row.fields[:trigger]))

data/lib/hecks/runtime/read_model_interpreter/head_ordering.rb

@@ -0,0 +1,49 @@
+module Hecks
+  module Runtime
+    class ReadModelInterpreter
+      # The order a read model's non-root heads are read in: by the references they hold toward
+      # each other. Mixed into {ReadModelInterpreter}.
+      module HeadOrdering
+        private
+
+        # Topologically sorts non-root heads by their declared reference fields
+        # (Kahn's algorithm); a cycle falls back to declared order rather than looping.
+        def order_other_heads(bluebook, root_heads, other_heads)
+          resolved = root_heads.map { |head| head[:aggregate] }
+          remaining = other_heads.dup
+          ordered = []
+          until remaining.empty?
+            ready, remaining = remaining.partition { |head| ready_head?(bluebook, head, other_heads, resolved) }
+            return ordered.concat(remaining) if ready.empty?
+
+            ordered.concat(ready)
+            resolved.concat(ready.map { |head| head[:aggregate] })
+          end
+          ordered
+        end
+
+        # Whether every head `head` depends on has already been read.
+        def ready_head?(bluebook, head, other_heads, resolved)
+          depends_on(bluebook, head, other_heads).all? { |target| resolved.include?(target) }
+        end
+
+        # Which other declared heads a head's own aggregate holds a reference field
+        # toward; an entity-headed include resolves no aggregate and so depends on nothing.
+        def depends_on(bluebook, head, other_heads)
+          aggregate = bluebook.aggregate(head[:aggregate])
+          return [] unless aggregate
+
+          other_heads.reject { |other| other[:aggregate] == head[:aggregate] }
+                     .select { |other| reference_fields(aggregate, other[:aggregate]).any? }
+                     .map { |other| other[:aggregate] }
+        end
+
+        def reference_fields(aggregate, target)
+          aggregate.attributes
+                   .select { |attribute| attribute.reference? && attribute.type.target_name == target.to_s }
+                   .map(&:name)
+        end
+      end
+    end
+  end
+end

data/lib/hecks/runtime/read_model_interpreter/reductions.rb

@@ -0,0 +1,123 @@
+require_relative "../../ports/query/in_memory"
+require_relative "../../query_specification/field_path"
+
+module Hecks
+  module Runtime
+    class ReadModelInterpreter
+      # The reductions a read model can declare (`count`, `sum`, `avg`, `min`, `max`, `any`,
+      # `all`, `median`, `percentile`): validated against the head's attributes, then applied to
+      # the head's rows. Mixed into {ReadModelInterpreter}.
+      module Reductions
+        # The reduction a model declares, with its declared field, for a refusal message.
+        Reduction = Struct.new(:model, :ivar, :word, :field)
+
+        # The order `reduce` looks for a declared reduction; `median` is what remains.
+        REDUCE_ORDER = %i[any_field all_field sum_field avg_field min_field max_field percentile_field].freeze
+
+        private
+
+        # Resolves a reduction's single many-side head, raising on a field that doesn't
+        # exist or has the wrong type rather than comparing garbage.
+        def aggregation_target(model, bluebook)
+          return nil unless model.reducing?
+
+          target = model.aggregate_heads.find { |head| head[:many] }
+          return target if model.count?
+
+          validate_reduction!(model, bluebook, target)
+          target
+        end
+
+        def validate_reduction!(model, bluebook, target)
+          ivar, word = REDUCTION_WORD.find { |name, _| model.public_send(name) }
+          field = model.public_send(ivar)
+          aggregate = bluebook.aggregate(target[:aggregate])
+          attribute = aggregate.attribute(field)
+          raise ArgumentError, undeclared_reduction_field(model, word, field, target, aggregate) unless attribute
+
+          validate_reduction_type!(Reduction.new(model, ivar, word, field), target[:aggregate], aggregate, attribute)
+        end
+
+        def undeclared_reduction_field(model, word, field, target, aggregate)
+          "#{model.name}'s #{word} names #{field.inspect}, but #{target[:aggregate]} " \
+            "declares no such attribute (it declares #{aggregate.attributes.map(&:name).join(", ")})"
+        end
+
+        # @raise [ArgumentError] if `attribute` does not have the type the reduction needs
+        def validate_reduction_type!(reduction, aggregate_name, aggregate, attribute)
+          return if reduction_type_ok?(reduction.ivar, aggregate, attribute)
+
+          kind = BOOLEAN_REDUCTIONS.include?(reduction.ivar) ? "boolean" : "numeric"
+          raise ArgumentError,
+                "#{reduction.model.name}'s #{reduction.word} names #{reduction.field.inspect} on #{aggregate_name}, " \
+                "which is not #{kind} — #{reduction.word} needs a #{kind == "boolean" ? "true/false" : "numeric"} field"
+        end
+
+        def reduction_type_ok?(ivar, aggregate, attribute)
+          wrap = ->(type) { aggregate.value_object(type) }
+          if BOOLEAN_REDUCTIONS.include?(ivar)
+            QuerySpecification::FieldPath.boolean?(attribute, [], &wrap)
+          elsif INTEGER_ONLY_REDUCTIONS.include?(ivar)
+            QuerySpecification::FieldPath.integer?(attribute, [], &wrap)
+          else
+            QuerySpecification::FieldPath.numeric?(attribute, [], &wrap)
+          end
+        end
+
+        # Dispatches to the one reduction `model` declares, over the eligible collection's own
+        # `comparable`-mapped values (or raw booleans for `any`/`all`) — the interpretation of
+        # `Runtime::ReadModelInterpreter#project`'s `reduced_head` branch.
+        def reduce(model, rows)
+          name = REDUCE_ORDER.find { |candidate| model.public_send(candidate) }
+          return percentile(numeric_values(rows, model.median_field), 0.5) unless name
+
+          apply_reduction(name, model, rows)
+        end
+
+        def apply_reduction(name, model, rows)
+          field = model.public_send(name)
+          case name
+          when :any_field then boolean_values(rows, field).any?
+          when :all_field then boolean_values(rows, field).all?
+          else numeric_reduction(name, model, numeric_values(rows, field))
+          end
+        end
+
+        def numeric_reduction(name, model, values)
+          case name
+          when :sum_field then values.sum
+          when :avg_field then average(values)
+          when :min_field then values.min
+          when :max_field then values.max
+          else percentile(values, model.percentile_at)
+          end
+        end
+
+        # Shared by every reduction: `comparable` unwraps a value-object-wrapped field down to
+        # its sole member (numeric or boolean alike) exactly as `where`/`order_by` already read
+        # it, so `flagged: { value: true }` reduces on the boolean, not the ever-truthy Hash.
+        def reduction_values(rows, field)
+          # `compact`, not `filter_map`: a stored `false` is a real value, not an absent one.
+          rows.map { |record| Ports::Query::InMemory.comparable(QuerySpecification::FieldPath.dig(row(record), field)) }.compact
+        end
+        alias numeric_values reduction_values
+        alias boolean_values reduction_values
+
+        # `nil` on no rows: a rate of nothing is undefined, not zero.
+        def average(values) = values.empty? ? nil : values.sum.to_f / values.length
+
+        # The value at one interpolated rank (`0.0`..`1.0`); `at: 0.5` is the standard median
+        # (middle value when odd, average of the two middle values when even). `nil` on no rows.
+        def percentile(values, at)
+          return nil if values.empty?
+
+          sorted = values.sort
+          position = at * (sorted.length - 1)
+          lower = position.floor
+          fraction = position - lower
+          fraction.zero? ? sorted[lower] : sorted[lower] + (fraction * (sorted[lower + 1] - sorted[lower]))
+        end
+      end
+    end
+  end
+end