class Dry::Types::Sum

def call(input)
  try(input).input
end

def constrained(options)
  if optional?
    right.constrained(options).optional
  else
    super
  end
end

def constrained?
  false
end

def default?
  false
end

def failure(input, _error = nil)
  if !left.valid?(input)
    left.failure(input, left.try(input).error)
  else
    right.failure(input, right.try(input).error)
  end
end

def initialize(left, right, options = {})
  super
  @left, @right = left, right
  freeze
end

def name
  [left, right].map(&:name).join(' | ')
end

def optional?
  left == Types['strict.nil']
end

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

def success(input)
  if left.valid?(input)
    left.success(input)
  elsif right.valid?(input)
    right.success(input)
  else
    raise ArgumentError, "Invalid success value '#{input}' for #{inspect}"
  end
end

def to_ast(meta: true)
  [:sum, [left.to_ast(meta: meta), right.to_ast(meta: meta), meta ? self.meta : EMPTY_HASH]]
end

def try(input, &block)
  result = left.try(input) do
    right.try(input)
  end
  return result if result.success?
  if block
    yield(result)
  else
    result
  end
end

def valid?(value)
  left.valid?(value) || right.valid?(value)
end