dry-monads 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c819d8b433c150703fa74c233a2079c524e2841ddeb4acf073fef3e16ef54225
-  data.tar.gz: b2da0bd96075be4863bb2073b434489ecae1374ebf0cf5cf55ed11a89c07263f
+  metadata.gz: ae0ce757dc3f6ec60e8fb1d3e111535fe3e32d40956c5e38cdbef583805b5f6a
+  data.tar.gz: 83962c10f05f0a53d37a34c77c4197a799a8a78f7a6de767999a6eebd0f30571
 SHA512:
-  metadata.gz: bbb8cb8fc13031cc1b75e9f830381b29cc89ae4652c58a927c45c474ae93bd13364a190cf0af792586fe25f5a9c3d6611e7dbdce01e63e4347d1fe56774201a4
-  data.tar.gz: 5a116f3c547e15ad14aa7d72894c4cbafb90f893033fa98c141e4e20a2644a48b741e1fcee762e4e417c4c9437803802e441b2ce7d07b4b7791f73f0e4457ca4
+  metadata.gz: 1754fea24d90657ea3947de3c1b4206d22c977ec30546377ccb82c166a898ca8f4dc0b6b21dd384ceea78a706c29c9570951222f48e6a40b661964b1f43ffef2
+  data.tar.gz: 7667bcb8d8a009f68055c9cade624e7276a51749f42fdbfacc8e47b13763e10f57e7e34b00878017498f100f9eae55de72e10b9d8ffcad8d952043311aea74ed

data/.travis.yml

@@ -7,15 +7,15 @@ script:
   - bundle exec rake spec
 before_install:
   - gem update --system
+  - gem install bundler
 after_success:
   - '[ -d coverage ] && bundle exec codeclimate-test-reporter'
 rvm:
-  - 2.2.10
-  - 2.3.7
-  - 2.4.4
-  - 2.5.1
-  - jruby-9.2.0.0
-  - ruby-head
+  - 2.3.8
+  - 2.4.5
+  - 2.5.3
+  - 2.6.0
+  - jruby-9.2.4.0
 env:
   global:
     - JRUBY_OPTS='--dev -J-Xmx1024M'

data/CHANGELOG.md

@@ -1,3 +1,93 @@
+# v1.2.0 2019-01-12
+
+## BREAKING CHANGES
+
+* Support for Ruby 2.2 was dropped. Ruby 2.2 reached its EOL on March 31, 2018.
+
+## Added
+
+* Most of constructors now have `call` alias so you can compose them with Procs nicely if you've switched to Ruby 2.6 (flash-gordon)
+  ```ruby
+  pipe = -> x { x.upcase } >> Success
+  pipe.('foo') # => Success('FOO')
+  ```
+* `List#collect` gathers `Some` values from the list (flash-gordon)
+  ```ruby
+  include Dry::Monads::List::Mixin
+  include Dry::Monads::Maybe::Mixin
+  # ...
+  List[10, 5, 0].collect do |divisor|
+    if divisor.zero?
+      None()
+    else
+      Some(n / divisor)
+    end
+  end
+  # => List[4, 2]
+  ```
+
+  Without block:
+
+  ```ruby
+  List[Some(5), None(), Some(3)].collect.map { |x| x * 2 }
+  # => [10, 6]
+  ```
+
+* Right-biased monads got `#flatten` and `#and` (falsh-gordon)
+
+  `#flatten` removes one level of monadic structure, it's useful when you're dealing with things like `Maybe` of `Maybe` of something:
+  ```ruby
+  include Dry::Monads::Maybe::Mixin
+
+  Some(Some(1)).flatten # => Some(1)
+  Some(None()).flatten # => None
+  None().flatten # => None
+  ```
+  In contrast to `Array#flatten`, dry-monads' version removes only 1 level of nesting, that is always acts as `Array#flatten(1)`:
+  ```ruby
+  Some(Some(Some(1))).flatten # => Some(Some(1))
+  ```
+  `#and` is handy for combining two monadic values and working with them at once:
+  ```ruby
+  include Dry::Monads::Maybe::Mixin
+
+  # using block
+  Some(5).and(Some(3)) { |x, y| x + y } # => Some(8)
+  # without block
+  Some(5).and(Some(3)) # => Some([5, 3])
+  # other cases
+  Some(5).and(None()) # => None()
+  None().and(Some(5)) # => None()
+  ```
+
+* Concise imports with `Dry::Monads.[]`. You're no longer required to require all desired monads and include them one-by-one, the `[]` method handles it for you (flash-gordon)
+
+  ```ruby
+  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
+  ```
+* `Task.failed` is a counterpart of `Task.pure`, accepts an exception and returns a failed task immediately (flash-gordon)
+
+[Compare v1.1.0...v1.2.0](https://github.com/dry-rb/dry-monads/compare/v1.1.0...v1.2.0)
+
 # v1.1.0 2018-10-16
 
 ## Fixed

data/dry-monads.gemspec

@@ -25,7 +25,7 @@ Gem::Specification.new do |spec|
   spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
-  spec.required_ruby_version = ">= 2.2.0"
+  spec.required_ruby_version = ">= 2.3.0"
   spec.add_dependency 'dry-equalizer'
   spec.add_dependency 'dry-core', '~> 0.4', '>= 0.4.4'
   spec.add_dependency 'concurrent-ruby', '~> 1.0'

data/lib/dry/monads.rb

@@ -1,14 +1,54 @@
+require 'dry/monads/registry'
+
 module Dry
   # Common, idiomatic monads for Ruby
   #
   # @api public
   module Monads
     def self.included(base)
-      if const_defined?(:CONSTRUCTORS)
-        base.include(*CONSTRUCTORS)
+      if all_loaded?
+        base.include(*constructors)
       else
         raise "Load all monads first with require 'dry/monads/all'"
       end
     end
+
+    # 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.[](*monads)
+      monads.sort!
+      @mixins.fetch_or_store(monads.hash) do
+        monads.each { |m| load_monad(m) }
+        mixins = monads.map { |m| registry.fetch(m) }
+        Module.new { include(*mixins) }.freeze
+      end
+    end
   end
 end

data/lib/dry/monads/all.rb

@@ -1,26 +1,9 @@
 require 'dry/monads'
-require 'dry/monads/do'
-require 'dry/monads/lazy'
-require 'dry/monads/list'
-require 'dry/monads/maybe'
-require 'dry/monads/result'
-require 'dry/monads/result/fixed'
-require 'dry/monads/task'
-require 'dry/monads/try'
-require 'dry/monads/validated'
+require 'dry/monads/registry'
 
 module Dry
   module Monads
-    # List of monad constructors
-    CONSTRUCTORS = [
-      Lazy::Mixin::Constructors,
-      Maybe::Mixin::Constructors,
-      Result::Mixin::Constructors,
-      Task::Mixin::Constructors,
-      Try::Mixin::Constructors,
-      Validated::Mixin::Constructors,
-    ].freeze
-
-    extend(*CONSTRUCTORS)
+    known_monads.each { |m| load_monad(m) }
+    extend(*constructors)
   end
 end

data/lib/dry/monads/do/all.rb

@@ -77,6 +77,11 @@ module Dry
 
                 base.prepend(wrappers[base])
               end
+
+              def included(base)
+                super
+                Dry::Monads::Do::All.included(base)
+              end
             end
           end
 
@@ -101,5 +106,8 @@ module Dry
         end
       end
     end
+
+    require 'dry/monads/registry'
+    register_mixin(:do, Do::All)
   end
 end

data/lib/dry/monads/lazy.rb

@@ -78,6 +78,7 @@ module Dry
       end
     end
 
-    extend Lazy::Mixin::Constructors
+    require 'dry/monads/registry'
+    register_mixin(:lazy, Lazy::Mixin)
   end
 end

data/lib/dry/monads/list.rb

@@ -308,6 +308,39 @@ module Dry
         self
       end
 
+      # Iterates over the list and collects Some values.
+      #
+      # @example with block syntax
+      #   n = 20
+      #   List[10, 5, 0].collect do |divisor|
+      #     if divisor.zero?
+      #       None()
+      #     else
+      #       Some(n / divisor)
+      #     end
+      #   end
+      #   # => List[4, 2]
+      #
+      # @example without block
+      #   List[Some(5), None(), Some(3)].collect.map { |x| x * 2 }
+      #   # => [10, 6]
+      #
+      # @return [List]
+      def collect
+        if block_given?
+          collected = value.each_with_object([]) do |x, ys|
+            y = yield(x)
+            ys << y.value! if y.some?
+          end
+
+          List.new(collected)
+        else
+          Enumerator.new do |g|
+            value.each { |x| g << x.value! if x.some? }
+          end
+        end
+      end
+
       private
 
       def coerce(other)
@@ -376,6 +409,9 @@ module Dry
         end
       end
     end
+
+    require 'dry/monads/registry'
+    register_mixin(:list, List::Mixin)
   end
 end
 

data/lib/dry/monads/maybe.rb

@@ -296,5 +296,8 @@ module Dry
         end
       end
     end
+
+    require 'dry/monads/registry'
+    register_mixin(:maybe, Maybe::Mixin)
   end
 end

data/lib/dry/monads/registry.rb

@@ -0,0 +1,70 @@
+require 'concurrent/map'
+
+module Dry
+  # Common, idiomatic monads for Ruby
+  #
+  # @api private
+  module Monads
+    @registry = {}
+    @constructors = nil
+    @paths = {
+      do: 'dry/monads/do/all',
+      lazy: 'dry/monads/lazy',
+      list: 'dry/monads/list',
+      maybe: 'dry/monads/maybe',
+      task: 'dry/monads/task',
+      try: 'dry/monads/try',
+      validated: 'dry/monads/validated',
+      result: [
+        'dry/monads/result',
+        'dry/monads/result/fixed'
+      ]
+    }.freeze
+    @mixins = Concurrent::Map.new
+
+    class << self
+      private
+
+      attr_reader :registry
+
+      def registry=(registry)
+        @constructors = nil
+        @registry = registry.dup.freeze
+      end
+      protected :registry=
+
+      # @private
+      def register_mixin(name, mod)
+        if registry.key?(name)
+          raise ArgumentError, "#{ name.inspect } is already registered"
+        end
+        self.registry = registry.merge(name => mod)
+      end
+
+      # @private
+      def known_monads
+        @paths.keys
+      end
+
+      # @private
+      def load_monad(name)
+        path = @paths.fetch(name) {
+          raise ArgumentError, "#{ name.inspect } is not a known monad"
+        }
+        Array(path).each { |p| require p }
+      end
+
+      # @private
+      def constructors
+        @constructors ||= registry.values.map { |m|
+          m::Constructors if m.const_defined?(:Constructors)
+        }.compact
+      end
+
+      # @private
+      def all_loaded?
+        registry.size == @paths.size
+      end
+    end
+  end
+end

data/lib/dry/monads/result.rb

@@ -124,6 +124,8 @@ module Dry
         include RightBiased::Left
         include Dry::Equalizer(:failure)
 
+        singleton_class.send(:alias_method, :call, :new)
+
         # Returns a constructor proc
         #
         # @return [Proc]
@@ -365,5 +367,8 @@ module Dry
         end
       end
     end
+
+    require 'dry/monads/registry'
+    register_mixin(:result, Result::Mixin)
   end
 end

data/lib/dry/monads/right_biased.rb

@@ -21,6 +21,7 @@ module Dry
           def m.to_proc
             @to_proc ||= method(:new).to_proc
           end
+          m.singleton_class.send(:alias_method, :call, :new)
         end
 
         # Unwraps the underlying value
@@ -144,6 +145,47 @@ module Dry
           fmap { Unit }
         end
 
+        # Removes one level of monad structure by joining two values.
+        #
+        # @example
+        #   include Dry::Monads::Result::Mixin
+        #   Success(Success(5)).flatten # => Success(5)
+        #   Success(Failure(:not_a_number)).flatten # => Failure(:not_a_number)
+        #   Failure(:not_a_number).flatten # => Failure(:not_a_number)
+        #
+        # @return [RightBiased::Right,RightBiased::Left]
+        def flatten
+          bind(&:itself)
+        end
+
+        # Combines the wrapped value with another monadic value.
+        # If both values are right-sided, yields a block and passes a tuple
+        # of values there. If no block given, returns a tuple of values wrapped with
+        # a monadic structure.
+        #
+        # @example
+        #   include Dry::Monads::Result::Mixin
+        #
+        #   Success(3).and(Success(5)) # => Success([3, 5])
+        #   Success(3).and(Failure(:not_a_number)) # => Failure(:not_a_number)
+        #   Failure(:not_a_number).and(Success(5)) # => Failure(:not_a_number)
+        #   Success(3).and(Success(5)) { |a, b| a + b } # => Success(8)
+        #
+        # @param mb [RightBiased::Left,RightBiased::Right]
+        #
+        # @return [RightBiased::Left,RightBiased::Right]
+        def and(mb)
+          bind do |a|
+            mb.fmap do |b|
+              if block_given?
+                yield([a, b])
+              else
+                [a, b]
+              end
+            end
+          end
+        end
+
         private
 
         # @api private
@@ -243,7 +285,23 @@ module Dry
         #
         # @return [RightBiased::Left]
         def discard
-          fmap { Unit }
+          self
+        end
+
+        # Returns self back. It exists to keep the interface
+        # identical to that of {RightBiased::Right}.
+        #
+        # @return [RightBiased::Left]
+        def flatten
+          self
+        end
+
+        # Returns self back. It exists to keep the interface
+        # identical to that of {RightBiased::Right}.
+        #
+        # @return [RightBiased::Left]
+        def and(_)
+          self
         end
       end
     end

data/lib/dry/monads/task.rb

@@ -54,7 +54,7 @@ module Dry
           new(Promise.execute(executor: executor, &block))
         end
 
-        # Returns a complete task from the given value
+        # Returns a completed task from the given value
         #
         # @overload pure(value)
         #   @param value [Object]
@@ -68,6 +68,14 @@ module Dry
           v = Undefined.default(value, block)
           new(Promise.fulfill(v))
         end
+
+        # Returns a failed task from the given exception
+        #
+        # @param exc [Exception]
+        # @return [Task]
+        def failed(exc)
+          new(Promise.reject(exc))
+        end
       end
 
       include ConversionStubs[:to_maybe, :to_result]
@@ -299,6 +307,7 @@ module Dry
       end
     end
 
-    extend Task::Mixin::Constructors
+    require 'dry/monads/registry'
+    register_mixin(:task, Task::Mixin)
   end
 end

data/lib/dry/monads/try.rb

@@ -168,6 +168,8 @@ module Dry
         include Dry::Equalizer(:exception)
         include RightBiased::Left
 
+        singleton_class.send(:alias_method, :call, :new)
+
         # @param exception [Exception]
         def initialize(exception)
           @exception = exception
@@ -273,6 +275,7 @@ module Dry
       end
     end
 
-    extend Try::Mixin::Constructors
+    require 'dry/monads/registry'
+    register_mixin(:try, Try::Mixin)
   end
 end

data/lib/dry/monads/validated.rb

@@ -296,5 +296,8 @@ module Dry
         end
       end
     end
+
+    require 'dry/monads/registry'
+    register_mixin(:validated, Validated::Mixin)
   end
 end

data/lib/dry/monads/version.rb

@@ -1,6 +1,6 @@
 module Dry
   module Monads
     # @private
-    VERSION = '1.1.0'.freeze
+    VERSION = '1.2.0'.freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dry-monads
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Nikita Shilnikov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-10-16 00:00:00.000000000 Z
+date: 2019-01-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-equalizer
@@ -147,6 +147,7 @@ files:
 - lib/dry/monads/lazy.rb
 - lib/dry/monads/list.rb
 - lib/dry/monads/maybe.rb
+- lib/dry/monads/registry.rb
 - lib/dry/monads/result.rb
 - lib/dry/monads/result/fixed.rb
 - lib/dry/monads/right_biased.rb
@@ -173,15 +174,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.2.0
+      version: 2.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.3
+rubygems_version: 3.0.1
 signing_key: 
 specification_version: 4
 summary: Common monads for Ruby.