dry-schema: Dry::Types::Constructor(URI) triggers :uri? predicate with bad arity

The recent addition of the uri? predicate to Dry::Logic::Predicates has the unfortunate side effect of crashing when a Dry::Types::Constructor is based off of URI (or presumably /(?:.*::)?URI$/; as will be explained momentarily):

Exception: ArgumentError: uri? predicate arity is invalid
--
0: /usr/local/lib/ruby/gems/2.7.0/gems/dry-schema-1.5.6/lib/dry/schema/predicate.rb:75:in `ensure_valid'
1: /usr/local/lib/ruby/gems/2.7.0/gems/dry-schema-1.5.6/lib/dry/schema/trace.rb:104:in `method_missing'
2: /usr/local/lib/ruby/gems/2.7.0/gems/dry-schema-1.5.6/lib/dry/schema/trace.rb:52:in `block in evaluate_predicates'
3: /usr/local/lib/ruby/gems/2.7.0/gems/dry-schema-1.5.6/lib/dry/schema/trace.rb:44:in `each'
4: /usr/local/lib/ruby/gems/2.7.0/gems/dry-schema-1.5.6/lib/dry/schema/trace.rb:44:in `flat_map'

The following code will reproduce the error given dry-schema 1.5.6 and dry-logic 1.0.8:

require 'dry/schema'

module WTF
  module Types
    include Dry::Types()
    URI = Types.Constructor(::URI) { |x| ::URI.parse x }
  end

  Schema = Dry::Schema.Params { required(:base).value Types::URI }
end

Diagnosis

It appears that what is happening is the Types::URI object is being handed off to an instance of Dry::Types::PredicateInferrer like so:

Dry::Types::PredicateInferrer.new[Types::URI]
# => [:uri?]

…which it appears to do via Dry::Schema::Macros::DSL#extract_type_spec. The :uri? predicate is picked because of line 49 in dry-types/predicate_inferrer.rb, which looks like:

[TYPE_TO_PREDICATE.fetch(type) { :"#{type.name.split('::').last.downcase}?" }]

…which if I understand correctly will turn the class name URI into the symbol :uri? given that it is not found in the hash. Since this predicate takes two arguments, Dry::Schema::Predicate#ensure_valid raises an exception because this invocation of :uri? has been queued without its other argument (an array of URI schemes), and to my knowledge there is no (documented) way to get additional arguments into predicates that have been queued through the inferrer mechanism.

Remedies

I see a number of possible remedies for this situation; the simplest perhaps being to overwrite the uri? predicate in the application with a method of arity 1. My only problem with this is it is not clear via the documentation where the predicate is actually being invoked and thus where it must be overridden.

Another solution would be to modify Dry::Types::PredicateInferrer#infer_predicate to ignore matches on predicates with arities greater than 1. Ostensibly the most involved solution would be to change (or document?) the interface so the additional arguments can be passed into multi-argument predicates when those predicates have been inferred.

Remarks

This bug was particularly difficult to track down. The behaviour spans three modules (dry-schema, dry-types, dry-logic), which is fine—it is DRY after all—but perhaps some additional signposts or an architectural overview would be helpful. The ultimate raise in ensure_valid was particularly ambiguous, down to the choice of ArgumentError: in addition to the terse error message, it wasn’t clear initially where this error was coming from. My inclination here would be to create a subclass of ArgumentError (say, PredicateParamError) to signal the peculiar case that a given predicate—which has yet to be invoked—has not been bundled with its requisite parameters. Saying something explicit in the error message like predicate :foo? takes parameters; see docs at … would also be helpful.

The overarching approach to mapping class names to predicates, moreover, has the potential to produce fragile and surprising results. Consider:

module Hmm
  class Key
    # this should trigger INVALID_PREDICATES
  end

  module Types
    include Dry::Types()

    Key = Types.Constructor(Key)
  end

  Schema = Dry::Schema.Params do
    required(:key).value Types::Key
  end
end

…sure enough:

Exception: Dry::Schema::InvalidSchemaError: key? predicate cannot be used in this context
--
0: /usr/local/lib/ruby/gems/2.7.0/gems/dry-schema-1.5.6/lib/dry/schema/trace.rb:96:in `method_missing'
1: /usr/local/lib/ruby/gems/2.7.0/gems/dry-schema-1.5.6/lib/dry/schema/trace.rb:52:in `block in evaluate_predicates'
2: /usr/local/lib/ruby/gems/2.7.0/gems/dry-schema-1.5.6/lib/dry/schema/trace.rb:44:in `each'
3: /usr/local/lib/ruby/gems/2.7.0/gems/dry-schema-1.5.6/lib/dry/schema/trace.rb:44:in `flat_map'
4: /usr/local/lib/ruby/gems/2.7.0/gems/dry-schema-1.5.6/lib/dry/schema/trace.rb:44:in `evaluate_predicates'

This is because of line 95 in trace.rb, looking for the derivation of the class name :key? which has been listed as invalid. As with the introduction of the :uri? predicate did with my code, there is potential for future predicates colliding with class names given to Dry::Types::Constructor. As such I apologize if I have potentially burdened you with an architectural rethink, and that my ignorance of the inner workings of dry-rb precludes me of being much more help than this. Nevertheless if pointed in the right direction I can hopefully do more.