module Dry::Types::BuilderMethods

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

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

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)

def Instance(klass)
  unless klass.is_a?(::Module)
    raise ::ArgumentError, "Expected a class or module, got #{klass.inspect}"
  end
  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)

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