class Dry::Types::Map

def assert_primitive(input)
  if primitive?(input)
    yield
  else
    failure(input, CoercionError.new("#{input.inspect} must be an instance of #{primitive}"))
  end
end

def call_safe(hash) = try(hash) { return yield }.input

def call_unsafe(hash)
  try(hash) { |failure|
    raise MapError, failure.error.message
  }.input
end

def coerce(input)
  assert_primitive(input) do
    output = {}
    failures = []
    input.each do |k, v|
      res_k = key_type.try(k)
      res_v = value_type.try(v)
      if res_k.failure?
        failures << res_k.error
      elsif output.key?(res_k.input)
        failures << CoercionError.new("duplicate coerced hash key #{res_k.input.inspect}")
      elsif res_v.failure?
        failures << res_v.error
      else
        output[res_k.input] = res_v.input
      end
    end
    if failures.empty?
      success(output)
    else
      failure(input, MultipleError.new(failures))
    end
  end
end

def constrained? = value_type.constrained?

def initialize(primitive, key_type: Types["any"], value_type: Types["any"], meta: EMPTY_HASH)
  super
end

def key_type = options[:key_type]

def name = "Map"

def to_ast(meta: true)
  [:map,
   [key_type.to_ast(meta: true),
    value_type.to_ast(meta: true),
    meta ? self.meta : EMPTY_HASH]]
end

def try(hash)
  result = coerce(hash)
  return result if result.success? || !block_given?
  yield(result)
end

def value_type = options[:value_type]