class Dry::Types::Constrained

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

def call_safe(input, &block)
  if rule[input]
    type.call_safe(input, &block)
  else
    yield
  end
end

def call_unsafe(input)
  result = rule.(input)
  if result.success?
    type.call_unsafe(input)
  else
    raise ConstraintError.new(result, input)
  end
end

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

def constrained?
  true
end

def constructor_type
  type.constructor_type
end

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

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

def lax
  type.lax
end

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

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