clean-architecture 5.0.2 → 6.0.0

data/sorbet/{rbi/gems → dry-monads-sorbet}/dry-monads.rbi

@@ -1,13 +1,10 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   srb rbi gems
-
 # typed: strong
 #
-# If you would like to make changes to this file, great! Please create the gem's shim here:
-#
-#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/dry-monads/all/dry-monads.rbi
+# This rbi file is bundled in the dry-monads-sorbet gem and is copied down
+# into projects using the dry_monads_sorbet:update_rbi rake task.
 #
-# dry-monads-1.3.5
+# Any changes to the type annotations for Dry::Monads should be made
+# in the dry-monads-sorbet gem itself in its bundled_rbi directory.
 
 module Dry
 end
@@ -26,7 +23,6 @@ module Dry::Monads
   extend Dry::Monads::Maybe::Mixin::Constructors
   extend Dry::Monads::Result::Mixin::Constructors
   extend Dry::Monads::Validated::Mixin::Constructors
-  include Dry::Core::Constants
 end
 module Dry::Monads::Curry
   def self.call(value); end
@@ -40,48 +36,58 @@ end
 class Dry::Monads::ConstructorNotAppliedError < NoMethodError
   def initialize(method_name, constructor_name); end
 end
-module Dry::Monads::RightBiased
-end
-module Dry::Monads::RightBiased::Right
-  def ===(other); end
-  def and(mb); end
-  def apply(val = nil); end
-  def bind(*args, **kwargs); end
-  def curry; end
-  def deconstruct; end
-  def deconstruct_keys(keys); end
-  def destructure(*args, **kwargs); end
-  def discard; end
-  def flatten; end
-  def fmap(*arg0); end
-  def or(*arg0); end
-  def or_fmap(*arg0); end
-  def self.included(m); end
-  def tee(*args, &block); end
-  def value!; end
-  def value_or(_val = nil); end
-end
-module Dry::Monads::RightBiased::Left
-  def and(_); end
-  def apply(*arg0); end
-  def bind(*arg0); end
-  def deconstruct; end
-  def deconstruct_keys(keys); end
-  def discard; end
-  def flatten; end
-  def fmap(*arg0); end
-  def or(*arg0); end
-  def or_fmap(*arg0); end
-  def self.trace_caller; end
-  def tee(*arg0); end
-  def value!; end
-  def value_or(val = nil); end
-end
 module Dry::Monads::Transformer
   def fmap2(*args); end
   def fmap3(*args); end
 end
 class Dry::Monads::Maybe
+  extend T::Sig
+  extend T::Generic
+  extend T::Helpers
+
+  abstract!
+  # sealed!
+
+  sig do
+    type_parameters(:New)
+      .params(blk: T.proc.params(arg0: Elem).returns(Dry::Monads::Maybe[T.type_parameter(:out, :New)]))
+      .returns(Dry::Monads::Maybe[T.type_parameter(:out, :New)])
+  end
+  def bind(&blk); end
+
+  sig do
+    type_parameters(:New)
+      .params(blk: T.proc.params(arg0: Elem).returns(T.type_parameter(:New)))
+      .returns(Dry::Monads::Maybe[T.type_parameter(:New)])
+  end
+  def fmap(&blk); end
+
+  sig do
+    params(val: T.any(Elem, NilClass),
+           blk: T.nilable(T.proc.returns(Elem)))
+      .returns(Elem)
+  end
+  def value_or(val = nil, &blk); end
+
+  sig do
+    returns(Elem)
+  end
+  def value!; end
+
+  sig do
+    params(blk: T.proc.returns(T.untyped))
+      .returns(T.self_type)
+  end
+  def or(&blk); end
+
+  sig do
+    type_parameters(:Error)
+      .params(val: T.nilable(T.type_parameter(:Error)),
+              blk: T.nilable(T.proc.returns(T.type_parameter(:Error))))
+      .returns(Dry::Monads::Result[T.type_parameter(:out, :Error), Elem])
+  end
+  def to_result(val = nil, &blk); end
+
   def failure?; end
   def monad; end
   def none?; end
@@ -96,68 +102,129 @@ class Dry::Monads::Maybe
   include Dry::Monads::Transformer
 end
 class Dry::Monads::Maybe::Some < Dry::Monads::Maybe
-  def fmap(*args, &block); end
+  extend T::Sig
+  extend T::Generic
+  Elem = type_member
+
+  sig {params(value: Elem).void}
   def initialize(value = nil); end
   def inspect; end
   def maybe(*args, &block); end
   def self.[](*value); end
   def self.call(*arg0); end
   def self.to_proc; end
-  def to_result(_fail = nil); end
   def to_s; end
-  include Anonymous_Dry_Equalizer_1
+  include Anonymous_Dry_Equalizer_33
   include Dry::Equalizer::Methods
-  include Dry::Monads::RightBiased::Right
 end
-module Anonymous_Dry_Equalizer_1
+module Anonymous_Dry_Equalizer_33
   def cmp?(comparator, other); end
   def hash; end
   def inspect; end
 end
 class Dry::Monads::Maybe::None < Dry::Monads::Maybe
+  extend T::Sig
+  extend T::Generic
+  Elem = type_member
+
   def ==(other); end
   def deconstruct; end
   def eql?(other); end
   def hash; end
-  def initialize(trace = nil); end
+  sig {params(trace: T.untyped).void}
+  def initialize(trace = T.unsafe(nil)); end
   def inspect; end
   def maybe(*arg0); end
   def or(*args); end
   def or_fmap(*args, &block); end
   def self.instance; end
   def self.method_missing(m, *arg1); end
-  def to_result(fail = nil); end
   def to_s; end
   def trace; end
-  include Dry::Monads::RightBiased::Left
+  include Dry::Core::Constants
 end
 module Dry::Monads::Maybe::Mixin
   include Dry::Monads::Maybe::Mixin::Constructors
 end
 module Dry::Monads::Maybe::Mixin::Constructors
+  sig {type_parameters(:T).params(value: T.nilable(T.type_parameter(:T))).returns(Dry::Monads::Maybe[T.type_parameter(:T)])}
   def Maybe(value); end
+  sig {type_parameters(:T).returns(Dry::Monads::Maybe[T.type_parameter(:out, :T)])}
   def None; end
-  def Some(value = nil, &block); end
+  sig {type_parameters(:T).params(value: T.type_parameter(:T)).returns(Dry::Monads::Maybe[T.type_parameter(:T)])}
+  def Some(value = nil); end
 end
 module Dry::Monads::Maybe::Hash
   def self.all(hash, trace = nil); end
   def self.filter(hash); end
 end
 class Dry::Monads::Result
+  extend T::Sig
+  extend T::Generic
+  extend T::Helpers
+
+  abstract!
+  # sealed!
+
+  sig do
+    type_parameters(:NewSuccessType)
+      .params(blk: T.proc.params(arg0: SuccessType).returns(Dry::Monads::Result[FailureType, T.type_parameter(:out, :NewSuccessType)]))
+      .returns(Dry::Monads::Result[FailureType, T.type_parameter(:out, :NewSuccessType)])
+  end
+  def bind(&blk); end
+
+  sig do
+    type_parameters(:New)
+      .params(blk: T.proc.params(arg0: SuccessType).returns(T.type_parameter(:New)))
+      .returns(Dry::Monads::Result[FailureType, T.type_parameter(:New)])
+  end
+  def fmap(&blk); end
+
+  sig do
+    type_parameters(:Val)
+      .params(val: T.nilable(T.type_parameter(:Val)), blk: T.nilable(T.proc.params(arg0: FailureType).returns(T.type_parameter(:Val))))
+      .returns(T.any(SuccessType, T.type_parameter(:Val)))
+  end
+  def value_or(val = nil, &blk); end
+
+  sig do
+    returns(SuccessType)
+  end
+  def value!; end
+  def to_maybe; end
+  def either(f, _); end
+
+  sig {returns(T::Boolean)}
+  def success?; end
+
+  sig {returns(T::Boolean)}
+  def failure?; end
+
+  sig {returns(FailureType)}
   def failure; end
+
+  sig do
+    type_parameters(:NewFailureType)
+      .params(blk: T.proc.params(arg0: FailureType).returns(Dry::Monads::Result[T.type_parameter(:out, :NewFailureType), SuccessType]))
+      .returns(Dry::Monads::Result[T.type_parameter(:out, :NewFailureType), SuccessType])
+  end
+  def or(&blk); end
+
   def monad; end
   def self.pure(value = nil, &block); end
   def success; end
   def to_monad; end
   def to_result; end
-  include Anonymous_Module_2
+  include Anonymous_Module_34
   include Dry::Monads::Transformer
 end
 class Dry::Monads::Result::Success < Dry::Monads::Result
-  def either(f, _); end
-  def failure?; end
+  extend T::Sig
+  extend T::Generic
+  FailureType = type_member
+  SuccessType = type_member
+
   def flip; end
-  def fmap(*args, &block); end
   def initialize(value); end
   def inspect; end
   def result(_, f); end
@@ -165,37 +232,33 @@ class Dry::Monads::Result::Success < Dry::Monads::Result
   def self.call(*arg0); end
   def self.to_proc; end
   def success; end
-  def success?; end
-  def to_maybe; end
   def to_s; end
   def to_validated; end
-  include Anonymous_Dry_Equalizer_3
+  include Anonymous_Dry_Equalizer_35
   include Dry::Equalizer::Methods
-  include Dry::Monads::RightBiased::Right
 end
 class Dry::Monads::Result::Failure < Dry::Monads::Result
+  extend T::Sig
+  extend T::Generic
+  FailureType = type_member
+  SuccessType = type_member
+
   def ===(other); end
-  def either(_, g); end
   def failure; end
-  def failure?; end
   def flip; end
   def initialize(value, trace = nil); end
   def inspect; end
-  def or(*args); end
   def or_fmap(*args, &block); end
   def result(f, _); end
   def self.[](*value); end
   def self.call(*arg0); end
   def self.to_proc; end
-  def success?; end
-  def to_maybe; end
   def to_s; end
   def to_validated; end
   def trace; end
   def value_or(val = nil); end
-  include Anonymous_Dry_Equalizer_4
+  include Anonymous_Dry_Equalizer_36
   include Dry::Equalizer::Methods
-  include Dry::Monads::RightBiased::Left
 end
 class Dry::Monads::Task
   def ==(other); end
@@ -224,7 +287,7 @@ class Dry::Monads::Task
   def value!; end
   def value_or(&block); end
   def wait(timeout = nil); end
-  include Anonymous_Module_5
+  include Anonymous_Module_37
 end
 class Dry::Monads::Try
   def error?; end
@@ -237,9 +300,13 @@ class Dry::Monads::Try
   def success?; end
   def to_monad; end
   def value?; end
-  include Anonymous_Module_6
+  include Anonymous_Module_38
 end
 class Dry::Monads::Try::Value < Dry::Monads::Try
+  extend T::Generic
+  FailureType = type_member
+  SuccessType = type_member
+
   def bind(*args); end
   def bind_call(*args, **kwargs); end
   def catchable; end
@@ -251,11 +318,14 @@ class Dry::Monads::Try::Value < Dry::Monads::Try
   def to_maybe; end
   def to_result; end
   def to_s; end
-  include Anonymous_Dry_Equalizer_7
+  include Anonymous_Dry_Equalizer_39
   include Dry::Equalizer::Methods
-  include Dry::Monads::RightBiased::Right
 end
 class Dry::Monads::Try::Error < Dry::Monads::Try
+  extend T::Generic
+  FailureType = type_member
+  SuccessType = type_member
+
   def ===(other); end
   def initialize(exception); end
   def inspect; end
@@ -264,15 +334,14 @@ class Dry::Monads::Try::Error < Dry::Monads::Try
   def to_maybe; end
   def to_result; end
   def to_s; end
-  include Anonymous_Dry_Equalizer_8
+  include Anonymous_Dry_Equalizer_40
   include Dry::Equalizer::Methods
-  include Dry::Monads::RightBiased::Left
 end
 class Dry::Monads::Validated
   def bind(*arg0); end
   def self.pure(value = nil, &block); end
   def to_monad; end
-  include Anonymous_Module_9
+  include Anonymous_Module_41
 end
 class Dry::Monads::Validated::Valid < Dry::Monads::Validated
   def ===(other); end
@@ -286,7 +355,7 @@ class Dry::Monads::Validated::Valid < Dry::Monads::Validated
   def to_result; end
   def to_s; end
   def value!; end
-  include Anonymous_Dry_Equalizer_10
+  include Anonymous_Dry_Equalizer_42
   include Dry::Equalizer::Methods
 end
 class Dry::Monads::Validated::Invalid < Dry::Monads::Validated
@@ -302,7 +371,7 @@ class Dry::Monads::Validated::Invalid < Dry::Monads::Validated
   def to_result; end
   def to_s; end
   def trace; end
-  include Anonymous_Dry_Equalizer_11
+  include Anonymous_Dry_Equalizer_43
   include Dry::Equalizer::Methods
 end
 module Dry::Monads::ConversionStubs
@@ -320,7 +389,7 @@ class Dry::Monads::Task::Promise < Concurrent::Promise
   def on_fulfill(result); end
   def on_reject(reason); end
 end
-module Anonymous_Module_5
+module Anonymous_Module_37
   def to_maybe(*arg0); end
   def to_result(*arg0); end
 end
@@ -331,16 +400,16 @@ end
 module Dry::Monads::Task::Mixin::Constructors
   def Task(&block); end
 end
-module Anonymous_Module_2
+module Anonymous_Module_34
   def to_maybe(*arg0); end
   def to_validated(*arg0); end
 end
-module Anonymous_Dry_Equalizer_3
+module Anonymous_Dry_Equalizer_35
   def cmp?(comparator, other); end
   def hash; end
   def inspect; end
 end
-module Anonymous_Dry_Equalizer_4
+module Anonymous_Dry_Equalizer_36
   def cmp?(comparator, other); end
   def hash; end
   def inspect; end
@@ -349,19 +418,34 @@ module Dry::Monads::Result::Mixin
   include Dry::Monads::Result::Mixin::Constructors
 end
 module Dry::Monads::Result::Mixin::Constructors
+  sig do
+    type_parameters(:FailureType, :SuccessType)
+      .params(value: T.nilable(T.type_parameter(:FailureType)),
+              block: T.nilable(T.untyped))
+      .returns(Dry::Monads::Result[T.type_parameter(:FailureType),
+                                   T.type_parameter(:out, :SuccessType)])
+  end
   def Failure(value = nil, &block); end
+
+  sig do
+    type_parameters(:FailureType, :SuccessType)
+      .params(value: T.nilable(T.type_parameter(:SuccessType)),
+              block: T.nilable(T.untyped))
+      .returns(Dry::Monads::Result[T.type_parameter(:out, :FailureType),
+                                   T.type_parameter(:SuccessType)])
+  end
   def Success(value = nil, &block); end
 end
-module Anonymous_Module_6
+module Anonymous_Module_38
   def to_maybe(*arg0); end
   def to_result(*arg0); end
 end
-module Anonymous_Dry_Equalizer_7
+module Anonymous_Dry_Equalizer_39
   def cmp?(comparator, other); end
   def hash; end
   def inspect; end
 end
-module Anonymous_Dry_Equalizer_8
+module Anonymous_Dry_Equalizer_40
   def cmp?(comparator, other); end
   def hash; end
   def inspect; end
@@ -374,16 +458,16 @@ end
 module Dry::Monads::Try::Mixin::Constructors
   def Try(*exceptions, &f); end
 end
-module Anonymous_Module_9
+module Anonymous_Module_41
   def to_maybe(*arg0); end
   def to_result(*arg0); end
 end
-module Anonymous_Dry_Equalizer_10
+module Anonymous_Dry_Equalizer_42
   def cmp?(comparator, other); end
   def hash; end
   def inspect; end
 end
-module Anonymous_Dry_Equalizer_11
+module Anonymous_Dry_Equalizer_43
   def cmp?(comparator, other); end
   def hash; end
   def inspect; end
@@ -435,15 +519,15 @@ class Dry::Monads::List
   def typed(type = nil); end
   def typed?; end
   def value; end
-  extend Anonymous_Dry_Core_Deprecations_Tagged_12
+  extend Anonymous_Dry_Core_Deprecations_Tagged_44
   extend Dry::Core::Deprecations::Interface
-  include Anonymous_Dry_Equalizer_13
+  include Anonymous_Dry_Equalizer_45
   include Dry::Equalizer::Methods
   include Dry::Monads::Transformer
 end
-module Anonymous_Dry_Core_Deprecations_Tagged_12
+module Anonymous_Dry_Core_Deprecations_Tagged_44
 end
-module Anonymous_Dry_Equalizer_13
+module Anonymous_Dry_Equalizer_45
   def cmp?(comparator, other); end
   def hash; end
   def inspect; end
@@ -464,7 +548,6 @@ module Dry::Monads::Do
   def self.for(*methods); end
   def self.halt(result); end
   def self.included(base); end
-  def self.wrap_method(target, method_name); end
   extend Dry::Monads::Do::Mixin
 end
 module Dry::Monads::Do::Mixin
@@ -505,6 +588,5 @@ module Dry::Monads::Lazy::Mixin::Constructors
 end
 class Dry::Monads::Result::Fixed < Module
   def included(base); end
-  def initialize(error, **_options); end
   def self.[](error, **options); end
 end