class Dry::Schema::PredicateInferrer::Compiler

@api private
Compiler reduces type AST into a list of predicates

def infer_predicate(type)

Other tags:
    Api: - private
def infer_predicate(type)
  TYPE_TO_PREDICATE.fetch(type) { :"#{type.name.split('::').last.downcase}?" }
end

def initialize(registry)

Other tags:
    Api: - private
def initialize(registry)
  @registry = registry
end

def visit(node)

Other tags:
    Api: - private
def visit(node)
  meth, rest = node
  public_send(:"visit_#{meth}", rest)
end

def visit_any(_)

Other tags:
    Api: - private
def visit_any(_)
  nil
end

def visit_array(_)

Other tags:
    Api: - private
def visit_array(_)
  :array?
end

def visit_constrained(node)

Other tags:
    Api: - private
def visit_constrained(node)
  other, * = node
  visit(other)
end

def visit_constructor(node)

Other tags:
    Api: - private
def visit_constructor(node)
  other, * = node
  visit(other)
end

def visit_enum(node)

Other tags:
    Api: - private
def visit_enum(node)
  other, * = node
  visit(other)
end

def visit_hash(_)

Other tags:
    Api: - private
def visit_hash(_)
  :hash?
end

def visit_nominal(node)

Other tags:
    Api: - private
def visit_nominal(node)
  type = node[0]
  predicate = infer_predicate(type)
  if registry.key?(predicate)
    predicate
  else
    { type?: type }
  end
end

def visit_safe(node)

Other tags:
    Api: - private
def visit_safe(node)
  other, * = node
  visit(other)
end

def visit_sum(node)

Other tags:
    Api: - private
def visit_sum(node)
  left, right = node
  predicates = [visit(left), visit(right)]
  if predicates.first == :nil?
    predicates[1..predicates.size - 1]
  else
    predicates
  end
end