plumb 0.0.18 → 0.2.0.beta.2

data/bench/results_allocations.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+# Surfaces the throwaway work Plumb does while parsing — Result objects, error
+# strings and containers that are built and then discarded.
+#
+# The headline metric is INVALID TRANSITIONS: how many times a Result is flipped to
+# invalid during a parse, including SUCCESSFUL ones. A value matching a non-first
+# branch of a union (`A | B`, `Lax::*`, `nullable`, defaults, enums) pays for every
+# branch it fell through, because `Or#call` tries each in turn and each miss runs,
+# builds an error payload, and flips the cursor.
+#
+# This counts flips rather than `Result::Invalid` objects because there is no such
+# class: Valid and Invalid were collapsed into one Result carrying a boolean, which
+# is what lets the built-ins reuse the cursor in place (`#invalid!`) instead of
+# allocating one per miss. That collapse removed the ALLOCATION but not the WORK,
+# and the work is what this bench is about — so the flip is the honest successor to
+# the old object count.
+#
+# The `Result` row is the other half of the picture, and shows the collapse paying
+# off: it stays FLAT across all three regimes (4 per record) while the flips go
+# 0 -> 5 -> 14. Misses cost work, but no longer cost an allocation.
+#
+# Three payload regimes are run over the SAME schema so the difference is purely
+# the data, not the types:
+#   1. first-branch valid  — every union matches its FIRST branch (the floor)
+#   2. union-hit valid      — valid OUTPUT, but unions match LATER branches
+#   3. fully invalid        — every field fails; Invalid propagates + errors aggregate
+#
+#   ruby bench/results_allocations.rb          # N=2000 records per regime
+#   N=20000 ruby bench/results_allocations.rb  # scale the sample
+
+require 'bundler'
+Bundler.setup(:benchmark)
+require 'plumb'
+require 'memory_profiler'
+
+# Count every flip to invalid, so the per-record figure is exact rather than
+# sampled. Both forms are counted: #invalid allocates a fresh Result (the safe form
+# user code uses), #invalid! flips the receiver (the built-ins' hot path).
+$invalid_transitions = 0
+module CountInvalidTransitions
+  def invalid(*args, **kwargs)
+    $invalid_transitions += 1
+    super
+  end
+
+  def invalid!(*args, **kwargs)
+    $invalid_transitions += 1
+    super
+  end
+end
+Plumb::Result.prepend(CountInvalidTransitions)
+
+module Bench
+  include Plumb::Types
+
+  # A value union: on a miss each branch interpolates "Must be equal to #{value}"
+  # (ValueClass#call), so late matches allocate error strings too.
+  Role = Value['admin'] | Value['editor'] | Value['viewer']
+  # email OR nil
+  Contact = String[/@/] | Nil
+
+  class Record < Data
+    attribute :name, String.present # not a union: the baseline field
+    attribute :age, Lax::Integer    # a union of coercions
+    attribute :role, Role
+    attribute :contact, Contact
+  end
+end
+
+N = Integer(ENV.fetch('N', '2000'))
+
+REGIMES = {
+  'first-branch valid' => { name: 'Joe', age: 40,   role: 'admin',  contact: 'joe@example.com' },
+  'union-hit valid'    => { name: 'Joe', age: '40', role: 'viewer', contact: nil },
+  'fully invalid'      => { name: '',    age: 'xx', role: 'nope',   contact: 123 }
+}.freeze
+
+REPORTED_CLASSES = %w[
+  Plumb::Result
+  String
+  Array
+  Hash
+].freeze
+
+def run_regime(row)
+  # warm (fill caches, JIT) and confirm validity classification
+  valid = Bench::Record.resolve(row).valid?
+
+  $invalid_transitions = 0
+  report = MemoryProfiler.report { N.times { Bench::Record.resolve(row) } }
+  invalid = $invalid_transitions
+
+  by_class = report.allocated_objects_by_class.each_with_object(Hash.new(0)) do |h, acc|
+    acc[h[:data]] = h[:count]
+  end
+  total = report.total_allocated
+
+  { valid:, invalid:, by_class:, total: }
+end
+
+results = REGIMES.transform_values { |row| run_regime(row) }
+
+puts "Parsing #{N} records per regime. Cells are total objects (per-record).\n\n"
+
+LABEL_W = 20
+COL_W = 22
+cell   = ->(str) { str.to_s.rjust(COL_W) }
+count  = ->(n) { cell.call(format('%d (%.2f)', n, n.to_f / N)) }
+
+def rule(width) = puts('-' * width)
+
+header = 'regime'.ljust(LABEL_W) + results.keys.map { |k| cell.call(k) }.join
+puts header
+puts 'valid output?'.ljust(LABEL_W) + results.values.map { |r| cell.call(r[:valid]) }.join
+rule(header.size)
+
+# Headline: flips to invalid (exact count, not sampled).
+puts 'invalid flips'.ljust(LABEL_W) + results.values.map { |r| count.call(r[:invalid]) }.join
+
+# Allocations, from the sampling profiler.
+REPORTED_CLASSES.each do |klass|
+  puts klass.sub('Plumb::', '').ljust(LABEL_W) +
+       results.values.map { |r| count.call(r[:by_class][klass]) }.join
+end
+
+rule(header.size)
+puts 'TOTAL objects'.ljust(LABEL_W) + results.values.map { |r| count.call(r[:total]) }.join
+
+# Order sensitivity: the SAME union, matching the first vs the last branch.
+puts "\nOrder sensitivity — (Value[a] | Value[b] | Value[c]).resolve(x), #{N}x each:"
+[%w[admin first], %w[viewer last]].each do |value, position|
+  $invalid_transitions = 0
+  N.times { Bench::Role.resolve(value) }
+  puts format('  match %-5s branch (%-6s): %d invalid flips (%.2f/record)',
+              position, value, $invalid_transitions, $invalid_transitions.to_f / N)
+end

data/bench/sample_data.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+# Shared sample payload for the schema-library comparisons (Parametric, Plumb,
+# Dry::Types). A realistic nested "broadband/TV/phone bundle" record.
+SAMPLE_DATA = {
+  supplier_name: 'Vodafone',
+  start_date: '2020-01-01',
+  end_date: '2021-01-11',
+  countdown_date: '2021-01-11',
+  name: 'Vodafone TV',
+  upfront_cost_description: 'Upfront cost description',
+  tv_channels_count: 100,
+  terms: [
+    { name: 'Foo', url: 'http://foo.com', terms_text: 'Foo terms', start_date: '2020-01-01', end_date: '2021-01-01' },
+    { name: 'Foo2', url: 'http://foo2.com', terms_text: 'Foo terms', start_date: '2020-01-01', end_date: '2021-01-01' }
+  ],
+  tv_included: true,
+  additional_info: 'Additional info',
+  product_type: 'TV',
+  annual_price_increase_applies: true,
+  annual_price_increase_description: 'Annual price increase description',
+  broadband_components: [
+    {
+      name: 'Broadband 1',
+      technology: 'FTTP',
+      technology_tags: ['FTTP'],
+      is_mobile: false,
+      description: 'Broadband 1 description',
+      download_speed_measurement: 'Mbps',
+      download_speed: 100,
+      upload_speed_measurement: 'Mbps',
+      upload_speed: 100,
+      download_usage_limit: 1000,
+      discount_price: 100,
+      discount_period: 12,
+      speed_description: 'Speed description',
+      ongoing_price: 100,
+      contract_length: 12,
+      upfront_cost: 100,
+      commission: 100
+    }
+  ],
+  tv_components: [
+    {
+      slug: 'vodafone-tv',
+      name: 'Vodafone TV',
+      search_tags: %w[Vodafone TV],
+      description: 'Vodafone TV description',
+      channels: 100,
+      discount_price: 100
+    }
+  ],
+  call_package_types: ['Everything'],
+  phone_components: [
+    {
+      name: 'Phone 1',
+      description: 'Phone 1 description',
+      discount_price: 100,
+      discount_period: 12,
+      ongoing_price: 100,
+      contract_length: 12,
+      upfront_cost: 100,
+      commission: 100,
+      call_package_types: ['Everything']
+    }
+  ],
+  payment_methods: ['Credit Card', 'Paypal'],
+  discounts: [
+    { period: 12, price: 100 }
+  ],
+  ongoing_price: 100,
+  contract_length: 12,
+  upfront_cost: 100,
+  year_1_price: 100,
+  savings: 100,
+  commission: 100,
+  max_broadband_download_speed: 100
+}.freeze

data/examples/command_objects.rb

@@ -65,7 +65,7 @@ module Types
       FileUtils.mkdir_p(dir)
     end
 
-    # The Plumb::Step interface to make these objects composable.
+    # The Plumb::Callable interface to make these objects composable.
     # @param result [Plumb::Result::Valid]
     # @return [Plumb::Result::Valid, Plumb::Result::Invalid]
     def call(result)

data/examples/concurrent_downloads.rb

@@ -20,10 +20,10 @@ module Types
   # It implements the #call(Result) => Result interface.
   # required by all Plumb steps.
   # URI => Image
-  Download = Plumb::Step.new do |result|
+  Download = Plumb::Composable.wrap(lambda do |result|
     io = ::URI.open(result.value)
     result.valid(Image.new(result.value.to_s, io))
-  end
+  end)
 
   # A configurable file-system cache to read and write files from.
   class Cache
@@ -32,12 +32,13 @@ module Types
       FileUtils.mkdir_p(dir)
     end
 
-    # Wrap the #reader and #wruter methods into Plumb steps
+    # Wrap the #reader and #writer methods into Plumb steps
     # A step only needs #call(Result) => Result to work in a pipeline,
-    # but wrapping it in Plumb::Step provides the #>> and #| methods for composability,
-    # as well as all the other helper methods provided by the Composable module.
-    def read = Plumb::Step.new(method(:reader))
-    def write = Plumb::Step.new(method(:writer))
+    # but wrapping it with Plumb::Composable.wrap provides the #>> and #| methods
+    # for composability, as well as all the other helper methods provided by the
+    # Composable module.
+    def read = Plumb::Composable.wrap(method(:reader))
+    def write = Plumb::Composable.wrap(method(:writer))
 
     private
 
@@ -54,7 +55,9 @@ module Types
       image = result.value
       path = path_for(image.url)
       File.open(path, 'wb') { |f| f.write(image.io.read) }
-      result.valid image.where(url: path, io: File.new(path))
+      # `#with` — the copy-with-changes method on a Ruby ::Data. (Not Plumb's
+      # `#where`, which builds a refined TYPE; `image` here is a Data instance.)
+      result.valid image.with(url: path, io: File.new(path))
     end
 
     def path_for(url)
@@ -78,7 +81,11 @@ cache = Types::Cache.new('./examples/data/downloads')
 # 1). Take a valid URL string.
 # 2). Attempt reading the file from the cache. Return that if it exists.
 # 3). Otherwise, download the file from the internet and write it to the cache.
-IdempotentDownload = Types::Forms::URI::HTTP >> (cache.read | (Types::Download >> cache.write))
+# The leading step turns a URL string into a URI::HTTP (HTTPS included — it is a
+# subclass). The encoder composes here in its decode direction
+# (String -> URI::HTTP), picked automatically from what the rest of the pipeline
+# consumes.
+IdempotentDownload = Plumb::Codec::Forms::HTTPURIEncoder >> (cache.read | (Types::Download >> cache.write))
 
 # An array of downloadable images,
 # marked as concurrent so that all IO operations are run in threads.

data/examples/event_registry.rb

@@ -14,6 +14,11 @@ module Types
   # Turn an ISO8601 string into a Time object
   ISOTime = String.build(::Time, :parse).policy(:rescue, ArgumentError)
 
+  # An already-parsed Time, or an ISO8601 string coerced into one. Use
+  # `Plumb::Codec::Forms::TimeEncoder` instead if you also want to encode back to
+  # a string; ISOTime above covers the one direction this example needs.
+  Timestamp = Time | ISOTime
+
   # A UUID string, or generate a new one
   AutoUUID = UUID::V4.default { SecureRandom.uuid }
 end
@@ -57,7 +62,7 @@ class Event < Types::Data
   attribute :id, Types::AutoUUID
   attribute :stream_id, Types::String.present
   attribute :type, Types::String
-  attribute(:created_at, Types::Forms::Time.default { ::Time.now })
+  attribute(:created_at, Types::Timestamp.default { ::Time.now })
   attribute? :causation_id, Types::UUID::V4
   attribute? :correlation_id, Types::UUID::V4
   attribute :payload, Types::Static[nil]

data/examples/weekdays.rb

@@ -41,7 +41,7 @@ module Types
   # Ex. [1, 2, 3, 4, 5, 6, 7], [1, 2, 4], ['monday', 'tuesday', 'wednesday', 7]
   # Turn day names into numbers, and sort the array.
   Week = Array[DayNameOrNumber]
-         .policy(size: 1..7)
+         .where(size: 1..7)
          .check('repeated days') { |days| days.uniq.size == days.size }
          .transform(::Array, &:sort)
 end

data/lib/plumb/and.rb

@@ -1,26 +1,83 @@
 # frozen_string_literal: true
 
 require 'plumb/composable'
+require 'plumb/conjunction'
 
 module Plumb
+  # SEQUENTIAL COMPOSITION — a morphism `left.source -> right.target`, built by
+  # `Composable#>>` when some side changes the value. The pure-refinement case
+  # (neither side converts) is {Plumb::Intersection} instead; see
+  # {Plumb::Conjunction} for why the two must be different nodes.
+  #
+  # #input_type / #output_type are what the chain as a whole CONSUMES and PRODUCES,
+  # not its two sides (those are `children`): `(String -> Integer) >> (Integer ->
+  # Integer)` consumes String and produces Integer. One hop at construction suffices,
+  # since the children are already resolved by the same rule — O(1) per node, and off
+  # the memoization path entirely.
   class And
     include Composable
-
-    attr_reader :children
+    include Conjunction
 
     def initialize(left, right)
       @left = left
       @right = right
+      @input_type = left.input_type
+      # A value-preserving right NARROWS what the left produces rather than replacing
+      # it, so the chain produces the MEET of the two: `(String -> Integer)` then
+      # `where(size: 10)` produces an Integer of size 10, not the bare `(size === 10)`.
+      # A converting right replaces the value, so its own output stands.
+      #
+      # Conjunction.build, not Intersection.new — `left.output_type` need not preserve
+      # values (a record drops undeclared keys, a Static replaces it), and only the
+      # classifier may decide. The `lo.equal?(left)` guard is the fixpoint: a left that
+      # IS its own output type would otherwise recurse forever.
+      @output_type = if Plumb::Subtyping.value_preserving?(right)
+                       lo = left.output_type
+                       lo.equal?(left) ? self : Conjunction.build(lo, right)
+                     else
+                       right.output_type
+                     end
       @children = [left, right].freeze
       freeze
     end
 
-    private def _inspect
-      %((#{@left.inspect} >> #{@right.inspect}))
+    # Identified for subtyping by what it PRODUCES, like Function and Implementation:
+    # the input constraints do not carry through. This is what stops the meet rule
+    # reaching a chain that converts. @see Composable#subtype_identity
+    def subtype_identity = @output_type
+
+    # Deliberately NO #accepted_type override: a composition accepts what it consumes,
+    # its #input_type, which is the default. Accepting against the right child's output
+    # (what Intersection does) would demand the upstream already produce what this
+    # chain's LAST step emits.
+
+    # Fuse `self >> other` by RE-ASSOCIATING: `>>` is associative, so when the tail can
+    # absorb `other` we rebuild around the fused tail. Without this, one non-fusable
+    # step at the head blocks every later step from reducing — a pipeline behind a type
+    # gate is `And(gate, step1)`, and only Function-to-Function fuses, so `step2`
+    # onwards could never join.
+    #
+    # The soundness proof stays with the node that owns it: this only re-associates,
+    # and `@right.fuse_with(other)` carries its own boundary check. Nil when the tail
+    # declines. Recursion is bounded by the chain's depth.
+    def fuse_with(other)
+      fused = @right.fuse_with(other)
+      fused && Conjunction.build(@left, fused)
+    end
+
+    # Boundary absorption re-associates for the same reason #fuse_with does: the
+    # boundary a chain presents to a neighbour belongs to the step at that END of it,
+    # so `And(gate, f) >> Types::Float` reaches `f`'s output slot, and `Types::Integer
+    # >> And(f, x)` reaches `f`'s input slot. Nil when that end declines, and the
+    # rebuilt half carries its own soundness proof. @see Composable#absorb_output
+    def absorb_output(type)
+      absorbed = @right.absorb_output(type)
+      absorbed && Conjunction.build(@left, absorbed)
     end
 
-    def call(result)
-      result.map(@left).map(@right)
+    def absorb_input(type)
+      absorbed = @left.absorb_input(type)
+      absorbed && Conjunction.build(absorbed, @right)
     end
   end
 end

data/lib/plumb/any_class.rb

@@ -6,8 +6,15 @@ module Plumb
   class AnyClass
     include Composable
 
-    def |(other) = Composable.wrap(other)
-    def >>(other) = Composable.wrap(other)
+    # These shortcuts bypass Composable's operators, but still resolve the
+    # operand through the #to_plumb_type hook (an Encoder gets no orientation
+    # context from the Any top and falls back to its default direction; a
+    # Codec must not leak into the tree as a bare node).
+    def |(other) = Composable.resolve_operand(other, op: :|, left: self)
+    def >>(other) = Composable.resolve_operand(other, op: :>>, left: self)
+
+    # Top is the identity of intersection: `Any & X == X`, mirroring `Any | X`.
+    def &(other) = Composable.resolve_operand(other, op: :&, left: self)
 
     # Any.default(value) must trigger default when value is Undefined
     def default(...)
@@ -15,5 +22,8 @@ module Plumb
     end
 
     def call(result) = result
+
+    # The identity type — accepts anything, changes nothing.
+    def value_preserving? = true
   end
 end

data/lib/plumb/array_class.rb

@@ -8,6 +8,7 @@ require 'plumb/stream_class'
 module Plumb
   class ArrayClass
     include Composable
+    include CovariantFusion
 
     attr_reader :children
 
@@ -24,50 +25,78 @@ module Plumb
 
     alias [] of
 
+    # An Array re-maps each element through its element type, so it preserves the
+    # value only when that element type does (a coercing element would change the
+    # array). This lets `#>>` drop a redundant `Array[Integer] >> Array[Numeric]`
+    # and `#|` absorb `Array[Integer] | Array[Numeric]`, matching the scalar case.
+    def value_preserving? = children.all? { |c| Plumb::Subtyping.value_preserving?(c) }
+
+    # Rebuild around new children (see Plumb::Subtyping.map_children).
+    def with_children(children) = of(children.first)
+
+    # As a consumer, an Array accepts elements relaxed to what the ELEMENT type
+    # accepts — so `Array[Integer] >> Array[Integer.build(Money)]` composes,
+    # mirroring HashClass#accepted_type's per-field relaxation.
+    def accepted_type = Plumb::Subtyping.map_children(self) { |c| Plumb::Subtyping.accepted_type(c) }
+
+    # The value you GET after re-mapping each element: the element type resolved
+    # to what it produces, so `Array[String >> Integer].output_type` is
+    # `Array[Integer]` (mirror of #accepted_type).
+    def output_type = Plumb::Subtyping.map_children(self) { |c| Plumb::Subtyping.resolved_output(c) }
+
     def concurrent
-      ConcurrentArrayClass.new(element_type:)
+      concurrent_class.new(element_type:)
     end
 
     def stream
       StreamClass.new(element_type:)
     end
 
+    # A lenient version of this Array: it accepts any Array and emits one with only
+    # the valid elements, dropping the rest. @see FilteredArray
     def filtered
-      MatchClass.new(::Array) >> Step.new(nil, "Array[#{element_type}].filtered") do |result|
-        arr = result.value.each.with_object([]) do |e, memo|
-          r = element_type.resolve(e)
-          memo << r.value if r.valid?
-        end
-        result.valid(arr)
-      end
+      filtered_class.new(element_type:)
     end
 
     def call(result)
-      return result.invalid(errors: 'is not an Array') unless ::Array === result.value
+      return result.invalid!(errors: 'is not an Array') unless ::Array === result.value
 
+      # map_array_elements uses its own element scratch (below), so `result` is
+      # untouched until here — flip it in place rather than allocating a fresh one.
       values, errors = map_array_elements(result)
-      return result.valid(values) unless errors.any?
+      return result.valid!(values) unless errors.any?
 
-      result.invalid(values, errors:)
+      result.invalid!(values, errors:)
     end
 
     private
 
     attr_reader :element_type
 
+    # Named, not hardcoded, so the two combine in EITHER order: each subclass points
+    # at the variant that keeps what it already is, instead of the second call
+    # dropping the first.
+    def concurrent_class = ConcurrentArrayClass
+    def filtered_class = FilteredArray
+
     def _inspect
       %(Array[#{element_type}])
     end
 
     def map_array_elements(result)
-      # Reuse the same result object for each element
-      # to decrease object allocation.
-      # Steps might return the same result instance, so we map the values directly
-      # separate from the errors.
-      element_result = result.dup
-      errors = Hash.new(capacity: result.value.size)
-      values = result.value.map.with_index do |e, idx|
-        re = element_type.call(element_result.reset(e))
+      # Reuse the INCOMING cursor as the per-element scratch (capturing the array
+      # first): each element flips it in place via #reset, and #call flips it a
+      # final time to the collected values — so a sequential Array validates with
+      # zero Result allocations of its own. Steps may return the same result
+      # instance, so map values/errors out immediately rather than holding `re`.
+      #
+      # Element types that produce a value which is lazily consumed later (a
+      # Stream) must not close over this reused cursor — StreamClass#call
+      # snapshots its source for exactly this reason (see there).
+      array = result.value
+      errors = Hash.new(capacity: array.size)
+      values = array.map.with_index do |e, idx|
+        re = element_type.call(result.reset(e))
         errors[idx] = re.errors unless re.valid?
         re.value
       end
@@ -78,19 +107,98 @@ module Plumb
     class ConcurrentArrayClass < self
       private
 
+      # Same contract as the sequential version above — collect each element's value,
+      # and its errors when it is invalid. Two ways this diverged from it:
+      #
+      #   - an element that resolved to an INVALID Result recorded nothing, because
+      #     only `f.reason` (an exception) was collected. With no errors recorded,
+      #     #call reports the whole array VALID, so
+      #     `Array[Integer].concurrent.resolve(['x'])` came back valid — a concurrent
+      #     Array was not really validating its elements.
+      #   - a REJECTED future (the element step raised) has a nil #value, so reading
+      #     `#value` on it raised `NoMethodError: undefined method 'value' for nil`
+      #     instead of surfacing the cause. The sequential path lets such an exception
+      #     propagate, so re-raise the reason to match it.
+      #
+      # No cursor reuse here, unlike the sequential path: the futures resolve on
+      # different threads, so each needs its own Result.
       def map_array_elements(result)
-        errors = {}
+        array = result.value
+        errors = Hash.new(capacity: array.size)
+        futures = array.map { |e| Concurrent::Future.execute { element_type.resolve(e) } }
+
+        values = futures.map.with_index do |future, idx|
+          re = future.value # blocks until settled; nil when rejected
+          raise future.reason if future.rejected?
 
-        values = result.value
-                       .map { |e| Concurrent::Future.execute { element_type.resolve(e) } }
-                       .map.with_index do |f, idx|
-          re = f.value
-          errors[idx] = f.reason if f.rejected?
+          errors[idx] = re.errors unless re.valid?
           re.value
         end
 
         [values, errors]
       end
+
+      def filtered_class = ConcurrentFilteredArray
+    end
+
+    # Same element type as an ArrayClass, but drops invalid elements instead of
+    # rejecting the whole Array. Being an ArrayClass is what keeps it rewritable: a
+    # visitor — or a Codec — that maps the element type rebuilds a FilteredArray, not
+    # a plain one. @see HashMap::FilteredHashMap, the same arrangement for maps.
+    class FilteredArray < self
+      # It drops elements, so it changes the value whatever its element type does.
+      def value_preserving? = false
+
+      # Lenient: it never rejects an Array, so as a #>> consumer it accepts any
+      # enumerable — without this `Types::Array >> Array[String].filtered` is an
+      # illegal narrowing.
+      def accepted_type = Types::Each
+
+      # `Array[T].filtered.stream` IS `Array[T].stream.filtered` — a filtered Stream
+      # drops the same elements, lazily.
+      def stream = super.filtered
+
+      def call(result)
+        return result.invalid!(errors: 'is not an Array') unless ::Array === result.value
+
+        result.valid!(valid_elements(result.value))
+      end
+
+      private
+
+      def concurrent_class = ConcurrentFilteredArray
+
+      # The only thing the concurrent variant replaces. No errors to collect, unlike
+      # #map_array_elements — an invalid element is simply not there.
+      def valid_elements(array)
+        array.each.with_object([]) do |e, memo|
+          r = element_type.resolve(e)
+          memo << r.value if r.valid?
+        end
+      end
+
+      def _inspect = "Array[#{element_type}].filtered"
+    end
+
+    # Both at once, reached from either side (`.filtered.concurrent`,
+    # `.concurrent.filtered`), and itself under both.
+    class ConcurrentFilteredArray < FilteredArray
+      private
+
+      def filtered_class = ConcurrentFilteredArray
+
+      # A rejected future re-raises, as ConcurrentArrayClass does: an element step
+      # that RAISED is a bug to surface, not an element to drop.
+      def valid_elements(array)
+        futures = array.map { |e| Concurrent::Future.execute { element_type.resolve(e) } }
+
+        futures.each_with_object([]) do |future, memo|
+          r = future.value # blocks until settled; nil when rejected
+          raise future.reason if future.rejected?
+
+          memo << r.value if r.valid?
+        end
+      end
     end
   end
 end