mona-result 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 32cb8667c98ff681514f079fed657c8daa835b7c480f2e28c0524892408c81e7
-  data.tar.gz: 741a2b69c33f10b9ec8fad3c25aeb49d6b7dd6f9178824819d933f34b2b5db38
+  metadata.gz: 11b851820d5a4a5558b4b9fca9ed4d473a4c7f41f76296e8304de95f319b4eac
+  data.tar.gz: e02cccae0cc5ddf02a7a8fd99d1f509be1148c9d41f39f28d545409da7906e05
 SHA512:
-  metadata.gz: 96e77b201ec66ee70f9aa84ff8b7aba988233c210e5cebb1157832c53f3c116f7ecf12f069dc29c4ae3514ed9f9007a0458e1824c2d3b45263ec7487f9bd0057
-  data.tar.gz: c359b0d6b6782297c3ebebea9e0d241d7646ccb3c44873c8d087567681ed3fb6ff58d827f6d0af9a97516d57e74410d754b47222c6b895440f9b15133b139faa
+  metadata.gz: 4b01676a3ec1acaa3541a3e60eeaacd82cfacdc81889bd7073e0824ee987ec89c01415b28ba1a72413a32d78d687d0ac1f0a5521a0933b4a1edae8fe0af6ce46
+  data.tar.gz: 66738db3e3571dd6c53982081acf787f634b5f7964a19a58649b513eeb5c3c169ac89bf25aa7fd9aaf951e25c83f9646314eab0d5b7b474f08efe3fe96adbe91

data/CHANGELOG.md

@@ -1,4 +1,20 @@
-## [0.1.1]
+## [0.2.0] - 2022-08-23
+
+- Adds Mona::Resultable module which implements the Result interface
+- Simplify and improve RBS
+- Steep checks tests in a stricter fashion
+- Improve docs, tests, and rubocop
+
+## [0.1.3] - 2022-08-09
+
+- Fix CHANGELOG rubygems link
+
+## [0.1.2] - 2022-08-09
+
+- Fix gemspec links
+- Improve documentation
+
+## [0.1.1] - 2022-08-09
 
 - Adds basic documentation
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    mona-result (0.1.1)
+    mona-result (0.2.0)
 
 GEM
   remote: https://rubygems.org/
@@ -21,7 +21,7 @@ GEM
     listen (3.7.1)
       rb-fsevent (~> 0.10, >= 0.10.3)
       rb-inotify (~> 0.9, >= 0.9.10)
-    minitest (5.16.2)
+    minitest (5.16.3)
     parallel (1.22.1)
     parser (3.1.2.1)
       ast (~> 2.4.1)
@@ -33,14 +33,14 @@ GEM
     rbs (2.6.0)
     regexp_parser (2.5.0)
     rexml (3.2.5)
-    rubocop (1.34.0)
+    rubocop (1.35.1)
       json (~> 2.3)
       parallel (~> 1.10)
       parser (>= 3.1.2.1)
       rainbow (>= 2.2.2, < 4.0)
       regexp_parser (>= 1.8, < 3.0)
       rexml (>= 3.2.5, < 4.0)
-      rubocop-ast (>= 1.20.0, < 2.0)
+      rubocop-ast (>= 1.20.1, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 1.4.0, < 3.0)
     rubocop-ast (1.21.0)

data/README.md

@@ -24,7 +24,10 @@ success = Result.ok(1) # => #<OK 1>
 success.ok? # => true
 success.err? # => false
 success.value # => 1
-success.and_tap { puts "it is #{_1}" }.and_then { _1 * 5 }.value_or { :nope }
+
+success.and_tap { puts "it is #{_1}" }
+       .and_then { _1 * 5 }
+       .value_or { :nope }
 # OUT: it is 1
 # => 5
 
@@ -34,14 +37,23 @@ failure.ok? # => false
 failure.err? # => true
 failure.failure # => 4
 failure.reason # => :not_prime
-failure.and_tap { puts "it is #{_1}" }.and_then { _1 * 5 }.value_or { :nope } # => :nope
 
-# Dict with sequence
+failure.and_tap { puts "it is #{_1}" }
+       .and_then { _1 * 5 }
+       .value_or { :nope }
+# => :nope
+
+# Dict with sequence, example using a fictional repository.
+# #set can take a [Symbol, Symbol] key argument where left is OK key, right is Err key
 result = Result.dict do |d|
-  d.set :numerator, 10
-  d.set :divisor, 2
-  d.set :answer, d[:numerator] / d[:divisor]
-end # => #<OK {:numerator=>10, :divisor=>2, :answer=>5}>
+  d.set :user, UserRepo.find user_id
+  d.set :input, PostInput.valid(attributes)
+  d.set [:post, :input], PostRepo.create user_id: user_id, **d[:input]
+end
+# if find user fails:  # => #<Err {:user=>NotFoundError} reason: :not_found, key: :user>
+# if validation fails: # => #<Err {:user=>User, :input=>PostInput(invalid)} reason: :invalid, key: :input>
+# if create fails:     # => #<Err {:user=>User, :input=>PostInput(db err)} reason: :db_err, key: :input>
+# if all ok:           # => #<OK: {:user=>User, :post=>Post}>
 
 # Action - a callable sequence
 divide = Result.action do |x, y|
@@ -78,6 +90,20 @@ in err:, reason:, **meta
 end
 ```
 
+You can also match a result, using similar semantics, the difference from using case/pattern-match is that a
+`Mona::Result::NoMatchError` is raised, which keeps a reference to the result (which is useful for differentially
+handling errors in an enclosing scope - not currently possible with ruby's `NoMatchingPatternError` which does not
+contain any information about the failed match)
+
+```ruby
+Mona::Result.match(result) do |on|
+  on.ok            { |value| puts "ok" }
+  on.err(key: :x)  { |failure, reason, **meta| puts "error with meta :key => :x" }
+  on.err(:invalid) { |failure, reason, **meta| puts "error with reason :invalid" }
+  on.err           { |failure, reason, **meta| puts "error" }
+end
+```
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/Steepfile

@@ -6,18 +6,15 @@ target :lib do
   signature "sig"
 
   check "lib"
-
-  configure_code_diagnostics(D::Ruby.default)
 end
 
 target :test do
-  signature "sig"
+  signature "sig", "test/sig"
 
   check "test"
 
   library "minitest", "mutex_m"
 
-  configure_code_diagnostics(D::Ruby.strict)
   configure_code_diagnostics do |h|
     h[D::Ruby::UnsupportedSyntax] = :information
   end

data/lib/mona/result/action.rb

@@ -68,14 +68,18 @@ module Mona
         remove_instance_variable :@sequence
       end
 
+      def perform(*args, **kwargs) = raise(NotImplementedError, "implement `perform'")
+
       private
 
+      def get(key) = @sequence.fetch(key)
+
       def set(key, value) = @sequence.set(key, value)
 
       def respond_to_missing?(key, _include_private = false) = @sequence.key?(key)
 
       def method_missing(key, *args)
-        return @sequence.fetch(key) if args.empty? && @sequence.key?(key)
+        return get(key) if args.empty? && @sequence.key?(key)
 
         raise NoMethodError, "no method `#{key}' for #{self}"
       end

data/lib/mona/result/dict.rb

@@ -5,7 +5,7 @@ module Mona
     # Represents a dictionary of results, it is successful if all results are successful, and a failure if one
     # is a failure. A Result::Dict can only contain one failure.
     class Dict
-      # factory method that returns {Dict::Success} or {Dict::Failure}
+      # factory method that returns {Dict::OK} or {Dict::Err}
       def self.new(initial = {}, &block)
         result = Dict::EMPTY
         initial.each { |k, v| result = result.set(k, v) }
@@ -14,7 +14,7 @@ module Mona
       end
 
       # Dict read interface
-      module ReadInterface
+      module Read
         def [](key) = to_h[key]
 
         def key?(key) = to_h.key?(key)
@@ -24,15 +24,16 @@ module Mona
 
       # OK dict result
       class OK < Result::OK
-        include ReadInterface
+        include Read
 
         def set(key, to_result)
           key, failure_key = key if key.is_a?(Array)
           failure_key ||= key
 
           Result[to_result].either \
-            ->(value)                { OK.new to_h.merge(key => value) },
-            ->(failure, reason, **m) { Err.new to_h.merge(failure_key => failure), reason, **m, key: failure_key }
+            ->(value) { OK.new to_h.merge(key => value) },
+            # @type var meta: Hash[Symbol, untyped]
+            ->(failure, reason, **meta) { Err.new to_h.merge(failure_key => failure), reason, **meta, key: failure_key }
         end
 
         def sequence(&) = Sequence.new(self).call(&)
@@ -42,7 +43,7 @@ module Mona
 
       # Err dict result
       class Err < Result::Err
-        include ReadInterface
+        include Read
 
         def set(_key, _val) = raise(Error, "cannot #set on #{self}")
 

data/lib/mona/result/err.rb

@@ -4,45 +4,25 @@ module Mona
   module Result
     # A Error or failure result, with optional reason, and metadata
     class Err
+      include Resultable
+
       def initialize(failure, reason = nil, **meta)
-        raise ArgumentError, "meta can't contain :reason key" if meta.key?(:reason)
+        raise ArgumentError, "meta can't contain :reason or err: key" if meta.key?(:reason) || meta.key?(:err)
 
-        @failure = failure.freeze
-        @reason = reason
-        @meta = meta
+        @failure = failure
+        @reason  = reason
+        @meta    = meta
       end
 
+      # @dynamic failure, reason, meta
       attr_reader :failure, :reason, :meta
 
-      def ok? = false
-
-      def err? = true
-
-      def value_or(&) = yield
-
-      def ok(&) = nil
-
-      def err(&) = yield @failure, @reason, **@meta
-
       def either(_ok, err) = err.call(@failure, @reason, **@meta)
 
-      def and_then(&) = self
-
-      def and_tap(&) = self
-
-      def or_else(&) = Result[yield @failure, @reason, **@meta]
-
-      def deconstruct = [:err, @failure, @reason, @meta]
-
-      def deconstruct_keys(_keys = nil) = { err: @failure, reason: @reason, **@meta }
-
-      def to_result = self
-
-      def to_s
-        "#<Err #{@failure.inspect} #{{ reason: @reason, **@meta }.map{ "#{_1}: #{_2.inspect}" }.join(", ")}>"
-      end
+      def inspect = "#<Err #{@failure} #{{ reason: @reason, **@meta }.map { "#{_1}: #{_2}" }.join(", ")}>"
 
-      alias inspect to_s
+      # @dynamic to_s
+      alias to_s inspect
     end
   end
 end

data/lib/mona/result/error.rb

@@ -7,6 +7,7 @@ module Mona
 
     # raised when Result::Match does not match the result
     class NoMatchError < Error
+      # @dynamic result
       attr_reader :result
 
       def initialize(result)

data/lib/mona/result/match.rb

@@ -5,10 +5,11 @@ module Mona
     # Use Match.call to respond to result success or failure
     #
     # Result::Match.call(result) do |r|
-    #   r.ok                 { |value| ... }
-    #   r.err(error, **meta) { |failure, reason, **meta| ... }
-    #   r.err(error)         { |failure, reason, **meta| ... }
-    #   r.err                { |failure, reason, **meta| ... }
+    #   r.ok                  { |value| ... }
+    #   r.err(reason, **meta) { |failure, reason, **meta| ... }
+    #   r.err(**meta)         { |failure, reason, **meta| ... }
+    #   r.err(reason)         { |failure, reason, **meta| ... }
+    #   r.err                 { |failure, reason, **meta| ... }
     # end
     class Match
       def self.call(result, &) = new(result).call(&)
@@ -33,6 +34,7 @@ module Mona
 
       def err(match_reason = nil, **match_meta)
         @result.or_else do |failure, reason, **meta|
+          # @type var meta: Hash[Symbol, untyped]
           if match_reason?(match_reason, reason) && match_meta?(match_meta, meta)
             throw @throw, yield(failure, reason, **meta)
           end

data/lib/mona/result/ok.rb

@@ -4,39 +4,21 @@ module Mona
   module Result
     # A Successful (OK) result
     class OK
+      include Resultable
+
       def initialize(value)
-        @value = value.freeze
+        @value = value
       end
 
+      # @dynamic value
       attr_reader :value
 
-      def value_or(&) = @value
-
-      def ok? = true
-
-      def err? = false
-
-      def ok(&) = yield @value
-
-      def err(&) = nil
-
       def either(ok, _err) = ok.call(@value)
 
-      def and_then(&) = Result[yield @value]
-
-      def and_tap(&) = tap { yield @value }
-
-      def or_else(&) = self
-
-      def deconstruct = [:ok, @value]
-
-      def deconstruct_keys(_keys = nil) = { ok: @value }
-
-      def to_result = self
-
-      def to_s = "#<OK #{@value.inspect}>"
+      def inspect = "#<OK #{@value}>"
 
-      alias inspect to_s
+      # @dynamic to_s
+      alias to_s inspect
     end
   end
 end

data/lib/mona/result/sequence.rb

@@ -5,7 +5,7 @@ module Mona
     # Sequence.call { ... } allows monadic 'do' notation for Result::Dict, where #set-ing the first failure skips the
     # remainder of the block and returns the Result::Dict
     class Sequence
-      include Dict::ReadInterface
+      include Dict::Read
 
       def self.call(result = Dict::EMPTY, &) = new(result).call(&)
 

data/lib/mona/result.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative "result/version"
 require_relative "result/error"
+require_relative "resultable"
 
 module Mona
   # Monadic result
@@ -9,6 +9,8 @@ module Mona
   # @author Ian White
   # @since 0.1.0
   module Result
+    VERSION = "0.2.0"
+
     autoload :OK,       "mona/result/ok.rb"
     autoload :Err,      "mona/result/err.rb"
     autoload :Match,    "mona/result/match.rb"
@@ -16,10 +18,12 @@ module Mona
     autoload :Sequence, "mona/result/sequence.rb"
     autoload :Action,   "mona/result/action.rb"
 
-    def self.[](obj) = obj.respond_to?(:to_result) ? obj.to_result : OK.new(obj)
+    def self.[](obj) = obj.is_a?(Resultable) ? obj : OK.new(obj)
 
     module_function
 
+    # @dynamic self.to_result, self.ok, self.err, self.on_result, self.on_ok, self.dict, self.action
+
     def to_result(obj) = Result[obj]
 
     def ok(value) = OK.new(value)

data/lib/mona/resultable.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Mona
+  # Provides the result interface
+  # The including class must implement #either(ok, err)
+  module Resultable
+    def value_or(&block)
+      either ->(value) { value },
+             ->(_failure, _reason = nil, **_meta) { block.call }
+    end
+
+    def ok?
+      either ->(_value) { true },
+             ->(_failure, _reason = nil, **_meta) { false }
+    end
+
+    def err?
+      either ->(_value) { false },
+             ->(_failure, _reason = nil, **_meta) { true }
+    end
+
+    def ok(&block)
+      either ->(value) { block.call(value) },
+             ->(_failure, _reason = nil, **_meta) {}
+    end
+
+    def err(&block)
+      either ->(_value) {},
+             # @type var meta: Hash[Symbol, untyped]
+             ->(failure, reason = nil, **meta) { block.call(failure, reason, **meta) }
+    end
+
+    def and_tap(&block)
+      tap do
+        either ->(value) { block.call(value) },
+               ->(_failure, _reason = nil, **_meta) {}
+      end
+    end
+
+    def and_then(&block)
+      either ->(value) { Result[block.call(value)] },
+             ->(_failure, _reason, **_meta) { self }
+    end
+
+    def or_else(&block)
+      either ->(_value) { self },
+             # @type var meta: Hash[Symbol, untyped]
+             ->(failure, reason, **meta) { Result[block.call(failure, reason, **meta)] }
+    end
+
+    def deconstruct
+      either ->(value) { [:ok, value] },
+             # @type var meta: Hash[Symbol, untyped]
+             ->(failure, reason, **meta) { [:err, failure, reason, meta] }
+    end
+
+    def deconstruct_keys(_keys = nil)
+      either ->(value) { { ok: value } },
+             # @type var meta: Hash[Symbol, untyped]
+             ->(failure, reason, **meta) { { err: failure, reason:, **meta } }
+    end
+  end
+end

data/sig/mona.rbs

@@ -0,0 +1,157 @@
+module Mona
+  type dict        = Hash[Symbol, untyped]
+  type result[T]   = Resultable[T]
+  type dict_result = (Result::Dict::OK | Result::Dict::Err)
+
+  module Resultable[T] : _Either[T]
+    interface _Either[T]
+      def either: [OKR, ErrR] (^(T) -> OKR, ^(T, ?untyped, **untyped) -> ErrR) -> (OKR | ErrR)
+    end
+
+    def ok?: -> bool
+    def err?: -> bool
+    def ok: [R] () { (T) -> R } -> (R | nil)
+    def err: [R] () { (T, ?untyped, **untyped) -> R } -> (R | nil)
+    def value_or: [R] { () -> R } -> (R | T)
+    def and_then: [R] () { (T) -> R } -> result[untyped]
+    def and_tap: () { (T) -> void } -> self
+    def or_else: [R] () { (T, ?untyped, **untyped) -> R } -> result[untyped]
+    def deconstruct: -> Array[untyped]
+    def deconstruct_keys: (?Array[Symbol]?) -> dict
+  end
+
+  module Result
+    VERSION: String
+
+    def self.[]: (untyped) -> result[untyped]
+    def self?.to_result: (untyped) -> result[untyped]
+    def self?.ok: [ValueT] (ValueT) -> OK[ValueT]
+    def self?.err: [FailureT] (FailureT, ?untyped, **untyped) -> Err[FailureT]
+    def self?.dict: (?dict) ?{ (Sequence) -> void } -> dict_result
+    def self?.on_result: (result[untyped]) { (Match) -> void } -> untyped
+    def self?.on_ok: (result[untyped]) { (untyped) -> void } -> untyped
+    def self?.action: () { (*untyped) -> void } -> Action::Ephemeral
+
+    class Error < StandardError
+    end
+
+    class NoMatchError < Error
+      attr_reader result: result[untyped]
+      def initialize: (result[untyped]) -> void
+    end
+
+    class OK[ValueT]
+      include Resultable[ValueT]
+
+      attr_reader value: ValueT
+
+      def initialize: (ValueT) -> void
+      def either: [OKR, ErrR] (^(ValueT) -> OKR, ^(untyped, ?untyped, **untyped) -> ErrR) -> OKR
+      def inspect: -> String
+      alias to_s inspect
+    end
+
+    class Err[FailureT]
+      include Resultable[FailureT]
+
+      attr_reader failure: FailureT
+      attr_reader reason: untyped
+      attr_reader meta: dict
+
+      def initialize: (FailureT, ?untyped, **untyped) -> void
+      def either: [OKR, ErrR] (^(untyped) -> OKR, ^(FailureT, ?untyped, **untyped) -> ErrR) -> ErrR
+      def inspect: -> String
+      alias to_s inspect
+    end
+
+    class Dict
+      EMPTY: dict_result
+
+      module Read : _ToH
+        interface _ToH
+          def to_h: -> dict
+        end
+
+        def key? : (Symbol) -> bool
+        def fetch : (Symbol) -> untyped
+        def [] : (Symbol) -> untyped
+      end
+
+      interface _Interface
+        def set: (Symbol | [Symbol, Symbol], untyped) -> dict_result
+        def sequence: () { (Sequence) -> void } -> dict_result
+        def to_h: -> dict
+      end
+
+      class OK < Result::OK[dict]
+        include Read
+
+        include _Interface
+
+        @value: dict
+      end
+
+      class Err < Result::Err[dict]
+        include Read
+
+        include _Interface
+
+        @failure: dict
+      end
+
+      def self.new: (?dict) ?{ (Sequence) -> void } -> dict_result
+    end
+
+    class Match
+      @throw: Object
+      @result: result[untyped]
+
+      def self.call: (result[untyped]) { (Match) -> void } -> untyped
+      def initialize: (result[untyped]) -> void
+      def call: () { (Match) -> void } -> untyped
+      def ok: () { (untyped) -> void } -> void
+      def err: (?untyped, **untyped) { (untyped, ?untyped, **untyped) -> void } -> void
+
+      private
+
+      def match_reason?: (untyped, untyped) -> bool
+      def match_meta?: (untyped, untyped) -> bool
+    end
+
+    class Sequence
+      include Dict::Read
+
+      @throw: Object
+      @result: dict_result
+
+      def self.call: (?dict_result) { (Sequence) -> void } -> dict_result
+      def initialize: (?dict_result) -> void
+      def call: () { (Sequence) -> void } -> dict_result
+      def set: (Symbol | [Symbol,Symbol], untyped) -> void
+      def to_h: -> dict
+    end
+
+    module Action
+      class Ephemeral
+        include Action
+
+        @perform: ^(*untyped, **untyped) -> void
+
+        def initialize: () { (*untyped, **untyped) -> void } -> void
+        def perform: (*untyped, **untyped) -> void
+      end
+
+      @sequence: Sequence
+
+      def call: (*untyped, **untyped) -> dict_result
+      def perform: (*untyped, **untyped) -> void
+
+      private
+
+      def get: (Symbol) -> untyped
+      def set: (Symbol | [Symbol,Symbol], untyped) -> void
+      def respond_to_missing?: (Symbol, ?bool) -> bool
+      def method_missing: (Symbol, *untyped) -> untyped
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mona-result
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Ian White
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-08-09 00:00:00.000000000 Z
+date: 2022-08-23 00:00:00.000000000 Z
 dependencies: []
 description: Mona::Result provides a result monad, and dict result monad with do-notation
 email:
@@ -33,16 +33,16 @@ files:
 - lib/mona/result/match.rb
 - lib/mona/result/ok.rb
 - lib/mona/result/sequence.rb
-- lib/mona/result/version.rb
-- sig/mona/result.rbs
-homepage: https://github.com/mona/mona-result
+- lib/mona/resultable.rb
+- sig/mona.rbs
+homepage: https://github.com/mona-rb/mona-result
 licenses:
 - MIT
 metadata:
   rubygems_mfa_required: 'true'
-  homepage_uri: https://github.com/mona/mona-result
-  source_code_uri: https://github.com/mona/mona-result
-  changelog_uri: https://github.com/mona/mona-result/CHANGELOG.md
+  homepage_uri: https://github.com/mona-rb/mona-result
+  source_code_uri: https://github.com/mona-rb/mona-result
+  changelog_uri: https://github.com/mona-rb/mona-result/blob/main/CHANGELOG.md
 post_install_message:
 rdoc_options: []
 require_paths:

data/lib/mona/result/version.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-module Mona
-  module Result
-    VERSION = "0.1.1"
-  end
-end

data/sig/mona/result.rbs

@@ -1,177 +0,0 @@
-module Mona
-  module Result
-    VERSION: String
-
-    type dict        = Hash[Symbol, untyped]
-    type keys        = Array[Symbol]
-    type result[T]   = (_OK[T] | _Err[T])
-    type dict_result = result[dict] & _Dict
-    type set_key     = (Symbol | [Symbol, Symbol])
-
-    def self.[]: (untyped) -> result[untyped]
-    def self?.to_result: (untyped) -> result[untyped]
-    def self?.ok: [T] (T) -> _OK[T]
-    def self?.err: [T] (T, ?untyped, **untyped) -> _Err[T]
-    def self?.dict: (?dict) ?{ (Sequence) -> void } -> dict_result
-    def self?.on_result: (result[untyped]) { (Match) -> void } -> untyped
-    def self?.on_ok: (result[untyped]) { (untyped) -> void } -> untyped
-    def self?.action: () { (*untyped) -> void } -> Action::Ephemeral
-
-    interface _OK[T]
-      def initialize: (T) -> void
-      def value: -> T
-      def ok?: -> true
-      def err?: -> false
-      def ok: [R] () { (T) -> R } -> R
-      def err: () { (T, untyped, **untyped) -> void } -> nil
-      def either: [R] (^(T) -> R, ^(T, untyped, **untyped) -> void) -> R
-      def value_or: () { -> void } -> T
-      def and_then: () { (T) -> untyped } -> result[untyped]
-      def and_tap: () { (T) -> void } -> self
-      def or_else: () { (T, ?untyped, **untyped) -> untyped } -> self
-      def deconstruct: -> [:ok, T]
-      def deconstruct_keys: (?keys?) -> { ok: T }
-    end
-
-    interface _Err[T]
-      def initialize: (T, ?untyped, **untyped) -> void
-      def failure: -> T
-      def reason: -> untyped
-      def meta: -> dict
-      def ok?: -> false
-      def err?: -> true
-      def ok: () { (untyped) -> void } -> nil
-      def err: [R] () { (T, untyped, **untyped) -> R } -> R
-      def either: [R] (^(T) -> void, ^(T, untyped, **untyped) -> R) -> R
-      def value_or: [R] () { -> R } -> R
-      def and_then: () { (T) -> untyped } -> self
-      def and_tap: () { (T) -> void } -> self
-      def or_else: () { (T, ?untyped, **untyped) -> untyped } -> result[untyped]
-      def deconstruct: -> [:err, T, untyped, dict]
-      def deconstruct_keys: (?keys?) -> dict
-    end
-
-    interface _ToH
-      def to_h: -> dict
-    end
-
-    interface _DictRead
-      def key? : (Symbol) -> bool
-      def fetch : (Symbol) -> untyped
-      def [] : (Symbol) -> untyped
-    end
-
-    interface _Dict
-      include _DictRead
-      def set: (set_key, untyped) -> dict_result
-      def sequence: () { (Sequence) -> void } -> dict_result
-      def to_h: -> dict
-    end
-
-    interface _Perform
-      def perform: (*untyped, **untyped) -> void
-    end
-
-    class Error < StandardError
-    end
-
-    class NoMatchError < Error
-      attr_reader result: _Err[untyped]
-      def initialize: (_Err[untyped]) -> void
-    end
-
-    class OK
-      include _OK[untyped]
-
-      @value: untyped
-    end
-
-    class Err
-      include _Err[untyped]
-
-      @failure: untyped
-      @reason: untyped
-      @meta: dict
-    end
-
-    class Dict
-      EMPTY: dict_result
-
-      module ReadInterface : _ToH
-        include _DictRead
-      end
-
-      class OK < Result::OK
-        include ReadInterface
-
-        include _OK[dict]
-        include _Dict
-
-        @value: dict
-      end
-
-      class Err < Result::Err
-        include ReadInterface
-
-        include _Err[dict]
-        include _Dict
-
-        @failure: dict
-        @reason: untyped
-        @meta: dict
-      end
-
-      def self.new: (?dict) ?{ (Sequence) -> void } -> dict_result
-    end
-
-    class Match
-      @throw: Object
-      @result: result[untyped]
-
-      def self.call: (result[untyped]) { (Match) -> void } -> untyped
-      def initialize: (result[untyped]) -> void
-      def call: () { (Match) -> void } -> untyped
-      def ok: () { (untyped) -> void } -> void
-      def err: (?untyped, **untyped) { (untyped, ?untyped, **untyped) -> void } -> void
-
-      private
-
-      def match_reason?: (untyped, untyped) -> bool
-      def match_meta?: (untyped, untyped) -> bool
-    end
-
-    class Sequence
-      include Dict::ReadInterface
-
-      @throw: Object
-      @result: dict_result
-
-      def self.call: (?dict_result) { (Sequence) -> void } -> dict_result
-      def initialize: (?dict_result) -> void
-      def call: () { (Sequence) -> void } -> dict_result
-      def set: (set_key, untyped) -> void
-      def to_h: -> dict
-    end
-
-    module Action : _Perform
-      class Ephemeral
-        include Action
-
-        @perform: ^(*untyped, **untyped) -> void
-
-        def initialize: () { (*untyped, **untyped) -> void } -> void
-        def perform: (*untyped, **untyped) -> void
-      end
-
-      @sequence: Sequence
-
-      def call: (*untyped, **untyped) -> dict_result
-
-      private
-
-      def set: (set_key, untyped) -> void
-      def respond_to_missing?: (Symbol, ?bool) -> bool
-      def method_missing: (Symbol, *untyped) -> untyped
-    end
-  end
-end