solid-process/solid-result

class Solid::Result
  private attr_accessor unknown: bool
  private attr_writer event_logs: Hash[Symbol, untyped]
  private attr_reader type_checker: Solid::Result::Contract::TypeChecker

  attr_reader data: Solid::Result::Data
  attr_reader source: untyped
  attr_reader terminal: bool
  attr_reader event_logs: Hash[Symbol, untyped]

  def self.config: -> Solid::Result::Config
  def self.configuration: (freeze: bool) { (Solid::Result::Config) -> void } -> (bool | Solid::Result::Config)
  def self.event_logs: (name: untyped, desc: untyped) { () -> untyped } -> Solid::Result

  def initialize: (
    type: Symbol,
    value: untyped,
    ?source: untyped,
    ?expectations: Solid::Result::Contract::Evaluator,
    ?terminal: bool
  ) -> void

  def type: -> Symbol
  def value: -> untyped

  def type?: (Symbol | String) -> bool
  def terminal?: -> bool
  def success?: (?Symbol type) -> bool
  def failure?: (?Symbol type) -> bool

  def value_or: { () -> untyped } -> untyped

  def on: (*Symbol) { (untyped, Symbol) -> void } -> Solid::Result
  def on_success: (*Symbol) { (untyped, Symbol) -> void } -> Solid::Result
  def on_failure: (*Symbol) { (untyped, Symbol) -> void } -> Solid::Result
  def on_unknown: () { (untyped, Symbol) -> void } -> Solid::Result

  def and_then: (?Symbol method_name, ?untyped injected_value) ?{ (untyped) -> untyped } -> untyped

  def and_then!: (untyped, ?untyped injected_value, _call: (Symbol | nil)) -> untyped

  def handle: () { (Solid::Result::Handler) -> void } -> untyped

  def ==: (untyped) -> bool
  def hash: -> Integer
  def inspect: -> String

  def deconstruct: -> [Symbol, [Symbol, untyped]]
  def deconstruct_keys: (Array[Symbol]) -> Hash[Symbol, Hash[Symbol, untyped]]

  TYPE_AND_VALUE: Array[Symbol]

  def method_missing: (Symbol, *untyped) { (untyped) -> untyped } -> untyped

  alias is? type?
  alias eql? ==
  alias on_type on

  private

  def kind: -> Symbol
  def known: (Proc) -> untyped
  def call_and_then_source_method: (Symbol, untyped) -> Solid::Result
  def call_and_then_source_method!: (untyped, untyped) -> Solid::Result
  def call_and_then_block: (untyped) -> Solid::Result
  def call_and_then_block!: (untyped) -> Solid::Result
  def call_and_then_callable!: (untyped, value: untyped, injected_value: untyped, method_name: (Symbol | nil)) -> Solid::Result
  def ensure_result_object: (untyped, origin: Symbol) -> Solid::Result
end

class Solid::Result
  class Success < Solid::Result
    include Solid::Success
  end

  def self.Success: (Symbol type, ?untyped value) -> Solid::Result::Success
end

class Solid::Result
  class Failure < Solid::Result
    include Solid::Failure
  end

  def self.Failure: (Symbol type, ?untyped value) -> Solid::Result::Failure
end