class Dry::Types::Constrained

def ===(value)
  valid?(value)
end

def call(input)
  try(input) do |result|
    raise ConstraintError.new(result, input)
  end.input
end

def constrained(options)
  with(rule: rule & Types.Rule(options))
end

def constrained?
  true
end

def decorate?(response)
  super || response.kind_of?(Constructor)
end

def initialize(type, options)
  super
  @rule = options.fetch(:rule)
end

def to_ast(meta: true)
  [:constrained, [type.to_ast(meta: meta),
                  rule.to_ast,
                  meta ? self.meta : EMPTY_HASH]]
end

def try(input, &block)
  result = rule.(input)
  if result.success?
    type.try(input, &block)
  else
    failure = failure(input, result)
    block ? yield(failure) : failure
  end
end

def valid?(value)
  rule.(value).success? && type.valid?(value)
end