module Dry::Types::BuilderMethods

def Array(type)
  Strict(::Array).of(type)
end

def Constant(object)
  Nominal(object.class).constrained(is: object)
end

def Constructor(klass, cons = nil, &block) # rubocop:disable Metrics/PerceivedComplexity:
  if klass.is_a?(Type)
    if cons || block
      klass.constructor(cons || block)
    else
      klass
    end
  else
    Nominal(klass).constructor(cons || block || klass.method(:new))
  end
end

def Hash(type_map)
  Strict(::Hash).schema(type_map)
end

def Instance(klass)
  Nominal(klass).constrained(type: klass)
end

def Interface(*methods)
  methods.reduce(Types["nominal.any"]) do |type, method|
    type.constrained(respond_to: method)
  end
end

def Map(key_type, value_type)
  Nominal(::Hash).map(key_type, value_type)
end

def Nominal(klass)
  if klass <= ::Array
    Array.new(klass)
  elsif klass <= ::Hash
    Hash.new(klass)
  else
    Nominal.new(klass)
  end
end

def Value(value)
  Nominal(value.class).constrained(eql: value)
end

def included(base)
  super
  base.extend(BuilderMethods)
end