class Dry::Types::Intersection

def self.operator = :&

def call_safe(input, &) = try_sides(input, &).input

def call_unsafe(input)
  merge_results(left.call_unsafe(input), right.call_unsafe(input))
end

def merge_results(left_result, right_result)
  case left_result
  when ::Array
    left_result.zip(right_result).map { merge_results(_1, _2) }
  when ::Hash
    left_result.merge(right_result)
  else
    left_result
  end
end

def primitive?(value)
  left.primitive?(value) && right.primitive?(value)
end

def try(input)
  try_sides(input) do |failure|
    if block_given?
      yield(failure)
    else
      failure
    end
  end
end

def try_side(side, input)
  failure = nil
  result = side.try(input) do |f|
    failure = f
    yield(f)
  end
  if result.is_a?(Result)
    result
  elsif failure
    Result::Failure.new(result, failure)
  else
    Result::Success.new(result)
  end
end

def try_sides(input, &block)
  results = []
  [left, right].each do |side|
    result = try_side(side, input, &block)
    return result if result.failure?
    results << result
  end
  Result::Success.new(merge_results(*results.map(&:input)))
end