dry-monads-sorbet 1.1.6 → 1.1.7

data/sorbet/rbi/gems/docile.rbi

@@ -1,32 +0,0 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   srb rbi gems
-
-# typed: strict
-#
-# 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/docile/all/docile.rbi
-#
-# docile-1.3.2
-
-module Docile
-  def dsl_eval(dsl, *args, &block); end
-  def dsl_eval_immutable(dsl, *args, &block); end
-  def dsl_eval_with_block_return(dsl, *args, &block); end
-  def self.dsl_eval(dsl, *args, &block); end
-  def self.dsl_eval_immutable(dsl, *args, &block); end
-  def self.dsl_eval_with_block_return(dsl, *args, &block); end
-  extend Docile::Execution
-end
-module Docile::Execution
-  def exec_in_proxy_context(dsl, proxy_type, *args, &block); end
-  def self.exec_in_proxy_context(dsl, proxy_type, *args, &block); end
-end
-class Docile::FallbackContextProxy
-  def initialize(receiver, fallback); end
-  def instance_variables; end
-  def method_missing(method, *args, &block); end
-end
-class Docile::ChainingFallbackContextProxy < Docile::FallbackContextProxy
-  def method_missing(method, *args, &block); end
-end

data/sorbet/rbi/gems/dry-core.rbi

@@ -1,38 +0,0 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   srb rbi gems
-
-# typed: strict
-#
-# 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-core/all/dry-core.rbi
-#
-# dry-core-0.4.9
-
-module Dry
-end
-module Dry::Core
-end
-module Dry::Core::Constants
-  def self.included(base); end
-end
-module Dry::Core::Deprecations
-  def self.[](tag); end
-  def self.announce(name, msg, tag: nil); end
-  def self.deprecated_name_message(old, new = nil, msg = nil); end
-  def self.deprecation_message(name, msg); end
-  def self.logger(output = nil); end
-  def self.set_logger!(output = nil); end
-  def self.warn(msg, tag: nil); end
-end
-class Dry::Core::Deprecations::Tagged < Module
-  def extended(base); end
-  def initialize(tag); end
-end
-module Dry::Core::Deprecations::Interface
-  def deprecate(old_name, new_name = nil, message: nil); end
-  def deprecate_class_method(old_name, new_name = nil, message: nil); end
-  def deprecate_constant(constant_name, message: nil); end
-  def deprecation_tag(tag = nil); end
-  def warn(msg); end
-end

data/sorbet/rbi/gems/dry-equalizer.rbi

@@ -1,26 +0,0 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   srb rbi gems
-
-# typed: strict
-#
-# 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-equalizer/all/dry-equalizer.rbi
-#
-# dry-equalizer-0.3.0
-
-module Dry
-  def self.Equalizer(*keys, **options); end
-end
-class Dry::Equalizer < Module
-  def define_cmp_method; end
-  def define_hash_method(immutable:); end
-  def define_inspect_method; end
-  def define_methods(inspect: nil, immutable: nil); end
-  def included(descendant); end
-  def initialize(*keys, **options); end
-end
-module Dry::Equalizer::Methods
-  def ==(other); end
-  def eql?(other); end
-end

data/sorbet/rbi/gems/dry-monads.rbi

@@ -1,510 +0,0 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   srb rbi gems
-
-# typed: false
-#
-# 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
-#
-# dry-monads-1.3.5
-
-module Dry
-end
-module Dry::Monads
-  def self.Result(error, **options); end
-  def self.[](*monads); end
-  def self.all_loaded?; end
-  def self.constructors; end
-  def self.included(base); end
-  def self.known_monads; end
-  def self.load_monad(name); end
-  def self.register_mixin(name, mod); end
-  def self.registry; end
-  def self.registry=(registry); end
-  extend Dry::Monads::Maybe::Mixin::Constructors
-  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
-end
-class Dry::Monads::UnwrapError < StandardError
-  def initialize(ctx); end
-end
-class Dry::Monads::InvalidFailureTypeError < StandardError
-  def initialize(failure); end
-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
-  def failure?; end
-  def monad; end
-  def none?; end
-  def self.coerce(value); end
-  def self.lift(*args, &block); end
-  def self.pure(value = nil, &block); end
-  def self.to_proc; end
-  def some?; end
-  def success?; end
-  def to_maybe; end
-  def to_monad; end
-  include Dry::Monads::Transformer
-end
-class Dry::Monads::Maybe::Some < Dry::Monads::Maybe
-  def fmap(*args, &block); end
-  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_2
-  include Dry::Equalizer::Methods
-  include Dry::Monads::RightBiased::Right
-end
-module Anonymous_Dry_Equalizer_2
-  def cmp?(comparator, other); end
-  def hash; end
-  def inspect; end
-end
-class Dry::Monads::Maybe::None < Dry::Monads::Maybe
-  def ==(other); end
-  def deconstruct; end
-  def eql?(other); end
-  def hash; end
-  def initialize(trace = 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
-end
-module Dry::Monads::Maybe::Mixin
-  include Dry::Monads::Maybe::Mixin::Constructors
-end
-module Dry::Monads::Maybe::Mixin::Constructors
-  def Maybe(value); end
-  def None; end
-  def Some(value = nil, &block); end
-end
-module Dry::Monads::Maybe::Hash
-  def self.all(hash, trace = nil); end
-  def self.filter(hash); end
-end
-class Dry::Monads::Result
-  def failure; 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_3
-  include Dry::Monads::Transformer
-end
-class Dry::Monads::Result::Success < Dry::Monads::Result
-  def either(f, _); end
-  def failure?; end
-  def flip; end
-  def fmap(*args, &block); end
-  def initialize(value); end
-  def inspect; end
-  def result(_, f); end
-  def self.[](*value); end
-  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_4
-  include Dry::Equalizer::Methods
-  include Dry::Monads::RightBiased::Right
-end
-class Dry::Monads::Result::Failure < Dry::Monads::Result
-  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_5
-  include Dry::Equalizer::Methods
-  include Dry::Monads::RightBiased::Left
-end
-class Dry::Monads::Task
-  def ==(other); end
-  def apply(val = nil); end
-  def bind(&block); end
-  def compare_promises(x, y); end
-  def complete?; end
-  def curry(value); end
-  def discard; end
-  def fmap(&block); end
-  def initialize(promise); end
-  def inspect; end
-  def monad; end
-  def or(&block); end
-  def or_fmap(&block); end
-  def promise; end
-  def self.[](executor, &block); end
-  def self.failed(exc); end
-  def self.new(promise = nil, &block); end
-  def self.pure(value = nil, &block); end
-  def then(&block); end
-  def to_maybe; end
-  def to_monad; end
-  def to_result; end
-  def to_s; end
-  def value!; end
-  def value_or(&block); end
-  def wait(timeout = nil); end
-  include Anonymous_Module_6
-end
-class Dry::Monads::Try
-  def error?; end
-  def exception; end
-  def failure?; end
-  def self.[](*exceptions, &block); end
-  def self.lift(*args, &block); end
-  def self.pure(value = nil, exceptions = nil, &block); end
-  def self.run(exceptions, f); end
-  def success?; end
-  def to_monad; end
-  def value?; end
-  include Anonymous_Module_7
-end
-class Dry::Monads::Try::Value < Dry::Monads::Try
-  def bind(*args); end
-  def bind_call(*args, **kwargs); end
-  def catchable; end
-  def fmap(*args, &block); end
-  def initialize(exceptions, value); end
-  def inspect; end
-  def self.call(*arg0); end
-  def self.to_proc; end
-  def to_maybe; end
-  def to_result; end
-  def to_s; end
-  include Anonymous_Dry_Equalizer_8
-  include Dry::Equalizer::Methods
-  include Dry::Monads::RightBiased::Right
-end
-class Dry::Monads::Try::Error < Dry::Monads::Try
-  def ===(other); end
-  def initialize(exception); end
-  def inspect; end
-  def or(*args); end
-  def self.call(*arg0); end
-  def to_maybe; end
-  def to_result; end
-  def to_s; end
-  include Anonymous_Dry_Equalizer_9
-  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_10
-end
-class Dry::Monads::Validated::Valid < Dry::Monads::Validated
-  def ===(other); end
-  def alt_map(_ = nil); end
-  def apply(val = nil); end
-  def fmap(proc = nil, &block); end
-  def initialize(value); end
-  def inspect; end
-  def or(_ = nil); end
-  def to_maybe; end
-  def to_result; end
-  def to_s; end
-  def value!; end
-  include Anonymous_Dry_Equalizer_11
-  include Dry::Equalizer::Methods
-end
-class Dry::Monads::Validated::Invalid < Dry::Monads::Validated
-  def ===(other); end
-  def alt_map(proc = nil, &block); end
-  def apply(val = nil); end
-  def error; end
-  def fmap(_ = nil); end
-  def initialize(error, trace = nil); end
-  def inspect; end
-  def or(proc = nil, &block); end
-  def to_maybe; end
-  def to_result; end
-  def to_s; end
-  def trace; end
-  include Anonymous_Dry_Equalizer_12
-  include Dry::Equalizer::Methods
-end
-module Dry::Monads::ConversionStubs
-  def self.[](*method_names); end
-end
-module Dry::Monads::ConversionStubs::Methods
-  def self.to_maybe; end
-  def self.to_result; end
-  def self.to_validated; end
-  def to_maybe; end
-  def to_result; end
-  def to_validated; end
-end
-class Dry::Monads::Task::Promise < Concurrent::Promise
-  def on_fulfill(result); end
-  def on_reject(reason); end
-end
-module Anonymous_Module_6
-  def to_maybe(*arg0); end
-  def to_result(*arg0); end
-end
-module Dry::Monads::Task::Mixin
-  def self.[](executor); end
-  include Dry::Monads::Task::Mixin::Constructors
-end
-module Dry::Monads::Task::Mixin::Constructors
-  def Task(&block); end
-end
-module Anonymous_Module_3
-  def to_maybe(*arg0); end
-  def to_validated(*arg0); end
-end
-module Anonymous_Dry_Equalizer_4
-  def cmp?(comparator, other); end
-  def hash; end
-  def inspect; end
-end
-module Anonymous_Dry_Equalizer_5
-  def cmp?(comparator, other); end
-  def hash; end
-  def inspect; end
-end
-module Dry::Monads::Result::Mixin
-  include Dry::Monads::Result::Mixin::Constructors
-end
-module Dry::Monads::Result::Mixin::Constructors
-  def Failure(value = nil, &block); end
-  def Success(value = nil, &block); end
-end
-module Anonymous_Module_7
-  def to_maybe(*arg0); end
-  def to_result(*arg0); end
-end
-module Anonymous_Dry_Equalizer_8
-  def cmp?(comparator, other); end
-  def hash; end
-  def inspect; end
-end
-module Anonymous_Dry_Equalizer_9
-  def cmp?(comparator, other); end
-  def hash; end
-  def inspect; end
-end
-module Dry::Monads::Try::Mixin
-  def Error(error = nil, &block); end
-  def Value(value = nil, exceptions = nil, &block); end
-  include Dry::Monads::Try::Mixin::Constructors
-end
-module Dry::Monads::Try::Mixin::Constructors
-  def Try(*exceptions, &f); end
-end
-module Anonymous_Module_10
-  def to_maybe(*arg0); end
-  def to_result(*arg0); end
-end
-module Anonymous_Dry_Equalizer_11
-  def cmp?(comparator, other); end
-  def hash; end
-  def inspect; end
-end
-module Anonymous_Dry_Equalizer_12
-  def cmp?(comparator, other); end
-  def hash; end
-  def inspect; end
-end
-module Dry::Monads::Validated::Mixin
-  include Dry::Monads::Validated::Mixin::Constructors
-end
-module Dry::Monads::Validated::Mixin::Constructors
-  def Invalid(value = nil, &block); end
-  def Valid(value = nil, &block); end
-end
-class Dry::Monads::List
-  def +(other); end
-  def apply(list = nil); end
-  def bind(*args); end
-  def coerce(other); end
-  def collect; end
-  def deconstruct; end
-  def empty?; end
-  def filter; end
-  def first; end
-  def fmap(*args); end
-  def fold_left(initial); end
-  def fold_right(initial); end
-  def foldl(initial); end
-  def foldr(initial); end
-  def head; end
-  def initialize(value, type = nil); end
-  def inspect; end
-  def last; end
-  def map(&block); end
-  def monad; end
-  def reduce(initial); end
-  def reverse; end
-  def select; end
-  def self.[](*values); end
-  def self.coerce(value, type = nil); end
-  def self.pure(value = nil, type = nil, &block); end
-  def self.unfold(state, type = nil); end
-  def size; end
-  def sort; end
-  def tail; end
-  def to_a; end
-  def to_ary; end
-  def to_monad; end
-  def to_s; end
-  def traverse(proc = nil, &block); end
-  def type; end
-  def typed(type = nil); end
-  def typed?; end
-  def value; end
-  extend Anonymous_Dry_Core_Deprecations_Tagged_13
-  extend Dry::Core::Deprecations::Interface
-  include Anonymous_Dry_Equalizer_14
-  include Dry::Equalizer::Methods
-  include Dry::Monads::Transformer
-end
-module Anonymous_Dry_Core_Deprecations_Tagged_13
-end
-module Anonymous_Dry_Equalizer_14
-  def cmp?(comparator, other); end
-  def hash; end
-  def inspect; end
-end
-class Dry::Monads::List::ListBuilder
-  def [](*args); end
-  def coerce(value); end
-  def initialize(type); end
-  def pure(val = nil, &block); end
-  def self.[](*arg0); end
-  def type; end
-end
-module Dry::Monads::List::Mixin
-  def List(value); end
-end
-module Dry::Monads::Do
-  def self.coerce_to_monad(monads); end
-  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
-  def bind(monads); end
-  def call; end
-end
-class Dry::Monads::Do::Halt < StandardError
-  def initialize(result); end
-  def result; end
-end
-module Dry::Monads::Do::All
-  def self.included(base); end
-  extend Dry::Monads::Do::All::InstanceMixin
-end
-class Dry::Monads::Do::All::MethodTracker < Module
-  def extend_object(target); end
-  def initialize(wrappers); end
-  def wrap_method(target, method); end
-  def wrappers; end
-end
-module Dry::Monads::Do::All::InstanceMixin
-  def extended(object); end
-end
-class Dry::Monads::Lazy < Dry::Monads::Task
-  def force!; end
-  def force; end
-  def inspect; end
-  def self.[](executor, &block); end
-  def self.new(promise = nil, &block); end
-  def to_s; end
-  def value!; end
-end
-module Dry::Monads::Lazy::Mixin
-  include Dry::Monads::Lazy::Mixin::Constructors
-end
-module Dry::Monads::Lazy::Mixin::Constructors
-  def Lazy(&block); end
-end
-class Dry::Monads::Result::Fixed < Module
-  def included(base); end
-  def initialize(error, **_options); end
-  def self.[](error, **options); end
-end