class Dry::Types::Hash::Schema

def call(hash)
  coerce(hash)
end

def coerce(hash)
  resolve(hash) do |type, key, value|
    begin
      type.call(value)
    rescue ConstraintError
      raise SchemaError.new(key, value)
    end
  end
end

def initialize(_primitive, options)
  @member_types = options.fetch(:member_types)
  super
end

def resolve(hash)
  result = {}
  member_types.each do |key, type|
    if hash.key?(key)
      result[key] = yield(type, key, hash[key])
    else
      resolve_missing_value(result, key, type)
    end
  end
  result
end

def resolve_missing_value(result, key, type)
  if type.default?
    result[key] = type.evaluate
  else
    super
  end
end

def try(hash, &block)
  success = true
  output  = {}
  begin
    result = try_coerce(hash) do |key, member_result|
      success &&= member_result.success?
      output[key] = member_result.input
      member_result
    end
  rescue ConstraintError, UnknownKeysError, SchemaError => e
    success = false
    result = e
  end
  if success
    success(output)
  else
    failure = failure(output, result)
    block ? yield(failure) : failure
  end
end

def try_coerce(hash)
  resolve(hash) do |type, key, value|
    yield(key, type.try(value))
  end
end