class Dry::Schema::Result

def self.new(*, **)
  result = super
  yield(result) if block_given?
  result.freeze
end

def [](name)
  output[name]
end

def add_error(node)
  result_ast << node
end

def at(at_path, &)
  new(@output, path: Path.new([*path, *Path[at_path]]), &)
end

def concat(other)
  result_ast.concat(other.map(&:to_ast))
  self
end

def deconstruct_keys(_)
  output
end

def error?(spec)
  message_set.any? { |msg| Path[msg.path].include?(Path[spec]) }
end

def errors(options = EMPTY_HASH)
  message_set(options)
end

def failure?
  !success?
end

def inspect
  "#<#{self.class}#{to_h.inspect} errors=#{errors.to_h.inspect} path=#{path.keys.inspect}>"
end

def key?(name)
  output.key?(name)
end

def message_set(options = EMPTY_HASH)
  message_compiler.with(options).(result_ast)
end

def new(output, **opts, &)
  self.class.new(
    output,
    message_compiler: message_compiler,
    result_ast: result_ast,
    **opts,
    &
  )
end

def output
  path.equal?(Path::EMPTY) ? @output : @output.dig(*path)
end

def path
  @path || Path::EMPTY
end

def replace(value)
  if value.is_a?(output.class)
    output.replace(value)
  elsif path.equal?(Path::EMPTY)
    @output = value
  else
    value_holder = path.keys.length > 1 ? @output.dig(*path.to_a[0..-2]) : @output
    value_holder[path.last] = value
  end
  self
end

def success?
  result_ast.empty?
end

def to_monad
  if success?
    Success(self)
  else
    Failure(self)
  end
end

def update(hash)
  output.update(hash)
  self
end