dry-monads 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f0acc62dda69a191664c47cae89550fa7e248b34
-  data.tar.gz: afd7e702a5dfb513b1f797890cdc465d5c1aaa57
+  metadata.gz: 2d763397f947c61f8b46fa0997e72b24b0c6b896
+  data.tar.gz: 99c80e46741e351e19f107dd71c01e8a7a66beaf
 SHA512:
-  metadata.gz: cbfa1c6b7446d082f00539c7764becdccc2ccdcc6045d7ff2c4006aea2c98651ac189a4db88b3fb1585ded0b375597e08a9248827651d61350e581a6fd908b3b
-  data.tar.gz: 2f6116133861c76fc8f7975c8e44badd1c901de101fe4f91b9c7fe28242a89534fd1b1ae904481cd441a02bf76be9064377b1fac48b84142e843bce4ff9e19d4
+  metadata.gz: 134d7bc216b65df0b1ed974fc68d04521ec1766c527848c4df473057ae5175e42447cee84073e69b44d4fe3a8a9399918ffb8c7119d6eb65abf0f7aa873d521c
+  data.tar.gz: b25676d21087677f2a2276b0e09abb3e672ce0d12f4c50aeee88c72afa8aff0d4e6df70ace29efc00b699094b94fe44f14753063d3f63bc2653bc8c50839d5d5

data/.travis.yml

@@ -1,25 +1,23 @@
 language: ruby
 dist: trusty
-sudo: required
+sudo: false
 cache: bundler
 bundler_args: --without benchmarks
 script:
   - bundle exec rake spec
-  - bundle exec rubocop
 after_success:
-  - '[ "$TRAVIS_RUBY_VERSION" = "2.3.1" ] && [ "$TRAVIS_BRANCH" = "master" ] && bundle exec codeclimate-test-reporter'
+  # Send coverage report from the job #1 == current MRI release
+  - '[ "${TRAVIS_JOB_NUMBER#*.}" = "1" ] && [ "$TRAVIS_BRANCH" = "master" ] && bundle exec codeclimate-test-reporter'
 rvm:
+  - 2.4.0
+  - 2.3.3
+  - 2.2.6
   - 2.1.10
-  - 2.2.5
-  - 2.3.1
-  - jruby-9.1.5.0
+  - jruby-9.1.7.0
   - ruby-head
-  - rbx-3
 env:
   global:
     - JRUBY_OPTS='--dev -J-Xmx1024M'
-before_install:
-  - gem update bundler
 matrix:
   allow_failures:
     - rvm: ruby-head
@@ -27,7 +25,9 @@ matrix:
     - rvm: rbx-3
   include:
     - rvm: jruby-head
-      before_install: gem install bundler --no-ri --no-rdoc
+      before_install: gem update bundler
+    - rvm: rbx-3
+      before_install: gem update bundler
 
 notifications:
   email:

data/CHANGELOG.md

@@ -0,0 +1,67 @@
+# v0.3.0 2017-03-16
+
+## Added
+* Added `Either#either` that accepts two callbacks, runs the first if it is `Right` and the second otherwise (nkondratyev)
+* Added `#fmap2` and `#fmap3` for mapping over nested structures like `List Either` and `Either Some` (flash-gordon)
+* Added `Try#value_or` (dsounded)
+* Added the `List` monad which acts as an immutable `Array` and plays nice with other monads. A common example is a list of `Either`s (flash-gordon)
+* `#bind` made to work with keyword arguments as extra parameters to the block (flash-gordon)
+* Added `List#traverse` that "flips" the list with an embedded monad (flash-gordon + damncabbage)
+* Added `#tee` for all right-biased monads (flash-gordon)
+
+[Compare v0.3.0...v0.2.1](https://github.com/dry-rb/dry-monads/compare/v0.2.1...v0.3.0)
+
+# v0.2.1 2016-11-13
+
+## Added
+
+* Added `Either#tee` that is similar to `Object#tap` but executes the block only for `Right` instances (saverio-kantox)
+
+## Fixed
+
+* `Right(nil).to_maybe` now returns `None` with a warning instead of failing (orisaka)
+* `Some#value_or` doesn't require an argument because `None#value_or` doesn't require it either if a block was passed (flash-gordon)
+
+[Compare v0.2.1...v0.2.0](https://github.com/dry-rb/dry-monads/compare/v0.2.0...v0.2.1)
+
+# v0.2.0 2016-09-18
+
+## Added
+
+* Added `Maybe#to_json` as an opt-in extension for serialization to JSON (rocknruby)
+* Added `Maybe#value_or` which returns you the underlying value with a fallback in a single method call (dsounded)
+
+[Compare v0.1.1...v0.2.0](https://github.com/dry-rb/dry-monads/compare/v0.1.1...v0.2.0)
+
+# v0.1.1 2016-08-25
+
+## Fixed
+
+* Added explicit requires of `dry-equalizer`. This allows to safely load only specific monads (artofhuman)
+
+[Compare v0.1.0...v0.1.1](https://github.com/dry-rb/dry-monads/compare/v0.1.0...v0.1.1)
+
+# v0.1.0 2016-08-23
+
+## Added
+
+* Support for passing extra arguments to the block in `.bind` and `.fmap` (flash-gordon)
+
+## Changed
+
+* Dropped MRI 2.0 support (flash-gordon)
+
+[Compare v0.0.2...v0.1.0](https://github.com/dry-rb/dry-monads/compare/v0.0.2...v0.1.0)
+
+# v0.0.2 2016-06-29
+
+## Added
+
+* Added `Either#to_either` so that you can rely on duck-typing when you work with different types of monads (timriley)
+* Added `Maybe#to_maybe` for consistency with `#to_either` (flash-gordon)
+
+[Compare v0.0.1...v0.0.2](https://github.com/dry-rb/dry-monads/compare/v0.0.1...v0.0.2)
+
+# v0.0.1 2016-05-02
+
+Initial release containing `Either`, `Maybe`, and `Try` monads.

data/Gemfile

@@ -8,6 +8,6 @@ group :test do
 end
 
 group :tools do
-  gem 'rubocop'
+  gem 'pry-byebug', platform: :mri
   gem 'pry'
 end

data/bin/console

@@ -12,3 +12,5 @@ M = Dry::Monads
 require 'pry'
 
 binding.pry
+
+p

data/lib/dry/monads.rb

@@ -1,6 +1,7 @@
 require 'dry/monads/either'
 require 'dry/monads/maybe'
 require 'dry/monads/try'
+require 'dry/monads/list'
 
 module Dry
   # @api public

data/lib/dry/monads/either.rb

@@ -1,5 +1,8 @@
 require 'dry/equalizer'
 
+require 'dry/monads/right_biased'
+require 'dry/monads/transformer'
+
 module Dry
   module Monads
     # Represents a value which is either correct or an error.
@@ -7,19 +10,19 @@ module Dry
     # @api public
     class Either
       include Dry::Equalizer(:right, :left)
-      attr_reader :right, :left
+      include Transformer
 
-      # Returns true for an instance of a {Either::Right} monad.
-      def right?
-        is_a? Right
-      end
-      alias success? right?
+      attr_reader :right, :left
 
-      # Returns true for an instance of a {Either::Left} monad.
-      def left?
-        is_a? Left
+      class << self
+        # Wraps the given value with Right
+        #
+        # @param value [Object] the value to be stored inside Right
+        # @return [Either::Right]
+        def pure(value)
+          Right.new(value)
+        end
       end
-      alias failure? left?
 
       # Returns self, added to keep the interface compatible with other monads.
       #
@@ -28,10 +31,20 @@ module Dry
         self
       end
 
+      # Returns the Either monad.
+      # This is how we're doing polymorphism in Ruby 😕
+      #
+      # @return [Monad]
+      def monad
+        Either
+      end
+
       # Represents a value that is in a correct state, i.e. everything went right.
       #
       # @api public
       class Right < Either
+        include RightBiased::Right
+
         alias value right
 
         # @param right [Object] a value in a correct state
@@ -39,27 +52,24 @@ module Dry
           @right = right
         end
 
-        # Calls the passed in Proc object with value stored in self
-        # and returns the result.
-        #
-        # If proc is nil, it expects a block to be given and will yield to it.
-        #
-        # @example
-        #   Dry::Monads.Right(4).bind(&:succ) # => 5
+        # Apply the second function to value.
         #
-        # @param [Array<Object>] args arguments that will be passed to a block
-        #                             if one was given, otherwise the first
-        #                             value assumed to be a Proc (callable)
-        #                             object and the rest of args will be passed
-        #                             to this object along with the internal value
-        # @return [Object] result of calling proc or block on the internal value
-        def bind(*args)
-          if block_given?
-            yield(value, *args)
-          else
-            args[0].call(value, *args.drop(1))
-          end
+        # @api public
+        def either(_, f)
+          f.call(value)
+        end
+
+        # Returns false
+        def left?
+          false
         end
+        alias failure? left?
+
+        # Returns true
+        def right?
+          true
+        end
+        alias success? right?
 
         # Does the same thing as #bind except it also wraps the value
         # in an instance of Either::Right monad. This allows for easier
@@ -68,33 +78,12 @@ module Dry
         # @example
         #   Dry::Monads.Right(4).fmap(&:succ).fmap(->(n) { n**2 }) # => Right(25)
         #
-        # @param [Array<Object>] args arguments will be transparently passed through to #bind
+        # @param args [Array<Object>] arguments will be transparently passed through to #bind
         # @return [Either::Right]
         def fmap(*args, &block)
           Right.new(bind(*args, &block))
         end
 
-        # Does the same thing as #bind except it returns the original monad
-        # when the result is a Right.
-        #
-        # @example
-        #   Dry::Monads.Right(4).tee { Right('ok') } # => Right(4)
-        #   Dry::Monads.Right(4).tee { Left('fail') } # => Left('fail')
-        #
-        # @param [Array<Object>] args arguments will be transparently passed through to #bind
-        # @return [Either]
-        def tee(*args, &block)
-          bind(*args, &block).bind { self }
-        end
-
-        # Ignores arguments and returns self. It exists to keep the interface
-        # identical to that of {Either::Left}.
-        #
-        # @return [Either::Right]
-        def or(*)
-          self
-        end
-
         # @return [String]
         def to_s
           "Right(#{value.inspect})"
@@ -112,6 +101,8 @@ module Dry
       #
       # @api public
       class Left < Either
+        include RightBiased::Left
+
         alias value left
 
         # @param left [Object] a value in an error state
@@ -119,29 +110,24 @@ module Dry
           @left = left
         end
 
-        # Ignores the input parameter and returns self. It exists to keep the interface
-        # identical to that of {Either::Right}.
+        # Apply the first function to value.
         #
-        # @return [Either::Left]
-        def bind(*)
-          self
+        # @api public
+        def either(f, _)
+          f.call(value)
         end
 
-        # Ignores the input parameter and returns self. It exists to keep the interface
-        # identical to that of {Either::Right}.
-        #
-        # @return [Either::Left]
-        def fmap(*)
-          self
+        # Returns true
+        def left?
+          true
         end
+        alias failure? left?
 
-        # Ignores the input parameter and returns self. It exists to keep the interface
-        # identical to that of {Either::Right}.
-        #
-        # @return [Either::Left]
-        def tee(*)
-          self
+        # Returns false
+        def right?
+          false
         end
+        alias success? right?
 
         # If a block is given passes internal value to it and returns the result,
         # otherwise simply returns the parameter val.
@@ -149,7 +135,7 @@ module Dry
         # @example
         #   Dry::Monads.Left(ArgumentError.new('error message')).or(&:message) # => "error message"
         #
-        # @param [Array<Object>] args arguments that will be passed to a block
+        # @param args [Array<Object>] arguments that will be passed to a block
         #                             if one was given, otherwise the first
         #                             value will be returned
         # @return [Object]
@@ -161,6 +147,18 @@ module Dry
           end
         end
 
+        # A lifted version of `#or`. Wraps the passed value or the block result with Either::Right.
+        #
+        # @example
+        #   Dry::Monads.Left.new('no value').or_fmap('value') # => Right("value")
+        #   Dry::Monads.Left.new('no value').or_fmap { 'value' } # => Right("value")
+        #
+        # @param args [Array<Object>] arguments will be passed to the underlying `#or` call
+        # @return [Either::Right] Wrapped value
+        def or_fmap(*args, &block)
+          Right.new(self.or(*args, &block))
+        end
+
         # @return [String]
         def to_s
           "Left(#{value.inspect})"

data/lib/dry/monads/list.rb

@@ -0,0 +1,285 @@
+require 'dry/equalizer'
+require 'dry/monads/maybe'
+require 'dry/monads/transformer'
+
+module Dry
+  module Monads
+    class List
+      class << self
+        # Builds a list.
+        #
+        # @param values [Array<Object>] List elements
+        # @return [List]
+        def [](*values)
+          new(values)
+        end
+
+        # Coerces a value to a list. `nil` will be coerced to an empty list.
+        #
+        # @param value [Object] Value
+        # @param type [Monad] Embedded monad type (used in case of list of monadic values)
+        # @return [List]
+        def coerce(value, type = nil)
+          if value.nil?
+            List.new([], type)
+          elsif value.respond_to?(:to_ary)
+            List.new(value.to_ary, type)
+          else
+            raise ArgumentError, "Can't coerce #{value.inspect} to List"
+          end
+        end
+
+        # Wraps a value with a list.
+        #
+        # @param value [Object] any object
+        # @return [List]
+        def pure(value, type = nil)
+          new([value], type)
+        end
+      end
+
+      include Dry::Equalizer(:value, :type)
+      include Transformer
+
+      # Internal array value
+      attr_reader :value, :type
+
+      # @api private
+      def initialize(value, type = nil)
+        @value = value
+        @type = type
+      end
+
+      # Lifts a block/proc and runs it against each member of the list.
+      # The block must return a value coercible to a list.
+      # As in other monads if no block given the first argument will
+      # be treated as callable and used instead.
+      #
+      # @example
+      #   Dry::Monads::List[1, 2].bind { |x| [x + 1] } # => List[2, 3]
+      #   Dry::Monads::List[1, 2].bind(-> x { [x, x + 1] }) # => List[1, 2, 2, 3]
+      #
+      # @param args [Array<Object>] arguments will be passed to the block or proc
+      # @return [List]
+      def bind(*args)
+        if block_given?
+          List.coerce(value.map { |v| yield(v, *args) }.reduce([], &:+))
+        else
+          obj, *rest = args
+          List.coerce(value.map { |v| obj.(v, *rest) }.reduce([], &:+))
+        end
+      end
+
+      # Maps a block over the list. Acts as `Array#map`.
+      # As in other monads if no block given the first argument will
+      # be treated as callable and used instead.
+      #
+      # @example
+      #   Dry::Monads::List[1, 2].fmap { |x| x + 1 } # => List[2, 3]
+      #
+      # @param args [Array<Object>] arguments will be passed to the block or proc
+      # @return [List]
+      def fmap(*args)
+        if block_given?
+          List.new(value.map { |v| yield(v, *args) })
+        else
+          obj, *rest = args
+          List.new(value.map { |v| obj.(v, *rest) })
+        end
+      end
+
+      # Maps a block over the list. Acts as `Array#map`.
+      # Requires a block.
+      #
+      # @return [List]
+      def map(&block)
+        if block
+          fmap(block)
+        else
+          raise ArgumentError, "Missing block"
+        end
+      end
+
+      # Concatenates two lists.
+      #
+      # @example
+      #   Dry::Monads::List[1, 2] + Dry::Monads::List[3, 4] # => List[1, 2, 3, 4]
+      #
+      # @param other [List] Other list
+      # @return [List]
+      def +(other)
+        List.new(to_ary + other.to_ary)
+      end
+
+      # Returns a string representation of the list.
+      #
+      # @example
+      #   Dry::Monads::List[1, 2, 3].inspect # => "List[1, 2, 3]"
+      #
+      # @return [String]
+      def inspect
+        "List#{ value.inspect }"
+      end
+      alias_method :to_s, :inspect
+
+      # Coerces to an array
+      alias_method :to_ary, :value
+      alias_method :to_a, :to_ary
+
+      # Returns the first element.
+      #
+      # @return [Object]
+      def first
+        value.first
+      end
+
+      # Returns the last element.
+      #
+      # @return [Object]
+      def last
+        value.last
+      end
+
+      # Folds the list from the left.
+      #
+      # @param initial [Object] Initial value
+      # @return [Object]
+      def fold_left(initial)
+        value.reduce(initial) { |acc, v| yield(acc, v) }
+      end
+      alias_method :foldl, :fold_left
+      alias_method :reduce, :fold_left
+
+      # Folds the list from the right.
+      #
+      # @param initial [Object] Initial value
+      # @return [Object]
+      def fold_right(initial)
+        value.reverse.reduce(initial) { |a, b| yield(b, a) }
+      end
+      alias_method :foldr, :fold_right
+
+      # Whether the list is empty.
+      #
+      # @return [TrueClass, FalseClass]
+      def empty?
+        value.empty?
+      end
+
+      # Sorts the list.
+      #
+      # @return [List]
+      def sort
+        coerce(value.sort)
+      end
+
+      # Filters elements with a block
+      #
+      # @return [List]
+      def filter
+        coerce(value.select { |e| yield(e) })
+      end
+      alias_method :select, :filter
+
+      # List size.
+      #
+      # @return [Integer]
+      def size
+        value.size
+      end
+
+      # Reverses the list.
+      #
+      # @return [List]
+      def reverse
+        coerce(value.reverse)
+      end
+
+      # Returns the first element wrapped with a `Maybe`.
+      #
+      # @return [Maybe<Object>]
+      def head
+        Maybe.coerce(value.first)
+      end
+
+      # Returns list's tail.
+      #
+      # @return [List]
+      def tail
+        coerce(value.drop(1))
+      end
+
+      # Turns the list into a types one.
+      # Type is required for some operations like .traverse.
+      #
+      # @param type [Monad] Monad instance
+      # @return [List] Typed list
+      def typed(type = nil)
+        if type.nil?
+          if size.zero?
+            raise ArgumentError, "Cannot infer monad for an empty list"
+          else
+            self.class.new(value, value[0].monad)
+          end
+        else
+          self.class.new(value, type)
+        end
+      end
+
+      # Whether the list is types
+      #
+      # @return [Boolean]
+      def typed?
+        !type.nil?
+      end
+
+      # Traverses the list with a block (or without it).
+      # This methods "flips" List structure with the given monad (obtained from the type).
+      # Note that traversing requires the list to be types.
+      # Also if a block given, its returning type must be equal list's type.
+      #
+      # @example
+      #   List<Either>[Right(1), Right(2)].traverse # => Right([1, 2])
+      #   List<Maybe>[Some(1), None, Some(3)].traverse # => None
+      #
+      # @return [Monad] Result is a monadic value
+      def traverse
+        unless typed?
+          raise StandardError, "Cannot traverse an untyped list"
+        end
+
+        foldl(type.pure(EMPTY)) { |acc, el|
+          acc.bind { |unwrapped|
+            mapped = block_given? ? yield(el) : el
+            mapped.fmap { |i| unwrapped + List[i] }
+          }
+        }
+      end
+
+      # Returns the List monad.
+      #
+      # @return [Monad]
+      def monad
+        List
+      end
+
+      private
+
+      def coerce(other)
+        self.class.coerce(other)
+      end
+
+      # Empty list
+      EMPTY = List.new([].freeze).freeze
+
+      module Mixin
+        List = List
+        L = List
+
+        def List(value)
+          List.coerce(value)
+        end
+      end
+    end
+  end
+end

data/lib/dry/monads/maybe.rb

@@ -1,5 +1,8 @@
 require 'dry/equalizer'
 
+require 'dry/monads/right_biased'
+require 'dry/monads/transformer'
+
 module Dry
   module Monads
     # Represents a value which can exist or not, i.e. it could be nil.
@@ -7,15 +10,27 @@ module Dry
     # @api public
     class Maybe
       include Dry::Equalizer(:value)
+      include Transformer
 
-      # Lifts the given value into Maybe::None or Maybe::Some monad.
-      #
-      # @param value [Object] the value to be stored in the monad
-      # @return [Maybe::Some, Maybe::None]
-      def self.lift(value)
-        if value.nil?
-          None.instance
-        else
+      class << self
+        # Wraps the given value with into a Maybe object.
+        #
+        # @param value [Object] the value to be stored in the monad
+        # @return [Maybe::Some, Maybe::None]
+        def coerce(value)
+          if value.nil?
+            None.instance
+          else
+            Some.new(value)
+          end
+        end
+        alias_method :lift, :coerce
+
+        # Wraps the given value with `Some`.
+        #
+        # @param value [Object] the value to be stored inside Some
+        # @return [Maybe::Some]
+        def pure(value)
           Some.new(value)
         end
       end
@@ -37,10 +52,20 @@ module Dry
         self
       end
 
+      # Returns the Maybe monad.
+      # This is how we're doing polymorphism in Ruby 😕
+      #
+      # @return [Monad]
+      def monad
+        Maybe
+      end
+
       # Represents a value that is present, i.e. not nil.
       #
       # @api public
       class Some < Maybe
+        include RightBiased::Right
+
         attr_reader :value
 
         def initialize(value)
@@ -48,28 +73,6 @@ module Dry
           @value = value
         end
 
-        # Calls the passed in Proc object with value stored in self
-        # and returns the result.
-        #
-        # If proc is nil, it expects a block to be given and will yield to it.
-        #
-        # @example
-        #   Dry::Monads.Some(4).bind(&:succ) # => 5
-        #
-        # @param [Array<Object>] args arguments that will be passed to a block
-        #                             if one was given, otherwise the first
-        #                             value assumed to be a Proc (callable)
-        #                             object and the rest of args will be passed
-        #                             to this object along with the internal value
-        # @return [Object] result of calling proc or block on the internal value
-        def bind(*args)
-          if block_given?
-            yield(value, *args)
-          else
-            args[0].call(value, *args.drop(1))
-          end
-        end
-
         # Does the same thing as #bind except it also wraps the value
         # in an instance of Maybe::Some monad. This allows for easier
         # chaining of calls.
@@ -77,28 +80,13 @@ module Dry
         # @example
         #   Dry::Monads.Some(4).fmap(&:succ).fmap(->(n) { n**2 }) # => Some(25)
         #
-        # @param [Array<Object>] args arguments will be transparently passed through to #bind
+        # @param args [Array<Object>] arguments will be transparently passed through to #bind
         # @return [Maybe::Some, Maybe::None] Lifted result, i.e. nil will be mapped to None,
         #                                    other values will be wrapped with Some
         def fmap(*args, &block)
           self.class.lift(bind(*args, &block))
         end
 
-        # Ignores arguments and returns self. It exists to keep the interface
-        # identical to that of {Maybe::None}.
-        #
-        # @return [Maybe::Some]
-        def or(*)
-          self
-        end
-
-        # Returns value. It exists to keep the interface identical to that of {Maybe::None}.
-        #
-        # @return [Object]
-        def value_or(_val = nil)
-          value
-        end
-
         # @return [String]
         def to_s
           "Some(#{value.inspect})"
@@ -110,6 +98,8 @@ module Dry
       #
       # @api public
       class None < Maybe
+        include RightBiased::Left
+
         @instance = new
         singleton_class.send(:attr_reader, :instance)
 
@@ -118,22 +108,6 @@ module Dry
           nil
         end
 
-        # Ignores arguments and returns self. It exists to keep the interface
-        # identical to that of {Maybe::Some}.
-        #
-        # @return [Maybe::None]
-        def bind(*)
-          self
-        end
-
-        # Ignores arguments and returns self. It exists to keep the interface
-        # identical to that of {Maybe::Some}.
-        #
-        # @return [Maybe::None]
-        def fmap(*)
-          self
-        end
-
         # If a block is given passes internal value to it and returns the result,
         # otherwise simply returns the parameter val.
         #
@@ -141,7 +115,8 @@ module Dry
         #   Dry::Monads.None.or('no value') # => "no value"
         #   Dry::Monads.None.or { Time.now } # => current time
         #
-        # @param val [Object, nil]
+        # @param args [Array<Object>] if no block given the first argument will be returned
+        #                             otherwise arguments will be transparently passed to the block
         # @return [Object]
         def or(*args)
           if block_given?
@@ -151,15 +126,18 @@ module Dry
           end
         end
 
-        # Returns the passed value
+        # A lifted version of `#or`. Applies `Maybe.lift` to the passed value or
+        # to the block result.
         #
-        # @returns [Object]
-        def value_or(val = nil)
-          if block_given?
-            yield
-          else
-            val
-          end
+        # @example
+        #   Dry::Monads.None.or_fmap('no value') # => Some("no value")
+        #   Dry::Monads.None.or_fmap { Time.now } # => Some(current time)
+        #
+        # @param args [Array<Object>] arguments will be passed to the underlying `#or` call
+        # @return [Maybe::Some, Maybe::None] Lifted `#or` result, i.e. nil will be mapped to None,
+        #                                    other values will be wrapped with Some
+        def or_fmap(*args, &block)
+          Maybe.lift(self.or(*args, &block))
         end
 
         # @return [String]

data/lib/dry/monads/right_biased.rb

@@ -0,0 +1,148 @@
+module Dry
+  module Monads
+    module RightBiased
+      module Right
+        attr_reader :value
+
+        # Calls the passed in Proc object with value stored in self
+        # and returns the result.
+        #
+        # If proc is nil, it expects a block to be given and will yield to it.
+        #
+        # @example
+        #   Dry::Monads.Right(4).bind(&:succ) # => 5
+        #
+        # @param [Array<Object>] args arguments that will be passed to a block
+        #                             if one was given, otherwise the first
+        #                             value assumed to be a Proc (callable)
+        #                             object and the rest of args will be passed
+        #                             to this object along with the internal value
+        # @return [Object] result of calling proc or block on the internal value
+        def bind(*args, **kwargs)
+          vargs, vkwargs = destructure(value)
+          kw = kwargs.empty? && vkwargs.empty? ? [] : [kwargs.merge(vkwargs)]
+
+          if block_given?
+            yield(*vargs, *args, *kw)
+          else
+            obj, *rest = args
+            obj.call(*vargs, *rest, *kw)
+          end
+        end
+
+        # Does the same thing as #bind except it returns the original monad
+        # when the result is a Right.
+        #
+        # @example
+        #   Dry::Monads.Right(4).tee { Right('ok') } # => Right(4)
+        #   Dry::Monads.Right(4).tee { Left('fail') } # => Left('fail')
+        #
+        # @param [Array<Object>] args arguments will be transparently passed through to #bind
+        # @return [RightBiased::Right]
+        def tee(*args, &block)
+          bind(*args, &block).bind { self }
+        end
+
+        # Abstract method for lifting a block over the monad type
+        # Must be implemented for a right-biased monad
+        #
+        # @return [RightBiased::Right]
+        def fmap(*)
+          raise NotImplementedError
+        end
+
+        # Ignores arguments and returns self. It exists to keep the interface
+        # identical to that of {RightBiased::Left}.
+        #
+        # @return [RightBiased::Right]
+        def or(*)
+          self
+        end
+
+        # A lifted version of `#or`. For {RightBiased::Right} acts in the same way as `#or`,
+        # that is returns itselt.
+        #
+        # @return [RightBiased::Right]
+        def or_fmap(*)
+          self
+        end
+
+        # Returns value. It exists to keep the interface identical to that of RightBiased::Left
+        #
+        # @return [Object]
+        def value_or(_val = nil)
+          value
+        end
+
+        private
+
+        # @api private
+        def destructure(*args, **kwargs)
+          [args, kwargs]
+        end
+      end
+
+      module Left
+        attr_reader :value
+
+        # Ignores the input parameter and returns self. It exists to keep the interface
+        # identical to that of {RightBiased::Right}.
+        #
+        # @return [RightBiased::Left]
+        def bind(*)
+          self
+        end
+
+        # Ignores the input parameter and returns self. It exists to keep the interface
+        # identical to that of {RightBiased::Right}.
+        #
+        # @return [RightBiased::Left]
+        def tee(*)
+          self
+        end
+
+        # Ignores the input parameter and returns self. It exists to keep the interface
+        # identical to that of {RightBiased::Right}.
+        #
+        # @return [RightBiased::Left]
+        def fmap(*)
+          self
+        end
+
+        # Left-biased #bind version.
+        #
+        # @example
+        #   Dry::Monads.Left(ArgumentError.new('error message')).or(&:message) # => "error message"
+        #   Dry::Monads.None.or('no value') # => "no value"
+        #   Dry::Monads.None.or { Time.now } # => current time
+        #
+        # @return [Object]
+        def or(*)
+          raise NotImplementedError
+        end
+
+        # A lifted version of `#or`. This is basically `#or` + `#fmap`.
+        #
+        # @example
+        #   Dry::Monads.None.or('no value') # => Some("no value")
+        #   Dry::Monads.None.or { Time.now } # => Some(current time)
+        #
+        # @return [RightBiased::Left, RightBiased::Right]
+        def or_fmap(*)
+          raise NotImplementedError
+        end
+
+        # Returns the passed value
+        #
+        # @returns [Object]
+        def value_or(val = nil)
+          if block_given?
+            yield
+          else
+            val
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/monads/transformer.rb

@@ -0,0 +1,42 @@
+module Dry
+  module Monads
+    module Transformer
+      # Lifts a block/proc over the 2-level nested structure.
+      # This is essentially fmap . fmap (. is the function composition
+      # operator from Haskell) or the functor instance for
+      # a two-level monadic structure like List Either.
+      #
+      # @example
+      #   List[Right(1), Left(1)].fmap2 { |x| x + 1 } # => List[Right(2), Left(1)]
+      #   Right(None).fmap2 { |x| x + 1 } # => Right(None)
+      #
+      # @param args [Array<Object>] arguments will be passed to the block or the proc
+      # @return [Object] some monadic value
+      def fmap2(*args)
+        if block_given?
+          fmap { |a| a.fmap { |b| yield(b, *args) } }
+        else
+          func, *rest = args
+          fmap { |a| a.fmap { |b| func.(b, *rest) } }
+        end
+      end
+
+      # Lifts a block/proc over the 3-level nested structure.
+      #
+      # @example
+      #   List[Right(Some(1)), Left(Some(1))].fmap3 { |x| x + 1 } # => List[Right(Some(2)), Left(Some(1))]
+      #   Right(None).fmap3 { |x| x + 1 } # => Right(None)
+      #
+      # @param args [Array<Object>] arguments will be passed to the block or the proc
+      # @return [Object] some monadic value
+      def fmap3(*args)
+        if block_given?
+          fmap { |a| a.fmap { |b| b.fmap { |c| yield(c, *args) } } }
+        else
+          func, *rest = args
+          fmap { |a| a.fmap { |b| b.fmap { |c| func.(c, *rest) } } }
+        end
+      end
+    end
+  end
+end

data/lib/dry/monads/try.rb

@@ -1,5 +1,7 @@
 require 'dry/equalizer'
 
+require 'dry/monads/right_biased'
+
 module Dry
   module Monads
     # Represents a value which can be either success or a failure (an exception).
@@ -7,7 +9,7 @@ module Dry
     #
     # @api public
     class Try
-      attr_reader :exception, :value
+      attr_reader :exception
 
       # Calls the passed in proc object and if successful stores the result in a
       # {Try::Success} monad, but if one of the specified exceptions was raised it stores
@@ -37,6 +39,13 @@ module Dry
       # @api public
       class Success < Try
         include Dry::Equalizer(:value, :catchable)
+        include RightBiased::Right
+
+        # Using #or is not a good practice, you should process exceptions
+        # explicitly hence we don't offer an easy way to ignore them.
+        # Use Try#to_maybe if you're sure you need `#or` for `Try`.
+        undef :or
+
         attr_reader :catchable
 
         # @param exceptions [Array<Exception>] list of exceptions to be rescued
@@ -46,6 +55,9 @@ module Dry
           @value = value
         end
 
+        alias bind_call bind
+        private :bind_call
+
         # Calls the passed in Proc object with value stored in self
         # and returns the result.
         #
@@ -56,18 +68,14 @@ module Dry
         #   success.bind(->(n) { n / 2 }) # => 5
         #   success.bind { |n| n / 0 } # => Try::Failure(ZeroDivisionError: divided by 0)
         #
-        # @param [Array<Object>] args arguments that will be passed to a block
+        # @param args [Array<Object>] arguments that will be passed to a block
         #                             if one was given, otherwise the first
         #                             value assumed to be a Proc (callable)
         #                             object and the rest of args will be passed
         #                             to this object along with the internal value
         # @return [Object, Try::Failure]
-        def bind(*args)
-          if block_given?
-            yield(value, *args)
-          else
-            args[0].call(value, *args.drop(1))
-          end
+        def bind(*)
+          super
         rescue *catchable => e
           Failure.new(e)
         end
@@ -81,15 +89,13 @@ module Dry
         #   success.fmap(&:succ).fmap(&:succ).value # => 12
         #   success.fmap(&:succ).fmap { |n| n / 0 }.fmap(&:succ).value # => nil
         #
-        # @param [Array<Object>] args extra arguments for the block, arguments are being processes
+        # @param args [Array<Object>] extra arguments for the block, arguments are being processes
         #                             just as in #bind
         # @return [Try::Success, Try::Failure]
         def fmap(*args, &block)
-          if block
-            Try.lift(catchable, -> { yield(value, *args) })
-          else
-            Try.lift(catchable, -> { args[0].call(value, *args.drop(1)) })
-          end
+          Success.new(catchable, bind_call(*args, &block))
+        rescue *catchable => e
+          Failure.new(e)
         end
 
         # @return [Maybe]
@@ -114,28 +120,14 @@ module Dry
       # @api public
       class Failure < Try
         include Dry::Equalizer(:exception)
+        include RightBiased::Left
+        undef :or
 
         # @param exception [Exception]
         def initialize(exception)
           @exception = exception
         end
 
-        # Ignores arguments and returns self. It exists to keep the interface
-        # identical to that of {Try::Success}.
-        #
-        # @return [Try::Failure]
-        def bind(*)
-          self
-        end
-
-        # Ignores arguments and returns self. It exists to keep the interface
-        # identical to that of {Try::Success}.
-        #
-        # @return [Try::Failure]
-        def fmap(*)
-          self
-        end
-
         # @return [Maybe::None]
         def to_maybe
           Dry::Monads::None()
@@ -171,12 +163,14 @@ module Dry
       module Mixin
         Try = Try
 
+        DEFAULT_EXCEPTIONS = [StandardError].freeze
+
         # A convenience wrapper for {Try.lift}.
         # If no exceptions are provided it falls back to StandardError.
         # In general, relying on this behaviour is not recommended as it can lead to unnoticed
         # bugs and it is always better to explicitly specify a list of exceptions if possible.
         def Try(*exceptions, &f)
-          catchable = exceptions.any? ? exceptions.flatten : [StandardError]
+          catchable = exceptions.empty? ? DEFAULT_EXCEPTIONS : exceptions.flatten
           Try.lift(catchable, f)
         end
       end

data/lib/dry/monads/version.rb

@@ -1,5 +1,5 @@
 module Dry
   module Monads
-    VERSION = '0.2.1'.freeze
+    VERSION = '0.3.0'.freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dry-monads
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Nikita Shilnikov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-11-13 00:00:00.000000000 Z
+date: 2017-03-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-equalizer
@@ -76,9 +76,8 @@ files:
 - ".codeclimate.yml"
 - ".gitignore"
 - ".rspec"
-- ".rubocop.yml"
-- ".rubocop_todo.yml"
 - ".travis.yml"
+- CHANGELOG.md
 - Gemfile
 - LICENSE
 - README.md
@@ -89,7 +88,10 @@ files:
 - lib/dry-monads.rb
 - lib/dry/monads.rb
 - lib/dry/monads/either.rb
+- lib/dry/monads/list.rb
 - lib/dry/monads/maybe.rb
+- lib/dry/monads/right_biased.rb
+- lib/dry/monads/transformer.rb
 - lib/dry/monads/try.rb
 - lib/dry/monads/version.rb
 - lib/json/add/dry/monads/maybe.rb
@@ -114,7 +116,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.10
 signing_key: 
 specification_version: 4
 summary: Common monads for Ruby.

data/.rubocop.yml

@@ -1,64 +0,0 @@
-inherit_from: .rubocop_todo.yml
-
-AllCops:
-  Exclude:
-    - 'spec/integration/either_spec.rb'
-    - 'vendor/**/*'
-
-Style/Documentation:
-  Enabled: false
-
-Style/StringLiterals:
-  Enabled: false
-
-Style/MethodName:
-  Enabled: false
-
-Style/LambdaCall:
-  Enabled: false
-
-Style/StabbyLambdaParentheses:
-  Enabled: false
-
-Style/NestedParenthesizedCalls:
-  Enabled: false
-
-Style/MultilineBlockChain:
-  Enabled: false
-
-Style/GuardClause:
-  Enabled: false
-
-Style/SymbolProc:
-  Exclude:
-    # This rule is broken in specs on purpose to make examples clearer
-    - 'spec/**/*'
-
-Style/SignalException:
-  Exclude:
-    - 'spec/**/*'
-
-Style/ModuleFunction:
-  Enabled: false
-
-Style/RescueModifier:
-  Enabled: false
-
-Metrics/LineLength:
-  Max: 110
-
-Style/FileName:
-  Exclude:
-    - 'lib/dry-monads.rb'
-
-Lint/Debugger:
-  Exclude:
-    - 'bin/console'
-
-Lint/HandleExceptions:
-  Exclude:
-    - 'spec/spec_helper.rb'
-
-Security/JSONLoad:
-  Exclude:
-    - 'spec/**/*'

data/.rubocop_todo.yml

@@ -1,7 +0,0 @@
-# This configuration was generated by
-# `rubocop --auto-gen-config`
-# on 2016-04-29 01:33:48 +0100 using RuboCop version 0.39.0.
-# The point is for the user to remove these configuration records
-# one by one as the offenses are removed from the code base.
-# Note that changes in the inspected code, or installation of new
-# versions of RuboCop, may require this file to be generated again.