# typed: strict
          
        
      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "sorbet-runtime"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require_relative "mangrove/version"
          
        
      
        

          

            
              1
            

            
              
            

            require_relative "mangrove/option"
          
        
      
        

          

            
              1
            

            
              
            

            require_relative "mangrove/result"
          
        
      
        

          

            
              1
            

            
              
            

            require_relative "mangrove/enum"
          
        
      
        

          

            
              1
            

            
              
            

            require_relative "mangrove/control_flow/control_signal"
          
        
      
        

          

            
              1
            

            
              
            

            require_relative "mangrove/try_from_ext"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            # Mangrove
          
        
      
        

          

            
              1
            

            
              
            

            module Mangrove; end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # typed: strict
          
        
      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Mangrove
          
        
      
        

          

            
              1
            

            
              
            

              module ControlFlow
          
        
      
        

          

            
              1
            

            
              
            

                module ControlSignal
          
        
      
        

          

            
              1
            

            
              
            

                  extend T::Sig
          
        
      
        

          

            
              1
            

            
              
            

                  extend T::Helpers
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  interface!
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { abstract.returns(T.untyped) }
          
        
      
        

          

            
              1
            

            
              
            

                  def inner_value; end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # typed: strict
          
        
      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            require "sorbet-runtime"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            module Mangrove
          
        
      
        

          

            

            
              
            

              class EnumVariantsScope
          
        
      
        

          

            

            
              
            

                extend ::T::Sig
          
        
      
        

          

            

            
              
            

                extend ::T::Helpers
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                sig { params(parent: T::Class[T.anything]).void }
          
        
      
        

          

            

            
              
            

                def initialize(parent)
          
        
      
        

          

            

            
              
            

                  @parent = parent
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                sig { params(block: T.proc.void).void }
          
        
      
        

          

            

            
              
            

                def call(&block)
          
        
      
        

          

            

            
              
            

                  instance_eval(&block)
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                sig { params(variant: T::Class[T.anything], inner_type: T.untyped).void }
          
        
      
        

          

            

            
              
            

                def variant(variant, inner_type)
          
        
      
        

          

            

            
              
            

                  variant.instance_variable_set(:@__mangrove__enum_inner_type, inner_type)
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

              private_constant :EnumVariantsScope
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

              module Enum
          
        
      
        

          

            

            
              
            

                extend ::T::Sig
          
        
      
        

          

            

            
              
            

                extend ::T::Helpers
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                requires_ancestor { Module }
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                sig { params(block: T.proc.bind(EnumVariantsScope).void).void }
          
        
      
        

          

            

            
              
            

                def variants(&block)
          
        
      
        

          

            

            
              
            

                  receiver = block.send(:binding).receiver
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  outer_code = <<~RUBY
          
        
      
        

          

            

            
              
            

                    def self.const_missing(id)
          
        
      
        

          

            

            
              
            

                      code = <<~NESTED_RUBY
          
        
      
        

          

            

            
              
            

                        class \#{id} < \#{caller.send(:binding).receiver.name}
          
        
      
        

          

            

            
              
            

                          def initialize(inner)
          
        
      
        

          

            

            
              
            

                            @inner = T.let(inner, self.class.instance_variable_get(:@__mangrove__enum_inner_type))
          
        
      
        

          

            

            
              
            

                          end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                          def inner
          
        
      
        

          

            

            
              
            

                            @inner
          
        
      
        

          

            

            
              
            

                          end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                          def as_super
          
        
      
        

          

            

            
              
            

                            T.cast(self, \#{caller.send(:binding).receiver.name})
          
        
      
        

          

            

            
              
            

                          end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                          def serialize(inner_serialization_methods: [:serialize, :to_h])
          
        
      
        

          

            

            
              
            

                            serialized_inner = begin
          
        
      
        

          

            

            
              
            

                              serialized_klass = [
          
        
      
        

          

            

            
              
            

                                Hash,
          
        
      
        

          

            

            
              
            

                                String,
          
        
      
        

          

            

            
              
            

                                Numeric,
          
        
      
        

          

            

            
              
            

                                TrueClass,
          
        
      
        

          

            

            
              
            

                                FalseClass,
          
        
      
        

          

            

            
              
            

                                NilClass,
          
        
      
        

          

            

            
              
            

                                Array
          
        
      
        

          

            

            
              
            

                              ]
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                              if serialized_klass.any? { |klass| @inner.is_a?(klass) }
          
        
      
        

          

            

            
              
            

                                @inner
          
        
      
        

          

            

            
              
            

                              else
          
        
      
        

          

            

            
              
            

                                inner_serialization_methods.find do |method_name|
          
        
      
        

          

            

            
              
            

                                  if @inner.respond_to?(method_name, true)
          
        
      
        

          

            

            
              
            

                                    maybe_hash = @inner.send(method_name)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                                    if maybe_hash.is_a?(Hash)
          
        
      
        

          

            

            
              
            

                                      break maybe_hash
          
        
      
        

          

            

            
              
            

                                    end
          
        
      
        

          

            

            
              
            

                                  end
          
        
      
        

          

            

            
              
            

                                end
          
        
      
        

          

            

            
              
            

                              end
          
        
      
        

          

            

            
              
            

                            end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                            { type: self.class.name, value: serialized_inner }
          
        
      
        

          

            

            
              
            

                          end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                          def ==(other)
          
        
      
        

          

            

            
              
            

                            other.is_a?(self.class) && other.inner == @inner
          
        
      
        

          

            

            
              
            

                          end
          
        
      
        

          

            

            
              
            

                        end
          
        
      
        

          

            

            
              
            

                      NESTED_RUBY
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                      class_eval(code, __FILE__, __LINE__ + 1)
          
        
      
        

          

            

            
              
            

                      class_eval(id.to_s, __FILE__, __LINE__ + 1)
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  RUBY
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  original_const_missing = receiver.method(:const_missing)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  receiver.class_eval(outer_code, __FILE__, __LINE__ + 1)
          
        
      
        

          

            
              1
            

            
              
            

                  EnumVariantsScope.new(receiver).call(&block)
          
        
      
        

          

            
              1
            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  # Mark as sealed hear because we can not define classes in const_missing after marking as sealed
          
        
      
        

          

            
              1
            

            
              
            

                  receiver.send(:eval, "sealed!", nil, __FILE__, __LINE__)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  variants = constants.filter_map { |variant_name|
          
        
      
        

          

            

            
              
            

                    maybe_variant = receiver.const_get(variant_name, false)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                    if maybe_variant.instance_variable_defined?(:@__mangrove__enum_inner_type)
          
        
      
        

          

            

            
              
            

                      maybe_variant
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  }
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  receiver.class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
          
        
      
        

          

            
              1
            

            
              
            

                    @sorbet_sealed_module_all_subclasses = #{variants} # @sorbet_sealed_module_all_subclasses = #{variants}
          
        
      
        

          

            

            
              
            

                  RUBY
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  # Bring back the original const_missing
          
        
      
        

          

            

            
              
            

                  receiver.define_singleton_method(:const_missing, original_const_missing)
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                sig { params(receiver: T::Class[T.anything]).void }
          
        
      
        

          

            

            
              
            

                def self.extended(receiver)
          
        
      
        

          

            

            
              
            

                  code = <<~RUBY
          
        
      
        

          

            

            
              
            

                    extend T::Sig
          
        
      
        

          

            

            
              
            

                    extend T::Helpers
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                    abstract!
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                    def self.deserialize(hash)
          
        
      
        

          

            

            
              
            

                      klass = const_get(hash[:type] || hash["type"])
          
        
      
        

          

            

            
              
            

                      value = hash[:value] || hash["value"]
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                      begin
          
        
      
        

          

            

            
              
            

                        klass.new(value)
          
        
      
        

          

            

            
              
            

                      rescue TypeError
          
        
      
        

          

            

            
              
            

                        klass.new(klass.deserialize(value))
          
        
      
        

          

            

            
              
            

                      end
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  RUBY
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  receiver.class_eval(code)
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # typed: strict
          
        
      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require_relative "option/control_signal"
          
        
      
        

          

            
              1
            

            
              
            

            require_relative "result"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Mangrove
          
        
      
        

          

            

            
              
            

              # Option is a type that represents either some value (`Some`) or no value (`None`).
          
        
      
        

          

            
              1
            

            
              
            

              module Option
          
        
      
        

          

            
              1
            

            
              
            

                extend T::Sig
          
        
      
        

          

            
              1
            

            
              
            

                extend T::Generic
          
        
      
        

          

            
              1
            

            
              
            

                extend T::Helpers
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                include Kernel
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                sealed!
          
        
      
        

          

            
              1
            

            
              
            

                interface!
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                InnerType = type_member
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                class << self
          
        
      
        

          

            
              1
            

            
              
            

                  extend ::T::Sig
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { type_parameters(:InnerType).params(nilable: T.nilable(T.type_parameter(:InnerType))).returns(Mangrove::Option[T.type_parameter(:InnerType)]) }
          
        
      
        

          

            
              1
            

            
              
            

                  def from_nilable(nilable)
          
        
      
        

          

            
              2
            

            
              
            

                    case nilable
          
        
      
        

          

            

            
              
                
                  when: 1
                
              
            

                    when NilClass
          
        
      
        

          

            
              1
            

            
              
            

                      Mangrove::Option::None.new
          
        
      
        

          

            

            
              
                
                  else: 1
                
              
            

                    else
          
        
      
        

          

            
              1
            

            
              
            

                      Mangrove::Option::Some.new(nilable)
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # Option::Some
          
        
      
        

          

            
              1
            

            
              
            

                class Some
          
        
      
        

          

            
              1
            

            
              
            

                  extend T::Sig
          
        
      
        

          

            
              1
            

            
              
            

                  extend T::Generic
          
        
      
        

          

            
              1
            

            
              
            

                  extend T::Helpers
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  include Option
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  InnerType = type_member
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { params(inner: InnerType).void }
          
        
      
        

          

            
              1
            

            
              
            

                  def initialize(inner)
          
        
      
        

          

            
              28
            

            
              
            

                    @inner = T.let(inner, InnerType)
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.params(other: BasicObject).returns(T::Boolean) }
          
        
      
        

          

            
              1
            

            
              
            

                  def ==(other)
          
        
      
        

          

            
              7
            

            
              
            

                    case other
          
        
      
        

          

            

            
              
                
                  when: 7
                
              
            

                    when Option::Some
          
        
      
        

          

            
              7
            

            
              
            

                      other.instance_variable_get(:@inner) == @inner
          
        
      
        

          

            

            
              
                
                  when: 0
                
              
            

                    when Option::None
          
        
      
        

          

            

            
              
            

                      false
          
        
      
        

          

            

            
              
            

                    else # rubocop:disable Lint/DuplicateBranch
          
        
      
        

          

            

            
              
                
                  else: 0
                
              
            

                      # Because == is defined on BasicObject, we can't be sure that `other` is an Option
          
        
      
        

          

            

            
              
            

                      false
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  sig { returns(InnerType) }
          
        
      
        

          

            
              1
            

            
              
            

                  def unwrap
          
        
      
        

          

            

            
              
            

                    @inner
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.params(_default: InnerType).returns(InnerType) }
          
        
      
        

          

            
              1
            

            
              
            

                  def unwrap_or(_default)
          
        
      
        

          

            
              1
            

            
              
            

                    @inner
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.returns(InnerType) }
          
        
      
        

          

            
              1
            

            
              
            

                  def unwrap!
          
        
      
        

          

            
              2
            

            
              
            

                    @inner
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.params(_message: String).returns(InnerType) }
          
        
      
        

          

            
              1
            

            
              
            

                  def expect!(_message)
          
        
      
        

          

            
              2
            

            
              
            

                    @inner
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.params(_block: T.proc.returns(T.untyped)).returns(InnerType) }
          
        
      
        

          

            
              1
            

            
              
            

                  def expect_with!(&_block)
          
        
      
        

          

            
              2
            

            
              
            

                    @inner
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.returns(T::Boolean) }
          
        
      
        

          

            
              1
            

            
              
            

                  def some? = true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.returns(T::Boolean) }
          
        
      
        

          

            
              1
            

            
              
            

                  def none? = false
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.type_parameters(:NewInnerType).params(block: T.proc.params(inner: InnerType).returns(Option[T.type_parameter(:NewInnerType)])).returns(::Mangrove::Option[T.type_parameter(:NewInnerType)]) }
          
        
      
        

          

            
              1
            

            
              
            

                  def map(&block)
          
        
      
        

          

            
              2
            

            
              
            

                    block.call(@inner)
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.params(_default: Option[InnerType]).returns(Option[InnerType]) }
          
        
      
        

          

            
              1
            

            
              
            

                  def or(_default)
          
        
      
        

          

            
              2
            

            
              
            

                    self
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.type_parameters(:ErrType).params(_err: T.type_parameter(:ErrType)).returns(Mangrove::Result[InnerType, T.type_parameter(:ErrType)]) }
          
        
      
        

          

            
              1
            

            
              
            

                  def transpose(_err)
          
        
      
        

          

            
              1
            

            
              
            

                    Result::Ok.new(@inner)
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  private
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  sig { returns(InnerType) }
          
        
      
        

          

            
              1
            

            
              
            

                  attr_reader :inner
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # Option::None
          
        
      
        

          

            
              1
            

            
              
            

                class None
          
        
      
        

          

            
              1
            

            
              
            

                  extend T::Sig
          
        
      
        

          

            
              1
            

            
              
            

                  extend T::Generic
          
        
      
        

          

            
              1
            

            
              
            

                  extend T::Helpers
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  include Option
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  InnerType = type_member
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.params(other: BasicObject).returns(T::Boolean) }
          
        
      
        

          

            
              1
            

            
              
            

                  def ==(other)
          
        
      
        

          

            
              3
            

            
              
            

                    case other
          
        
      
        

          

            

            
              
                
                  when: 0
                
              
            

                    when Option::Some
          
        
      
        

          

            

            
              
            

                      false
          
        
      
        

          

            

            
              
                
                  when: 3
                
              
            

                    when Option::None
          
        
      
        

          

            
              3
            

            
              
            

                      true
          
        
      
        

          

            

            
              
            

                    else # rubocop:disable Lint/DuplicateBranch
          
        
      
        

          

            

            
              
                
                  else: 0
                
              
            

                      # Because == is defined on BasicObject, we can't be sure that `other` is an Option
          
        
      
        

          

            

            
              
            

                      false
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.params(default: InnerType).returns(InnerType) }
          
        
      
        

          

            
              1
            

            
              
            

                  def unwrap_or(default)
          
        
      
        

          

            
              1
            

            
              
            

                    default
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.returns(InnerType) }
          
        
      
        

          

            
              1
            

            
              
            

                  def unwrap!
          
        
      
        

          

            
              1
            

            
              
            

                    raise Option::ControlSignal, "called `Option#unwrap!` on an `None` value: #{self}"
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.params(message: String).returns(InnerType) }
          
        
      
        

          

            
              1
            

            
              
            

                  def expect!(message)
          
        
      
        

          

            
              1
            

            
              
            

                    raise Option::ControlSignal, message
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.params(block: T.proc.returns(T.untyped)).returns(InnerType) }
          
        
      
        

          

            
              1
            

            
              
            

                  def expect_with!(&block)
          
        
      
        

          

            
              1
            

            
              
            

                    raise Option::ControlSignal, block.call
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.returns(T::Boolean) }
          
        
      
        

          

            
              1
            

            
              
            

                  def some? = false
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.returns(T::Boolean) }
          
        
      
        

          

            
              1
            

            
              
            

                  def none? = true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.type_parameters(:NewInnerType).params(_block: T.proc.params(inner: InnerType).returns(Option[T.type_parameter(:NewInnerType)])).returns(Option[T.type_parameter(:NewInnerType)]) }
          
        
      
        

          

            
              1
            

            
              
            

                  def map(&_block)
          
        
      
        

          

            
              2
            

            
              
            

                    T.cast(self, Option[T.type_parameter(:NewInnerType)])
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.params(default: Option[InnerType]).returns(Option[InnerType]) }
          
        
      
        

          

            
              1
            

            
              
            

                  def or(default)
          
        
      
        

          

            
              2
            

            
              
            

                    default
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.type_parameters(:ErrType).params(err: T.type_parameter(:ErrType)).returns(Mangrove::Result[InnerType, T.type_parameter(:ErrType)]) }
          
        
      
        

          

            
              1
            

            
              
            

                  def transpose(err)
          
        
      
        

          

            
              1
            

            
              
            

                    Result::Err.new(err)
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                sig { abstract.params(other: BasicObject).returns(T::Boolean) }
          
        
      
        

          

            
              1
            

            
              
            

                def ==(other); end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                sig { abstract.params(default: InnerType).returns(InnerType) }
          
        
      
        

          

            
              1
            

            
              
            

                def unwrap_or(default); end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                sig { abstract.returns(InnerType) }
          
        
      
        

          

            
              1
            

            
              
            

                def unwrap!; end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                sig { abstract.params(message: String).returns(InnerType) }
          
        
      
        

          

            
              1
            

            
              
            

                def expect!(message); end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                sig { abstract.params(block: T.proc.returns(T.untyped)).returns(InnerType) }
          
        
      
        

          

            
              1
            

            
              
            

                def expect_with!(&block); end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                sig { abstract.returns(T::Boolean) }
          
        
      
        

          

            
              1
            

            
              
            

                def some?; end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                sig { abstract.returns(T::Boolean) }
          
        
      
        

          

            
              1
            

            
              
            

                def none?; end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                sig { abstract.type_parameters(:NewInnerType).params(block: T.proc.params(inner: InnerType).returns(Option[T.type_parameter(:NewInnerType)])).returns(::Mangrove::Option[T.type_parameter(:NewInnerType)]) }
          
        
      
        

          

            
              1
            

            
              
            

                def map(&block); end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                sig { abstract.params(default: Option[InnerType]).returns(Option[InnerType]) }
          
        
      
        

          

            
              1
            

            
              
            

                def or(default); end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                sig { abstract.type_parameters(:ErrType).params(err: T.type_parameter(:ErrType)).returns(Mangrove::Result[InnerType, T.type_parameter(:ErrType)]) }
          
        
      
        

          

            
              1
            

            
              
            

                def transpose(err); end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # typed: strict
          
        
      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "mangrove/control_flow/control_signal"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Mangrove
          
        
      
        

          

            
              1
            

            
              
            

              module Option
          
        
      
        

          

            
              1
            

            
              
            

                class ControlSignal < StandardError
          
        
      
        

          

            
              1
            

            
              
            

                  extend T::Sig
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  include Mangrove::ControlFlow::ControlSignal
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { params(inner_value: T.untyped).void }
          
        
      
        

          

            
              1
            

            
              
            

                  def initialize(inner_value)
          
        
      
        

          

            
              5
            

            
              
            

                    @inner_value = inner_value
          
        
      
        

          

            
              5
            

            
              
            

                    super
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.params(other: BasicObject).returns(T::Boolean) }
          
        
      
        

          

            
              1
            

            
              
            

                  def ==(other)
          
        
      
        

          

            
              2
            

            
              
            

                    case other
          
        
      
        

          

            

            
              
                
                  when: 2
                
              
            

                    when ControlSignal
          
        
      
        

          

            
              2
            

            
              
            

                      other.inner_value == inner_value
          
        
      
        

          

            

            
              
                
                  else: 0
                
              
            

                    else
          
        
      
        

          

            

            
              
            

                      false
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.returns(T.untyped) }
          
        
      
        

          

            
              1
            

            
              
            

                  attr_reader :inner_value
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # typed: strict
          
        
      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require_relative "result/control_signal"
          
        
      
        

          

            
              1
            

            
              
            

            require_relative "result/ext"
          
        
      
        

          

            
              1
            

            
              
            

            require_relative "result/collector"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Mangrove
          
        
      
        

          

            

            
              
            

              # Result is a type that represents either success (`Ok`) or failure (`Err`).
          
        
      
        

          

            
              1
            

            
              
            

              module Result
          
        
      
        

          

            
              1
            

            
              
            

                extend T::Sig
          
        
      
        

          

            
              1
            

            
              
            

                extend T::Generic
          
        
      
        

          

            
              1
            

            
              
            

                extend T::Helpers
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                include Kernel
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                sealed!
          
        
      
        

          

            
              1
            

            
              
            

                interface!
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                OkType = type_member(:out)
          
        
      
        

          

            
              1
            

            
              
            

                ErrType = type_member(:out)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                sig { abstract.params(other: BasicObject).returns(T::Boolean) }
          
        
      
        

          

            
              1
            

            
              
            

                def ==(other); end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # @deprecated Use #is_a?(Result::Ok) instead to enable Sorbet to define types statically.
          
        
      
        

          

            

            
              
            

                #   This method will be removed in future versions.
          
        
      
        

          

            
              2
            

            
              
            

                sig { abstract.returns(T::Boolean) }
          
        
      
        

          

            
              1
            

            
              
            

                def ok?; end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # @deprecated Use #is_a?(Result::Err) instead to enable Sorbet to define types statically.
          
        
      
        

          

            
              2
            

            
              
            

                sig { abstract.returns(T::Boolean) }
          
        
      
        

          

            
              1
            

            
              
            

                def err?; end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                sig { abstract.returns(OkType) }
          
        
      
        

          

            
              1
            

            
              
            

                def unwrap!; end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                sig { abstract.params(block: T.proc.params(err: ErrType).returns(Exception)).returns(OkType) }
          
        
      
        

          

            
              1
            

            
              
            

                def unwrap_or_raise_with!(&block); end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                sig { abstract.params(exception: Exception).returns(OkType) }
          
        
      
        

          

            
              1
            

            
              
            

                def unwrap_or_raise!(exception); end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                sig { abstract.returns(OkType) }
          
        
      
        

          

            
              1
            

            
              
            

                def unwrap_or_raise_inner!; end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                sig { abstract.params(ctx: Result::CollectingContext[T.untyped, ErrType]).returns(OkType) }
          
        
      
        

          

            
              1
            

            
              
            

                def unwrap_in(ctx); end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                sig { abstract.params(message: String).returns(OkType) }
          
        
      
        

          

            
              1
            

            
              
            

                def expect!(message); end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                sig { abstract.type_parameters(:E).params(block: T.proc.params(err: ErrType).returns(T.type_parameter(:E))).returns(OkType) }
          
        
      
        

          

            
              1
            

            
              
            

                def expect_with!(&block); end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                sig { abstract.type_parameters(:NewOkType, :NewErrType).params(block: T.proc.params(this: Result[OkType, ErrType]).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)])).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]) }
          
        
      
        

          

            
              1
            

            
              
            

                def map(&block); end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                sig { abstract.type_parameters(:NewOkType, :NewErrType).params(_t_new_ok: T::Class[T.type_parameter(:NewOkType)], _t_new_err: T::Class[T.type_parameter(:NewErrType)], block: T.proc.params(this: Result[OkType, ErrType]).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)])).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]) }
          
        
      
        

          

            
              1
            

            
              
            

                def map_wt(_t_new_ok, _t_new_err, &block); end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                sig { abstract.type_parameters(:NewOkType).params(block: T.proc.params(this: OkType).returns(T.type_parameter(:NewOkType))).returns(Result[T.type_parameter(:NewOkType), ErrType]) }
          
        
      
        

          

            
              1
            

            
              
            

                def map_ok(&block); end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                sig { abstract.type_parameters(:NewOkType).params(_t_new_ok: T::Class[T.type_parameter(:NewOkType)], block: T.proc.params(this: OkType).returns(T.type_parameter(:NewOkType))).returns(Result[T.type_parameter(:NewOkType), ErrType]) }
          
        
      
        

          

            
              1
            

            
              
            

                def map_ok_wt(_t_new_ok, &block); end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                sig { abstract.type_parameters(:NewErrType).params(block: T.proc.params(this: ErrType).returns(T.type_parameter(:NewErrType))).returns(Result[OkType, T.type_parameter(:NewErrType)]) }
          
        
      
        

          

            
              1
            

            
              
            

                def map_err(&block); end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                sig { abstract.type_parameters(:NewErrType).params(_t_new_err: T::Class[T.type_parameter(:NewErrType)], block: T.proc.params(this: ErrType).returns(T.type_parameter(:NewErrType))).returns(Result[OkType, T.type_parameter(:NewErrType)]) }
          
        
      
        

          

            
              1
            

            
              
            

                def map_err_wt(_t_new_err, &block); end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                sig { abstract.params(block: T.proc.params(this: OkType).void).returns(Result[OkType, ErrType]) }
          
        
      
        

          

            
              1
            

            
              
            

                def tap_ok(&block); end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                sig { abstract.params(block: T.proc.params(this: ErrType).void).returns(Result[OkType, ErrType]) }
          
        
      
        

          

            
              1
            

            
              
            

                def tap_err(&block); end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                sig { abstract.type_parameters(:NewOkType, :NewErrType).params(other: Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]).returns(T.any(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)], Result[T.type_parameter(:NewOkType), ErrType])) }
          
        
      
        

          

            
              1
            

            
              
            

                def and(other); end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                sig { abstract.type_parameters(:NewOkType, :NewErrType).params(block: T.proc.params(this: OkType).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)])).returns(T.any(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)], Result[T.type_parameter(:NewOkType), ErrType])) }
          
        
      
        

          

            
              1
            

            
              
            

                def and_then(&block); end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                sig { abstract.type_parameters(:NewOkType, :NewErrType).params(_t_new_ok: T::Class[T.type_parameter(:NewOkType)], block: T.proc.params(this: OkType).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)])).returns(T.any(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)], Result[T.type_parameter(:NewOkType), ErrType])) }
          
        
      
        

          

            
              1
            

            
              
            

                def and_then_wt(_t_new_ok, &block); end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                sig {
          
        
      
        

          

            
              1
            

            
              
            

                  abstract
          
        
      
        

          

            

            
              
            

                    .type_parameters(:NewErrType)
          
        
      
        

          

            

            
              
            

                    .params(
          
        
      
        

          

            

            
              
            

                      new_err_inner: T.type_parameter(:NewErrType),
          
        
      
        

          

            

            
              
            

                      condition: T.proc.params(inner: OkType).returns(T::Boolean)
          
        
      
        

          

            

            
              
            

                    )
          
        
      
        

          

            

            
              
            

                    .returns(
          
        
      
        

          

            

            
              
            

                      T.any(Result[OkType, T.type_parameter(:NewErrType)], Result[OkType, ErrType])
          
        
      
        

          

            

            
              
            

                    )
          
        
      
        

          

            

            
              
            

                }
          
        
      
        

          

            
              1
            

            
              
            

                def and_err_if(new_err_inner, &condition); end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                sig { abstract.type_parameters(:NewOkType, :NewErrType).params(other: Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]).returns(T.any(Result[OkType, T.type_parameter(:NewErrType)], Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)])) }
          
        
      
        

          

            
              1
            

            
              
            

                def or(other); end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                sig { abstract.type_parameters(:NewOkType, :NewErrType).params(block: T.proc.params(this: ErrType).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)])).returns(T.any(Result[OkType, T.type_parameter(:NewErrType)], Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)])) }
          
        
      
        

          

            
              1
            

            
              
            

                def or_else(&block); end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                sig { abstract.type_parameters(:NewOkType, :NewErrType).params(_t_new_err: T::Class[T.type_parameter(:NewErrType)], block: T.proc.params(this: ErrType).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)])).returns(T.any(Result[OkType, T.type_parameter(:NewErrType)], Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)])) }
          
        
      
        

          

            
              1
            

            
              
            

                def or_else_wt(_t_new_err, &block); end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                sig {
          
        
      
        

          

            
              1
            

            
              
            

                  abstract
          
        
      
        

          

            

            
              
            

                    .type_parameters(:NewOkType)
          
        
      
        

          

            

            
              
            

                    .params(
          
        
      
        

          

            

            
              
            

                      new_ok_inner: T.type_parameter(:NewOkType),
          
        
      
        

          

            

            
              
            

                      condition: T.proc.params(inner: ErrType).returns(T::Boolean)
          
        
      
        

          

            

            
              
            

                    )
          
        
      
        

          

            

            
              
            

                    .returns(
          
        
      
        

          

            

            
              
            

                      T.any(Result[T.type_parameter(:NewOkType), ErrType], Result[OkType, ErrType])
          
        
      
        

          

            

            
              
            

                    )
          
        
      
        

          

            

            
              
            

                }
          
        
      
        

          

            
              1
            

            
              
            

                def or_ok_if(new_ok_inner, &condition); end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                class << self
          
        
      
        

          

            
              1
            

            
              
            

                  extend T::Sig
          
        
      
        

          

            
              1
            

            
              
            

                  extend T::Generic
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  OkType = type_member
          
        
      
        

          

            
              1
            

            
              
            

                  ErrType = type_member
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { type_parameters(:T, :E).params(results: T::Enumerable[Result[T.type_parameter(:T), T.type_parameter(:E)]]).returns(Result[T::Enumerable[T.type_parameter(:T)], T::Enumerable[T.type_parameter(:E)]]) }
          
        
      
        

          

            
              1
            

            
              
            

                  def from_results(results)
          
        
      
        

          

            
              4
            

            
              
            

                    errs = results.filter(&:err?)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              4
            

            
              
            

                    if errs.empty?
          
        
      
        

          

            

            
              
                
                  then: 2
                
              
            

                      # This is safe as errs is empty.
          
        
      
        

          

            
              8
            

            
              
            

                      Result::Ok[T::Enumerable[T.type_parameter(:T)]].new(results.map { |r| T.cast(r, Result::Ok[T.type_parameter(:T)]).ok_inner })
          
        
      
        

          

            

            
              
            

                    else
          
        
      
        

          

            

            
              
                
                  else: 2
                
              
            

                      # This is safe as errs is results where err? is true
          
        
      
        

          

            
              6
            

            
              
            

                      Result::Err[T::Enumerable[T.type_parameter(:E)]].new(errs.map { |r| T.cast(r, Result::Err[T.type_parameter(:E)]).err_inner })
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { type_parameters(:OkType).params(inner: T.type_parameter(:OkType)).returns(Result::Ok[T.type_parameter(:OkType)]) }
          
        
      
        

          

            
              1
            

            
              
            

                  def ok(inner)
          
        
      
        

          

            
              4
            

            
              
            

                    Result::Ok[T.type_parameter(:OkType)].new(inner)
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  # @deprecated
          
        
      
        

          

            
              2
            

            
              
            

                  sig { type_parameters(:OkType, :ErrType).params(inner: T.type_parameter(:OkType), _t_err: T::Class[T.type_parameter(:ErrType)]).returns(Result::Ok[T.type_parameter(:OkType)]) }
          
        
      
        

          

            
              1
            

            
              
            

                  def ok_wt(inner, _t_err)
          
        
      
        

          

            
              13
            

            
              
            

                    Result::Ok[T.type_parameter(:OkType)].new(inner)
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { type_parameters(:ErrType).params(inner: T.type_parameter(:ErrType)).returns(Result::Err[T.type_parameter(:ErrType)]) }
          
        
      
        

          

            
              1
            

            
              
            

                  def err(inner)
          
        
      
        

          

            
              1
            

            
              
            

                    Result::Err[T.type_parameter(:ErrType)].new(inner)
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  # @deprecated
          
        
      
        

          

            
              2
            

            
              
            

                  sig { type_parameters(:OkType, :ErrType).params(_t_ok: T::Class[T.type_parameter(:OkType)], inner: T.type_parameter(:ErrType)).returns(Result::Err[T.type_parameter(:ErrType)]) }
          
        
      
        

          

            
              1
            

            
              
            

                  def err_wt(_t_ok, inner)
          
        
      
        

          

            
              10
            

            
              
            

                    Result::Err[T.type_parameter(:ErrType)].new(inner)
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  sig {
          
        
      
        

          

            
              1
            

            
              
            

                    type_parameters(:O, :E)
          
        
      
        

          

            

            
              
            

                      .params(
          
        
      
        

          

            

            
              
            

                        _t_ok: T::Class[T.type_parameter(:O)],
          
        
      
        

          

            

            
              
            

                        _t_err: T::Class[T.type_parameter(:E)],
          
        
      
        

          

            

            
              
            

                        block: T.proc.params(
          
        
      
        

          

            

            
              
            

                          do_block: CollectingContext[T.type_parameter(:O), T.type_parameter(:E)]
          
        
      
        

          

            

            
              
            

                        ).returns(Mangrove::Result[T.type_parameter(:O), T.type_parameter(:E)])
          
        
      
        

          

            

            
              
            

                      )
          
        
      
        

          

            

            
              
            

                      .returns(Mangrove::Result[T.type_parameter(:O), T.type_parameter(:E)])
          
        
      
        

          

            

            
              
            

                  }
          
        
      
        

          

            
              1
            

            
              
            

                  def collecting(_t_ok, _t_err, &block)
          
        
      
        

          

            
              5
            

            
              
            

                    catch(:__mangrove_result_collecting_context_return) {
          
        
      
        

          

            
              5
            

            
              
            

                      block.call(CollectingContext[T.type_parameter(:O), T.type_parameter(:E)].new)
          
        
      
        

          

            

            
              
            

                    }
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                class CollectingContext
          
        
      
        

          

            
              1
            

            
              
            

                  extend T::Sig
          
        
      
        

          

            
              1
            

            
              
            

                  extend T::Generic
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  O = type_member
          
        
      
        

          

            
              1
            

            
              
            

                  E = type_member
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { type_parameters(:T).params(result: Mangrove::Result[T.type_parameter(:T), E]).returns(T.type_parameter(:T)) }
          
        
      
        

          

            
              1
            

            
              
            

                  def try!(result)
          
        
      
        

          

            
              10
            

            
              
            

                    case result
          
        
      
        

          

            

            
              
                
                  when: 7
                
              
            

                    when Mangrove::Result::Ok
          
        
      
        

          

            
              7
            

            
              
            

                      result.ok_inner
          
        
      
        

          

            

            
              
                
                  when: 3
                
              
            

                    when Mangrove::Result::Err
          
        
      
        

          

            
              3
            

            
              
            

                      throw :__mangrove_result_collecting_context_return, result
          
        
      
        

          

            

            
              
                
                  else: 0
                
              
            

                    else
          
        
      
        

          

            

            
              
            

                      T.absurd(result)
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                class Ok
          
        
      
        

          

            
              1
            

            
              
            

                  extend T::Sig
          
        
      
        

          

            
              1
            

            
              
            

                  extend T::Generic
          
        
      
        

          

            
              1
            

            
              
            

                  extend T::Helpers
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  include Result
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  OkType = type_member
          
        
      
        

          

            
              1
            

            
              
            

                  ErrType = type_member { { fixed: T.noreturn } }
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { params(inner: OkType).void }
          
        
      
        

          

            
              1
            

            
              
            

                  def initialize(inner)
          
        
      
        

          

            
              165
            

            
              
            

                    @inner = inner
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.params(other: BasicObject).returns(T::Boolean) }
          
        
      
        

          

            
              1
            

            
              
            

                  def ==(other)
          
        
      
        

          

            
              50
            

            
              
            

                    case other
          
        
      
        

          

            

            
              
                
                  when: 50
                
              
            

                    when Result::Ok
          
        
      
        

          

            
              50
            

            
              
            

                      other.instance_variable_get(:@inner) == @inner
          
        
      
        

          

            

            
              
                
                  when: 0
                
              
            

                    when Result::Err
          
        
      
        

          

            

            
              
            

                      false
          
        
      
        

          

            

            
              
            

                    else # rubocop:disable Lint/DuplicateBranch
          
        
      
        

          

            

            
              
                
                  else: 0
                
              
            

                      # Because == is defined on BasicObject, we can't be sure that `other` is an Option
          
        
      
        

          

            

            
              
            

                      false
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { returns(OkType) }
          
        
      
        

          

            
              1
            

            
              
            

                  def ok_inner
          
        
      
        

          

            
              20
            

            
              
            

                    @inner
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.returns(OkType) }
          
        
      
        

          

            
              1
            

            
              
            

                  def unwrap!
          
        
      
        

          

            
              6
            

            
              
            

                    @inner
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.params(_exception: Exception).returns(OkType) }
          
        
      
        

          

            
              1
            

            
              
            

                  def unwrap_or_raise!(_exception)
          
        
      
        

          

            
              2
            

            
              
            

                    @inner
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.params(_block: T.proc.params(err: ErrType).returns(Exception)).returns(OkType) }
          
        
      
        

          

            
              1
            

            
              
            

                  def unwrap_or_raise_with!(&_block)
          
        
      
        

          

            
              2
            

            
              
            

                    @inner
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.returns(OkType) }
          
        
      
        

          

            
              1
            

            
              
            

                  def unwrap_or_raise_inner!
          
        
      
        

          

            
              2
            

            
              
            

                    @inner
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.params(_ctx: Result::CollectingContext[T.untyped, ErrType]).returns(OkType) }
          
        
      
        

          

            
              1
            

            
              
            

                  def unwrap_in(_ctx)
          
        
      
        

          

            
              5
            

            
              
            

                    @inner
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.params(_message: String).returns(OkType) }
          
        
      
        

          

            
              1
            

            
              
            

                  def expect!(_message)
          
        
      
        

          

            
              2
            

            
              
            

                    @inner
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.type_parameters(:E).params(_block: T.proc.params(err: ErrType).returns(T.type_parameter(:E))).returns(OkType) }
          
        
      
        

          

            
              1
            

            
              
            

                  def expect_with!(&_block)
          
        
      
        

          

            
              2
            

            
              
            

                    @inner
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  # @deprecated Use #is_a?(Result::Ok) instead to enable Sorbet to define types statically.
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.returns(T::Boolean) }
          
        
      
        

          

            
              1
            

            
              
            

                  def ok? = true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  # @deprecated Use #is_a?(Result::Err) instead to enable Sorbet to define types statically.
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.returns(T::Boolean) }
          
        
      
        

          

            
              1
            

            
              
            

                  def err? = false
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.type_parameters(:NewOkType, :NewErrType).params(block: T.proc.params(this: Result[OkType, ErrType]).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)])).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]) }
          
        
      
        

          

            
              1
            

            
              
            

                  def map(&block)
          
        
      
        

          

            
              2
            

            
              
            

                    block.call(self)
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.type_parameters(:NewOkType, :NewErrType).params(_t_new_ok: T::Class[T.type_parameter(:NewOkType)], _t_new_err: T::Class[T.type_parameter(:NewErrType)], block: T.proc.params(this: Result[OkType, ErrType]).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)])).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]) }
          
        
      
        

          

            
              1
            

            
              
            

                  def map_wt(_t_new_ok, _t_new_err, &block)
          
        
      
        

          

            
              2
            

            
              
            

                    block.call(self)
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.type_parameters(:NewOkType).params(block: T.proc.params(this: OkType).returns(T.type_parameter(:NewOkType))).returns(Result[T.type_parameter(:NewOkType), ErrType]) }
          
        
      
        

          

            
              1
            

            
              
            

                  def map_ok(&block)
          
        
      
        

          

            
              4
            

            
              
            

                    Result::Ok[T.type_parameter(:NewOkType)].new(block.call(@inner))
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  # Because sorbet does not deduct types from return values well. This method takes a type of new inner values.
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.type_parameters(:NewOkType).params(_t_new_ok: T::Class[T.type_parameter(:NewOkType)], block: T.proc.params(this: OkType).returns(T.type_parameter(:NewOkType))).returns(Result[T.type_parameter(:NewOkType), ErrType]) }
          
        
      
        

          

            
              1
            

            
              
            

                  def map_ok_wt(_t_new_ok, &block)
          
        
      
        

          

            
              2
            

            
              
            

                    Result::Ok[T.type_parameter(:NewOkType)].new(block.call(@inner))
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.type_parameters(:NewErrType).params(_block: T.proc.params(this: ErrType).returns(T.type_parameter(:NewErrType))).returns(Result[OkType, T.type_parameter(:NewErrType)]) }
          
        
      
        

          

            
              1
            

            
              
            

                  def map_err(&_block)
          
        
      
        

          

            
              2
            

            
              
            

                    self
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  # Because sorbet does not deduct types from return values well. This method takes a type of new inner values.
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.type_parameters(:NewErrType).params(_t_new_err: T::Class[T.type_parameter(:NewErrType)], _block: T.proc.params(this: ErrType).returns(T.type_parameter(:NewErrType))).returns(Result[OkType, T.type_parameter(:NewErrType)]) }
          
        
      
        

          

            
              1
            

            
              
            

                  def map_err_wt(_t_new_err, &_block)
          
        
      
        

          

            
              7
            

            
              
            

                    self
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.params(block: T.proc.params(this: OkType).void).returns(Result[OkType, ErrType]) }
          
        
      
        

          

            
              1
            

            
              
            

                  def tap_ok(&block)
          
        
      
        

          

            
              2
            

            
              
            

                    block.call(@inner)
          
        
      
        

          

            
              2
            

            
              
            

                    self
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.params(_block: T.proc.params(this: ErrType).void).returns(Result[OkType, ErrType]) }
          
        
      
        

          

            
              1
            

            
              
            

                  def tap_err(&_block)
          
        
      
        

          

            
              2
            

            
              
            

                    self
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.type_parameters(:NewOkType, :NewErrType).params(other: Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]) }
          
        
      
        

          

            
              1
            

            
              
            

                  def and(other)
          
        
      
        

          

            
              2
            

            
              
            

                    other
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.type_parameters(:NewOkType, :NewErrType).params(block: T.proc.params(this: OkType).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)])).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]) }
          
        
      
        

          

            
              1
            

            
              
            

                  def and_then(&block)
          
        
      
        

          

            
              2
            

            
              
            

                    block.call(@inner)
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  # @deprecated
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.type_parameters(:NewOkType, :NewErrType).params(_t_new_ok: T::Class[T.type_parameter(:NewOkType)], block: T.proc.params(this: OkType).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)])).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]) }
          
        
      
        

          

            
              1
            

            
              
            

                  def and_then_wt(_t_new_ok, &block)
          
        
      
        

          

            
              8
            

            
              
            

                    block.call(@inner)
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  sig {
          
        
      
        

          

            
              1
            

            
              
            

                    override
          
        
      
        

          

            

            
              
            

                      .type_parameters(:NewErrType)
          
        
      
        

          

            

            
              
            

                      .params(
          
        
      
        

          

            

            
              
            

                        new_err_inner: T.type_parameter(:NewErrType),
          
        
      
        

          

            

            
              
            

                        condition: T.proc.params(inner: OkType).returns(T::Boolean)
          
        
      
        

          

            

            
              
            

                      )
          
        
      
        

          

            

            
              
            

                      .returns(
          
        
      
        

          

            

            
              
            

                        Result[OkType, T.type_parameter(:NewErrType)]
          
        
      
        

          

            

            
              
            

                      )
          
        
      
        

          

            

            
              
            

                  }
          
        
      
        

          

            
              1
            

            
              
            

                  def and_err_if(new_err_inner, &condition)
          
        
      
        

          

            
              4
            

            
              
                
                  then: 2
                
              
            

                    if condition.call(@inner)
          
        
      
        

          

            
              2
            

            
              
            

                      Result::Err[T.type_parameter(:NewErrType)].new(new_err_inner)
          
        
      
        

          

            

            
              
                
                  else: 2
                
              
            

                    else
          
        
      
        

          

            
              2
            

            
              
            

                      self
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.type_parameters(:NewOkType, :NewErrType).params(_other: Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]).returns(Result[OkType, T.type_parameter(:NewErrType)]) }
          
        
      
        

          

            
              1
            

            
              
            

                  def or(_other)
          
        
      
        

          

            
              2
            

            
              
            

                    self
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.type_parameters(:NewOkType, :NewErrType).params(_block: T.proc.params(this: ErrType).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)])).returns(Result[OkType, T.type_parameter(:NewErrType)]) }
          
        
      
        

          

            
              1
            

            
              
            

                  def or_else(&_block)
          
        
      
        

          

            
              2
            

            
              
            

                    self
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  # @deprecated
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.type_parameters(:NewOkType, :NewErrType).params(_t_new_err: T::Class[T.type_parameter(:NewErrType)], _block: T.proc.params(this: ErrType).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)])).returns(Result[OkType, T.type_parameter(:NewErrType)]) }
          
        
      
        

          

            
              1
            

            
              
            

                  def or_else_wt(_t_new_err, &_block)
          
        
      
        

          

            
              2
            

            
              
            

                    self
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  sig {
          
        
      
        

          

            
              1
            

            
              
            

                    override
          
        
      
        

          

            

            
              
            

                      .type_parameters(:NewOkType)
          
        
      
        

          

            

            
              
            

                      .params(
          
        
      
        

          

            

            
              
            

                        _new_ok_inner: T.type_parameter(:NewOkType),
          
        
      
        

          

            

            
              
            

                        _condition: T.proc.params(inner: ErrType).returns(T::Boolean)
          
        
      
        

          

            

            
              
            

                      )
          
        
      
        

          

            

            
              
            

                      .returns(
          
        
      
        

          

            

            
              
            

                        Result[OkType, ErrType]
          
        
      
        

          

            

            
              
            

                      )
          
        
      
        

          

            

            
              
            

                  }
          
        
      
        

          

            
              1
            

            
              
            

                  def or_ok_if(_new_ok_inner, &_condition)
          
        
      
        

          

            
              4
            

            
              
            

                    self
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { returns(T::Array[OkType]) }
          
        
      
        

          

            
              1
            

            
              
            

                  def deconstruct
          
        
      
        

          

            
              2
            

            
              
            

                    [@inner]
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { params(_keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, OkType]) }
          
        
      
        

          

            
              1
            

            
              
            

                  def deconstruct_keys(_keys)
          
        
      
        

          

            
              3
            

            
              
            

                    { inner: @inner }
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { returns(String) }
          
        
      
        

          

            
              1
            

            
              
            

                  def to_s
          
        
      
        

          

            
              1
            

            
              
            

                    "#{super}: inner=`#{@inner}`"
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                class Err
          
        
      
        

          

            
              1
            

            
              
            

                  extend T::Sig
          
        
      
        

          

            
              1
            

            
              
            

                  extend T::Generic
          
        
      
        

          

            
              1
            

            
              
            

                  extend T::Helpers
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  include Result
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  OkType = type_member { { fixed: T.noreturn } }
          
        
      
        

          

            
              1
            

            
              
            

                  ErrType = type_member
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { params(inner: ErrType).void }
          
        
      
        

          

            
              1
            

            
              
            

                  def initialize(inner)
          
        
      
        

          

            
              134
            

            
              
            

                    @inner = inner
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.params(other: BasicObject).returns(T::Boolean) }
          
        
      
        

          

            
              1
            

            
              
            

                  def ==(other)
          
        
      
        

          

            
              50
            

            
              
            

                    case other
          
        
      
        

          

            

            
              
                
                  when: 0
                
              
            

                    when Result::Ok
          
        
      
        

          

            

            
              
            

                      false
          
        
      
        

          

            

            
              
                
                  when: 49
                
              
            

                    when Result::Err
          
        
      
        

          

            
              49
            

            
              
            

                      other.instance_variable_get(:@inner) == @inner
          
        
      
        

          

            

            
              
            

                    else # rubocop:disable Lint/DuplicateBranch
          
        
      
        

          

            

            
              
                
                  else: 1
                
              
            

                      # Because == is defined on BasicObject, we can't be sure that `other` is an Option
          
        
      
        

          

            
              1
            

            
              
            

                      false
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { returns(ErrType) }
          
        
      
        

          

            
              1
            

            
              
            

                  def err_inner
          
        
      
        

          

            
              10
            

            
              
            

                    @inner
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.returns(OkType) }
          
        
      
        

          

            
              1
            

            
              
            

                  def unwrap!
          
        
      
        

          

            
              2
            

            
              
            

                    raise Result::ControlSignal, @inner
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.params(exception: Exception).returns(OkType) }
          
        
      
        

          

            
              1
            

            
              
            

                  def unwrap_or_raise!(exception)
          
        
      
        

          

            
              1
            

            
              
            

                    raise exception
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.params(block: T.proc.params(err: ErrType).returns(Exception)).returns(OkType) }
          
        
      
        

          

            
              1
            

            
              
            

                  def unwrap_or_raise_with!(&block)
          
        
      
        

          

            
              1
            

            
              
            

                    raise block.call(@inner)
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.returns(OkType) }
          
        
      
        

          

            
              1
            

            
              
            

                  def unwrap_or_raise_inner!
          
        
      
        

          

            
              1
            

            
              
            

                    raise T.unsafe(@inner)
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.params(_ctx: Result::CollectingContext[T.untyped, ErrType]).returns(T.noreturn) }
          
        
      
        

          

            
              1
            

            
              
            

                  def unwrap_in(_ctx)
          
        
      
        

          

            
              2
            

            
              
            

                    throw :__mangrove_result_collecting_context_return, self
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.params(message: String).returns(OkType) }
          
        
      
        

          

            
              1
            

            
              
            

                  def expect!(message)
          
        
      
        

          

            
              1
            

            
              
            

                    raise Result::ControlSignal, message
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.type_parameters(:E).params(block: T.proc.params(err: ErrType).returns(T.type_parameter(:E))).returns(OkType) }
          
        
      
        

          

            
              1
            

            
              
            

                  def expect_with!(&block)
          
        
      
        

          

            
              1
            

            
              
            

                    raise Result::ControlSignal, block.call(@inner)
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  # @deprecated Use #is_a?(Result::Ok) instead to enable Sorbet to define types statically.
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.returns(T::Boolean) }
          
        
      
        

          

            
              1
            

            
              
            

                  def ok? = false
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  # @deprecated Use #is_a?(Result::Err) instead to enable Sorbet to define types statically.
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.returns(T::Boolean) }
          
        
      
        

          

            
              1
            

            
              
            

                  def err? = true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.type_parameters(:NewOkType, :NewErrType).params(block: T.proc.params(this: Result[OkType, ErrType]).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)])).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]) }
          
        
      
        

          

            
              1
            

            
              
            

                  def map(&block)
          
        
      
        

          

            
              2
            

            
              
            

                    block.call(self)
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.type_parameters(:NewOkType, :NewErrType).params(_t_new_ok: T::Class[T.type_parameter(:NewOkType)], _t_new_err: T::Class[T.type_parameter(:NewErrType)], block: T.proc.params(this: Result[OkType, ErrType]).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)])).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]) }
          
        
      
        

          

            
              1
            

            
              
            

                  def map_wt(_t_new_ok, _t_new_err, &block)
          
        
      
        

          

            
              2
            

            
              
            

                    block.call(self)
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.type_parameters(:NewOkType).params(_block: T.proc.params(this: OkType).returns(T.type_parameter(:NewOkType))).returns(Result[T.type_parameter(:NewOkType), ErrType]) }
          
        
      
        

          

            
              1
            

            
              
            

                  def map_ok(&_block)
          
        
      
        

          

            
              4
            

            
              
            

                    self
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.type_parameters(:NewOkType).params(_t_new_ok: T::Class[T.type_parameter(:NewOkType)], _block: T.proc.params(this: OkType).returns(T.type_parameter(:NewOkType))).returns(Result[T.type_parameter(:NewOkType), ErrType]) }
          
        
      
        

          

            
              1
            

            
              
            

                  def map_ok_wt(_t_new_ok, &_block)
          
        
      
        

          

            
              2
            

            
              
            

                    self
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.type_parameters(:NewErrType).params(block: T.proc.params(this: ErrType).returns(T.type_parameter(:NewErrType))).returns(Result[OkType, T.type_parameter(:NewErrType)]) }
          
        
      
        

          

            
              1
            

            
              
            

                  def map_err(&block)
          
        
      
        

          

            
              2
            

            
              
            

                    Result::Err[T.type_parameter(:NewErrType)].new(block.call(@inner))
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.type_parameters(:NewErrType).params(_t_new_err: T::Class[T.type_parameter(:NewErrType)], block: T.proc.params(this: ErrType).returns(T.type_parameter(:NewErrType))).returns(Result[OkType, T.type_parameter(:NewErrType)]) }
          
        
      
        

          

            
              1
            

            
              
            

                  def map_err_wt(_t_new_err, &block)
          
        
      
        

          

            
              4
            

            
              
            

                    Result::Err[T.type_parameter(:NewErrType)].new(block.call(@inner))
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.params(_block: T.proc.params(this: OkType).void).returns(Result[OkType, ErrType]) }
          
        
      
        

          

            
              1
            

            
              
            

                  def tap_ok(&_block)
          
        
      
        

          

            
              2
            

            
              
            

                    self
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.params(block: T.proc.params(this: ErrType).void).returns(Result[OkType, ErrType]) }
          
        
      
        

          

            
              1
            

            
              
            

                  def tap_err(&block)
          
        
      
        

          

            
              2
            

            
              
            

                    block.call(@inner)
          
        
      
        

          

            
              2
            

            
              
            

                    self
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.type_parameters(:NewOkType, :NewErrType).params(_other: Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]).returns(Result[T.type_parameter(:NewOkType), ErrType]) }
          
        
      
        

          

            
              1
            

            
              
            

                  def and(_other)
          
        
      
        

          

            
              1
            

            
              
            

                    self
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.type_parameters(:NewOkType, :NewErrType).params(_block: T.proc.params(this: OkType).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)])).returns(Result[T.type_parameter(:NewOkType), ErrType]) }
          
        
      
        

          

            
              1
            

            
              
            

                  def and_then(&_block)
          
        
      
        

          

            
              2
            

            
              
            

                    self
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  # @deprecated
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.type_parameters(:NewOkType, :NewErrType).params(_t_new_ok: T::Class[T.type_parameter(:NewOkType)], _block: T.proc.params(this: OkType).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)])).returns(Result[T.type_parameter(:NewOkType), ErrType]) }
          
        
      
        

          

            
              1
            

            
              
            

                  def and_then_wt(_t_new_ok, &_block)
          
        
      
        

          

            
              3
            

            
              
            

                    self
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  sig {
          
        
      
        

          

            
              1
            

            
              
            

                    override
          
        
      
        

          

            

            
              
            

                      .type_parameters(:NewErrType)
          
        
      
        

          

            

            
              
            

                      .params(
          
        
      
        

          

            

            
              
            

                        _new_err_inner: T.type_parameter(:NewErrType),
          
        
      
        

          

            

            
              
            

                        _condition: T.proc.params(inner: OkType).returns(T::Boolean)
          
        
      
        

          

            

            
              
            

                      )
          
        
      
        

          

            

            
              
            

                      .returns(
          
        
      
        

          

            

            
              
            

                        Result[OkType, ErrType]
          
        
      
        

          

            

            
              
            

                      )
          
        
      
        

          

            

            
              
            

                  }
          
        
      
        

          

            
              1
            

            
              
            

                  def and_err_if(_new_err_inner, &_condition)
          
        
      
        

          

            
              4
            

            
              
            

                    self
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.type_parameters(:NewOkType, :NewErrType).params(other: Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]) }
          
        
      
        

          

            
              1
            

            
              
            

                  def or(other)
          
        
      
        

          

            
              2
            

            
              
            

                    other
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.type_parameters(:NewOkType, :NewErrType).params(block: T.proc.params(this: ErrType).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)])).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]) }
          
        
      
        

          

            
              1
            

            
              
            

                  def or_else(&block)
          
        
      
        

          

            
              2
            

            
              
            

                    block.call(@inner)
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.type_parameters(:NewOkType, :NewErrType).params(_t_new_err: T::Class[T.type_parameter(:NewErrType)], block: T.proc.params(this: ErrType).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)])).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]) }
          
        
      
        

          

            
              1
            

            
              
            

                  def or_else_wt(_t_new_err, &block)
          
        
      
        

          

            
              2
            

            
              
            

                    block.call(@inner)
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  sig {
          
        
      
        

          

            
              1
            

            
              
            

                    override
          
        
      
        

          

            

            
              
            

                      .type_parameters(:NewOkType)
          
        
      
        

          

            

            
              
            

                      .params(
          
        
      
        

          

            

            
              
            

                        new_ok_inner: T.type_parameter(:NewOkType),
          
        
      
        

          

            

            
              
            

                        condition: T.proc.params(inner: ErrType).returns(T::Boolean)
          
        
      
        

          

            

            
              
            

                      )
          
        
      
        

          

            

            
              
            

                      .returns(
          
        
      
        

          

            

            
              
            

                        Result[T.type_parameter(:NewOkType), ErrType]
          
        
      
        

          

            

            
              
            

                      )
          
        
      
        

          

            

            
              
            

                  }
          
        
      
        

          

            
              1
            

            
              
            

                  def or_ok_if(new_ok_inner, &condition)
          
        
      
        

          

            
              4
            

            
              
                
                  then: 2
                
              
            

                    if condition.call(@inner)
          
        
      
        

          

            
              2
            

            
              
            

                      Result::Ok[T.type_parameter(:NewOkType)].new(new_ok_inner)
          
        
      
        

          

            

            
              
                
                  else: 2
                
              
            

                    else
          
        
      
        

          

            
              2
            

            
              
            

                      self
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { returns(T::Array[ErrType]) }
          
        
      
        

          

            
              1
            

            
              
            

                  def deconstruct
          
        
      
        

          

            
              2
            

            
              
            

                    [@inner]
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { params(_keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ErrType]) }
          
        
      
        

          

            
              1
            

            
              
            

                  def deconstruct_keys(_keys)
          
        
      
        

          

            
              3
            

            
              
            

                    { inner: @inner }
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { returns(String) }
          
        
      
        

          

            
              1
            

            
              
            

                  def to_s
          
        
      
        

          

            
              1
            

            
              
            

                    "#{super}: inner=`#{@inner}`"
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # typed: true
          
        
      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Mangrove
          
        
      
        

          

            
              1
            

            
              
            

              module Result
          
        
      
        

          

            
              1
            

            
              
            

                class Collector
          
        
      
        

          

            
              1
            

            
              
            

                  extend T::Sig
          
        
      
        

          

            
              1
            

            
              
            

                  extend T::Generic
          
        
      
        

          

            
              1
            

            
              
            

                  extend T::Helpers
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  OkType = type_member
          
        
      
        

          

            
              1
            

            
              
            

                  ErrType = type_member
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { params(block: T.proc.params(ctx: CollectingContext[OkType, ErrType]).returns(Result[OkType, ErrType])).returns(Result[OkType, ErrType]) }
          
        
      
        

          

            
              1
            

            
              
            

                  def collecting(&block)
          
        
      
        

          

            
              1
            

            
              
            

                    catch(:__mangrove_result_collecting_context_return) {
          
        
      
        

          

            
              1
            

            
              
            

                      block.call(CollectingContext[OkType, ErrType].new)
          
        
      
        

          

            

            
              
            

                    }
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # typed: strict
          
        
      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "mangrove/control_flow/control_signal"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Mangrove
          
        
      
        

          

            
              1
            

            
              
            

              module Result
          
        
      
        

          

            
              1
            

            
              
            

                class ControlSignal < StandardError
          
        
      
        

          

            
              1
            

            
              
            

                  extend T::Sig
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  include Mangrove::ControlFlow::ControlSignal
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { params(inner_value: T.untyped).void }
          
        
      
        

          

            
              1
            

            
              
            

                  def initialize(inner_value)
          
        
      
        

          

            
              6
            

            
              
            

                    @inner_value = inner_value
          
        
      
        

          

            
              6
            

            
              
            

                    super
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.params(other: BasicObject).returns(T::Boolean) }
          
        
      
        

          

            
              1
            

            
              
            

                  def ==(other)
          
        
      
        

          

            
              2
            

            
              
            

                    case other
          
        
      
        

          

            

            
              
                
                  when: 2
                
              
            

                    when ControlSignal
          
        
      
        

          

            
              2
            

            
              
            

                      other.inner_value == inner_value
          
        
      
        

          

            

            
              
                
                  else: 0
                
              
            

                    else
          
        
      
        

          

            

            
              
            

                      false
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.returns(T.untyped) }
          
        
      
        

          

            
              1
            

            
              
            

                  attr_reader :inner_value
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # typed: true
          
        
      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Mangrove
          
        
      
        

          

            
              1
            

            
              
            

              module Result
          
        
      
        

          

            
              1
            

            
              
            

                module Ext
          
        
      
        

          

            
              1
            

            
              
            

                  extend T::Sig
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def in_ok
          
        
      
        

          

            
              5
            

            
              
            

                    Mangrove::Result::Ok.new(self)
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def in_err
          
        
      
        

          

            
              5
            

            
              
            

                    Mangrove::Result::Err.new(self)
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # typed: true
          
        
      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Mangrove
          
        
      
        

          

            
              1
            

            
              
            

              module TryFromExt
          
        
      
        

          

            
              1
            

            
              
            

                extend T::Sig
          
        
      
        

          

            
              1
            

            
              
            

                extend T::Helpers
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                include Kernel
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                sig {
          
        
      
        

          

            
              1
            

            
              
            

                  type_parameters(:I, :O, :E)
          
        
      
        

          

            

            
              
            

                    .params(
          
        
      
        

          

            

            
              
            

                      from: T::Class[T.type_parameter(:I)],
          
        
      
        

          

            

            
              
            

                      to: T::Class[T.type_parameter(:O)],
          
        
      
        

          

            

            
              
            

                      err: T::Class[T.type_parameter(:E)],
          
        
      
        

          

            

            
              
            

                      block: T.proc.params(arg: T.type_parameter(:I)).returns(Mangrove::Result[T.type_parameter(:O), T.type_parameter(:E)])
          
        
      
        

          

            

            
              
            

                    ).void
          
        
      
        

          

            

            
              
            

                }
          
        
      
        

          

            

            
              
            

                # rubocop:disable Lint/UnusedMethodArgument
          
        
      
        

          

            
              1
            

            
              
            

                def try_convert_from(from:, to:, err:, &block)
          
        
      
        

          

            
              9
            

            
              
            

                  T.bind(self, T::Class[T.type_parameter(:O)])
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              9
            

            
              
            

                  vars = from.instance_variable_get(:@convertable_to) || {}
          
        
      
        

          

            
              9
            

            
              
            

                  vars[self] = block
          
        
      
        

          

            
              9
            

            
              
            

                  from.instance_variable_set(:@convertable_to, vars)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              9
            

            
              
            

                  @convertable_from ||= {}
          
        
      
        

          

            
              9
            

            
              
            

                  @convertable_from[from] = [err, block]
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              9
            

            
              
            

                  into_t = T.cast(self, Class)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              9
            

            
              
            

                  from.define_method("try_into_#{T.must_because(into_t.name) { "name is required" }.gsub(/::|([A-Z]+)([A-Z][a-z])/, '\1_\2').gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase}") do
          
        
      
        

          

            
              11
            

            
              
                
                  then: 5
                
              
                
                  else: 1
                
              
            

                    proc = T.unsafe(self).class.ancestors.lazy.map { |klass| klass.instance_variable_get(:@convertable_to)&.[](into_t) }.find(&:itself)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              5
            

            
              
            

                    proc.call(self)
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

                # rubocop:enable Lint/UnusedMethodArgument
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # typed: strict
          
        
      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "mangrove"
          
        
      
        

          

            
              1
            

            
              
            

            require "tapioca/dsl"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            # @api private
          
        
      
        

          

            
              1
            

            
              
            

            module Tapioca
          
        
      
        

          

            
              1
            

            
              
            

              module Compilers
          
        
      
        

          

            
              1
            

            
              
            

                class MangroveEnum < Tapioca::Dsl::Compiler
          
        
      
        

          

            
              1
            

            
              
            

                  extend T::Sig
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  ConstantType = type_member { { fixed: T.class_of(::Mangrove::Enum) } }
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.returns(T::Enumerable[Module]) }
          
        
      
        

          

            
              1
            

            
              
            

                  def self.gather_constants
          
        
      
        

          

            
              2660
            

            
              
            

                    all_classes.select { |c| c.singleton_class < ::Mangrove::Enum && T::AbstractUtils.abstract_module?(c) }
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.void }
          
        
      
        

          

            
              1
            

            
              
            

                  def decorate
          
        
      
        

          

            
              1
            

            
              
            

                    root.create_path(constant) { |constant_type|
          
        
      
        

          

            
              1
            

            
              
            

                      constant_type.nodes.append(
          
        
      
        

          

            

            
              
            

                        RBI::Helper.new("abstract"),
          
        
      
        

          

            

            
              
            

                        RBI::Helper.new("sealed")
          
        
      
        

          

            

            
              
            

                      )
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                      variants = constant
          
        
      
        

          

            

            
              
            

                        .constants
          
        
      
        

          

            

            
              
            

                        .filter_map { |variant_name|
          
        
      
        

          

            
              1
            

            
              
            

                          maybe_variant = constant.const_get(variant_name, false)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
                
                  then: 1
                
              
                
                  else: 0
                
              
            

                          if maybe_variant.instance_variable_defined?(:@__mangrove__enum_inner_type)
          
        
      
        

          

            
              1
            

            
              
            

                            maybe_variant
          
        
      
        

          

            

            
              
            

                          end
          
        
      
        

          

            

            
              
            

                        }
          
        
      
        

          

            
              1
            

            
              
            

                        .sort_by { |variant| variant.name.to_s }
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                      inner_types = variants.map { |variant|
          
        
      
        

          

            
              1
            

            
              
            

                        inner_type = runtime_type_to_type_name(variant.instance_variable_get(:@__mangrove__enum_inner_type))
          
        
      
        

          

            
              1
            

            
              
            

                        constant_type.create_class(variant.name.gsub(/.*::/, ""), superclass_name: constant_type.fully_qualified_name) { |variant_type|
          
        
      
        

          

            
              1
            

            
              
            

                          variant_type.create_method("initialize", parameters: [create_param("inner", type: inner_type)], return_type: "void")
          
        
      
        

          

            
              1
            

            
              
            

                          variant_type.create_method("serialize", parameters: [create_kw_opt_param("inner_serialization_methods", type: "T.nilable(T::Array[Symbol])", default: "[:serialize, :to_h]")], return_type: "T::Hash[Symbol, T.untyped]")
          
        
      
        

          

            
              1
            

            
              
            

                          variant_type.create_method("inner", return_type: inner_type)
          
        
      
        

          

            
              1
            

            
              
            

                          variant_type.create_method("as_super", return_type: constant.name.to_s)
          
        
      
        

          

            
              1
            

            
              
            

                          variant_type.sort_nodes!
          
        
      
        

          

            

            
              
            

                        }
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                        inner_type
          
        
      
        

          

            

            
              
            

                      }
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
                
                  then: 1
                
              
            

                      return_type = if inner_types.size == 1
          
        
      
        

          

            
              1
            

            
              
            

                                      T.must(inner_types.first)
          
        
      
        

          

            

            
              
                
                  else: 0
                
              
            

                                    else
          
        
      
        

          

            

            
              
            

                                      "T.any(#{inner_types.join(", ")})"
          
        
      
        

          

            

            
              
            

                                    end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                      constant_type.create_method("inner", return_type:)
          
        
      
        

          

            
              1
            

            
              
            

                      constant_type.create_method("serialize", parameters: [create_kw_opt_param("inner_serialization_methods", type: "T.nilable(T::Array[Symbol])", default: "[:serialize, :to_h]")], return_type: "T::Hash[Symbol, T.untyped]")
          
        
      
        

          

            
              1
            

            
              
            

                      constant_type.create_method("deserialize", parameters: [create_param("hash", type: "T::Hash[T.any(Symbol, String), T.untyped]")], return_type: constant.name, class_method: true)
          
        
      
        

          

            
              1
            

            
              
            

                      constant_type.create_method("as_super", return_type: constant.name.to_s)
          
        
      
        

          

            
              1
            

            
              
            

                      constant_type.sort_nodes!
          
        
      
        

          

            

            
              
            

                    }
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  private
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { params(runtime_type: T.untyped).returns(String) }
          
        
      
        

          

            
              1
            

            
              
            

                  def runtime_type_to_type_name(runtime_type)
          
        
      
        

          

            
              1
            

            
              
                
                  then: 0
                
              
            

                    if runtime_type.is_a?(Array)
          
        
      
        

          

            

            
              
            

                      content = runtime_type.map { |inner|
          
        
      
        

          

            

            
              
            

                        runtime_type_to_type_name(inner)
          
        
      
        

          

            

            
              
            

                      }.join(", ")
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
                
                  else: 1
                
              
            

                      "[#{content}]"
          
        
      
        

          

            
              1
            

            
              
                
                  then: 0
                
              
            

                    elsif runtime_type.is_a?(Hash)
          
        
      
        

          

            

            
              
            

                      content = runtime_type.map { |k, v|
          
        
      
        

          

            

            
              
                
                  else: 0
                
              
                
                  then: 0
                
              
            

                        unless k.is_a?(Symbol) || k.is_a?(String)
          
        
      
        

          

            

            
              
            

                          raise "shape key must be Symbol or String"
          
        
      
        

          

            

            
              
            

                        end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                        "#{k}: #{runtime_type_to_type_name(v)}"
          
        
      
        

          

            

            
              
            

                      }.join(", ")
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                      "{ #{content} }"
          
        
      
        

          

            

            
              
                
                  else: 1
                
              
            

                    else
          
        
      
        

          

            
              1
            

            
              
            

                      runtime_type.to_s
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # typed: strict
          
        
      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "mangrove/result/ext"
          
        
      
        

          

            
              1
            

            
              
            

            require "tapioca/dsl"
          
        
      
        

          

            
              1
            

            
              
            

            require "sorbet-runtime"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Tapioca
          
        
      
        

          

            
              1
            

            
              
            

              module Compilers
          
        
      
        

          

            
              1
            

            
              
            

                class MangroveResultExt < Tapioca::Dsl::Compiler
          
        
      
        

          

            
              1
            

            
              
            

                  extend T::Sig
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  ConstantType = type_member { { fixed: T.class_of(Mangrove::Result::Ext) } }
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.returns(T::Enumerable[Module]) }
          
        
      
        

          

            
              1
            

            
              
            

                  def self.gather_constants
          
        
      
        

          

            
              4527
            

            
              
            

                    all_classes.select { |c| c < ::Mangrove::Result::Ext }
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.void }
          
        
      
        

          

            
              1
            

            
              
            

                  def decorate
          
        
      
        

          

            
              2
            

            
              
                
                  else: 2
                
              
                
                  then: 0
                
              
            

                    return unless valid_constant_name?(constant.to_s)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                    root.create_path(constant) do |klass|
          
        
      
        

          

            
              2
            

            
              
            

                      klass.create_method("in_ok", return_type: "Mangrove::Result::Ok[#{constant}]")
          
        
      
        

          

            
              2
            

            
              
            

                      klass.create_method("in_err", return_type: "Mangrove::Result::Err[#{constant}]")
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  rescue NameError
          
        
      
        

          

            

            
              
            

                    # 握りつぶす
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  private
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { params(string: String).returns(T::Boolean) }
          
        
      
        

          

            
              1
            

            
              
            

                  def valid_constant_name?(string)
          
        
      
        

          

            
              2
            

            
              
            

                    Object.const_defined?(string) && !!(string =~ /\A[A-Z][a-zA-Z0-9_]*\z/)
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # typed: true
          
        
      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "mangrove/try_from_ext"
          
        
      
        

          

            
              1
            

            
              
            

            require "tapioca/dsl"
          
        
      
        

          

            
              1
            

            
              
            

            require "sorbet-runtime"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Tapioca
          
        
      
        

          

            
              1
            

            
              
            

              module Compilers
          
        
      
        

          

            
              1
            

            
              
            

                class TryFromExt < Tapioca::Dsl::Compiler
          
        
      
        

          

            
              1
            

            
              
            

                  extend T::Sig
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  ConstantType = type_member { { fixed: T.class_of(Mangrove::TryFromExt) } }
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.returns(T::Enumerable[Module]) }
          
        
      
        

          

            
              1
            

            
              
            

                  def self.gather_constants
          
        
      
        

          

            
              8298
            

            
              
            

                    all_classes.select { |c| c.singleton_class < ::Mangrove::TryFromExt }
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  sig { override.void }
          
        
      
        

          

            
              1
            

            
              
            

                  def decorate
          
        
      
        

          

            
              1
            

            
              
                
                  then: 1
                
              
                
                  else: 0
                
              
            

                    return if constant.instance_variable_get(:@convertable_from).nil? || constant.instance_variable_get(:@convertable_from).empty?
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
                
                  else: 0
                
              
            

                    constant.instance_variable_get(:@convertable_from)&.each do |convertable_from, values|
          
        
      
        

          

            

            
              
            

                      err_constant, _block = values
          
        
      
        

          

            

            
              
            

                      root.create_path(convertable_from) do |klass|
          
        
      
        

          

            

            
              
            

                        klass.create_method("try_into_#{constant.to_s.gsub(/::|([A-Z]+)([A-Z][a-z])/, '\1_\2').gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase}", return_type: "Mangrove::Result[#{constant}, #{err_constant}]")
          
        
      
        

          

            

            
              
            

                      end
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end