Generate initial signatures

Author: aaronmallen

sig/dry/monads.rbs

@@ -0,0 +1,46 @@
+
+
+module Dry
+  # Common, idiomatic monads for Ruby
+  #
+  # @api public
+  module Monads
+    # @api private
+    def self.loader: () -> untyped
+
+    # @private
+    def self.included: (untyped base) -> untyped
+
+    # Build a module with cherry-picked monads.
+    # It saves a bit of typing when you add multiple
+    # monads to one class. Not loaded monads get loaded automatically.
+    #
+    # @example
+    #   require 'dry/monads'
+    #
+    #   class CreateUser
+    #     include Dry::Monads[:result, :do]
+    #
+    #     def initialize(repo, send_email)
+    #       @repo = repo
+    #       @send_email = send_email
+    #     end
+    #
+    #     def call(name)
+    #       if @repo.user_exist?(name)
+    #         Failure(:user_exists)
+    #       else
+    #         user = yield @repo.add_user(name)
+    #         yield @send_email.(user)
+    #         Success(user)
+    #       end
+    #     end
+    #   end
+    #
+    # @param [Array<Symbol>] monads
+    # @return [Module]
+    # @api public
+    def self.[]: (*untyped monads) -> untyped
+  end
+end
+

sig/dry/monads/all.rbs

@@ -0,0 +1,7 @@
+
+
+module Dry
+  module Monads
+  end
+end
+

sig/dry/monads/constants.rbs

@@ -0,0 +1,8 @@
+
+
+module Dry
+  module Monads
+    include Core::Constants
+  end
+end
+

sig/dry/monads/conversion_stubs.rbs

@@ -0,0 +1,18 @@
+
+
+module Dry
+  module Monads
+    module ConversionStubs
+      def self.[]: (*untyped method_names) -> untyped
+
+      module Methods
+        def self?.to_maybe: () -> untyped
+
+        def self?.to_result: () -> untyped
+
+        def self?.to_validated: () -> untyped
+      end
+    end
+  end
+end
+

sig/dry/monads/curry.rbs

@@ -0,0 +1,12 @@
+
+
+module Dry
+  module Monads
+    # @private
+    module Curry
+      # @private
+      def self.call: (untyped value) -> untyped
+    end
+  end
+end
+

sig/dry/monads/do.rbs

@@ -0,0 +1,102 @@
+
+
+module Dry
+  module Monads
+    # An implementation of do-notation.
+    #
+    # @see Do.for
+    module Do
+      extend Mixin
+
+      VISIBILITY_WORD: untyped
+
+      # @api private
+      class Halt < StandardError
+        # @api private
+        attr_reader result: untyped
+
+        def initialize: (untyped result) -> untyped
+      end
+
+      # @api private
+      class MethodTracker < ::Module
+        # @api private
+        def initialize: (untyped tracked_methods, untyped base, untyped wrapper) -> untyped
+      end
+
+      # Generates a module that passes a block to methods
+      # that either unwraps a single-valued monadic value or halts
+      # the execution.
+      #
+      # @example A complete example
+      #
+      #   class CreateUser
+      #     include Dry::Monads::Result::Mixin
+      #     include Dry::Monads::Try::Mixin
+      #     include Dry::Monads::Do.for(:call)
+      #
+      #     attr_reader :user_repo
+      #
+      #     def initialize(:user_repo)
+      #       @user_repo = user_repo
+      #     end
+      #
+      #     def call(params)
+      #       json = yield parse_json(params)
+      #       hash = yield validate(json)
+      #
+      #       user_repo.transaction do
+      #         user = yield create_user(hash[:user])
+      #         yield create_profile(user, hash[:profile])
+      #       end
+      #
+      #       Success(user)
+      #     end
+      #
+      #     private
+      #
+      #     def parse_json(params)
+      #       Try(JSON::ParserError) {
+      #         JSON.parse(params)
+      #       }.to_result
+      #     end
+      #
+      #     def validate(json)
+      #       UserSchema.(json).to_monad
+      #     end
+      #
+      #     def create_user(user_data)
+      #       Try(Sequel::Error) {
+      #         user_repo.create(user_data)
+      #       }.to_result
+      #     end
+      #
+      #     def create_profile(user, profile_data)
+      #       Try(Sequel::Error) {
+      #         user_repo.create_profile(user, profile_data)
+      #       }.to_result
+      #     end
+      #   end
+      #
+      # @param [Array<Symbol>] methods
+      # @return [Module]
+      def self.for: (*untyped methods) -> untyped
+
+      # @api private
+      def self.included: (untyped base) -> untyped
+
+      # @api private
+      def self.wrap_method: (untyped target, untyped method, untyped visibility) -> untyped
+
+      # @api private
+      def self.method_visibility: (untyped mod, untyped method) -> untyped
+
+      # @api private
+      def self.coerce_to_monad: (untyped monads) -> untyped
+
+      # @api private
+      def self.halt: (untyped result) -> untyped
+    end
+  end
+end
+

sig/dry/monads/do/all.rbs

@@ -0,0 +1,87 @@
+
+
+module Dry
+  module Monads
+    module Do
+      # Do::All automatically wraps methods defined in a class with an unwrapping block.
+      # Similar to what `Do.for(...)` does except wraps every method so you don't have
+      # to list them explicitly.
+      #
+      # @example annotated example
+      #
+      #   require 'dry/monads/do/all'
+      #   require 'dry/monads/result'
+      #
+      #   class CreateUser
+      #     include Dry::Monads::Do::All
+      #     include Dry::Monads::Result::Mixin
+      #
+      #     def call(params)
+      #       # Unwrap a monadic value using an implicitly passed block
+      #       # if `validates` returns Failure, the execution will be halted
+      #       values = yield validate(params)
+      #       user = create_user(values)
+      #       # If another block is passed to a method then takes
+      #       # precedence over the unwrapping block
+      #       safely_subscribe(values[:email]) { Logger.info("Already subscribed") }
+      #
+      #       Success(user)
+      #     end
+      #
+      #     def validate(params)
+      #       if params.key?(:email)
+      #         Success(email: params[:email])
+      #       else
+      #         Failure(:no_email)
+      #       end
+      #     end
+      #
+      #     def create_user(user)
+      #       # Here a block is passed to the method but we don't use it
+      #       UserRepo.new.add(user)
+      #     end
+      #
+      #     def safely_subscribe(email)
+      #       repo = SubscriptionRepo.new
+      #
+      #       if repo.subscribed?(email)
+      #          # This calls the logger because a block
+      #          # explicitly passed from `call`
+      #          yield
+      #       else
+      #         repo.subscribe(email)
+      #       end
+      #     end
+      #   end
+      module All
+        # @private
+        class MethodTracker < ::Module
+          attr_reader wrappers: untyped
+
+          def initialize: (untyped wrappers) -> untyped
+
+          def extend_object: (untyped target) -> untyped
+
+          def wrap_method: (untyped target, untyped method) -> untyped
+        end
+
+        # @api private
+        def self.included: (untyped base) -> untyped
+
+        # @api private
+        def self.wrap_defined_methods: (untyped klass, untyped target) -> untyped
+
+        # @api private
+        module InstanceMixin
+          # @api private
+          def extended: (untyped object) -> untyped
+        end
+
+        extend InstanceMixin
+      end
+    end
+
+    def warn: (untyped message, ?category: untyped, **untyped) -> untyped
+  end
+end
+

sig/dry/monads/do/mixin.rbs

@@ -0,0 +1,47 @@
+
+
+module Dry
+  module Monads
+    module Do
+      # Do notation as a mixin.
+      # You can use it in any place in your code, see examples.
+      #
+      # @example class-level mixin
+      #
+      #   class CreateUser
+      #     extend Dry::Monads::Do::Mixin
+      #     extend Dry::Monads[:result]
+      #
+      #     def self.run(params)
+      #       self.call do
+      #         values = bind Validator.validate(params)
+      #         user = bind UserRepository.create(values)
+      #
+      #         Success(user)
+      #       end
+      #     end
+      #   end
+      #
+      # @example using methods defined on Do
+      #
+      #   create_user = proc do |params|
+      #     Do.() do
+      #       values = bind validate(params)
+      #       user = bind user_repo.create(values)
+      #
+      #       Success(user)
+      #     end
+      #   end
+      #
+      # @api public
+      module Mixin
+        # @api public
+        def call: () -> untyped
+
+        # @api public
+        def bind: (untyped monads) -> untyped
+      end
+    end
+  end
+end
+

sig/dry/monads/errors.rbs

@@ -0,0 +1,23 @@
+
+
+module Dry
+  module Monads
+    # An unsuccessful result of extracting a value from a monad.
+    class UnwrapError < ::StandardError
+      attr_reader receiver: untyped
+
+      def initialize: (untyped receiver) -> untyped
+    end
+
+    # An error thrown on returning a Failure of unknown type.
+    class InvalidFailureTypeError < ::StandardError
+      def initialize: (untyped failure) -> untyped
+    end
+
+    # Improper use of None
+    class ConstructorNotAppliedError < ::NoMethodError
+      def initialize: (untyped method_name, untyped constructor_name) -> untyped
+    end
+  end
+end
+

sig/dry/monads/extensions/pretty_print.rbs

@@ -0,0 +1,20 @@
+
+
+module Dry
+  module Monads
+    module Extensions
+      module PrettyPrint
+        class PrintValue < ::Module
+          def initialize: (untyped constructor, ?accessor: untyped) -> untyped
+        end
+
+        class LazyPrintValue < ::Module
+          def initialize: (untyped constructor, ?success_prefix: untyped, ?error_prefix: untyped) -> untyped
+        end
+      end
+
+      def pretty_print: (untyped pp) -> untyped
+    end
+  end
+end
+