dry-monads 1.3.0 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b5983b622b49edc1008fc8717adf6f4150f011c55ca094879f6788cfed657f2
-  data.tar.gz: 8e01a982d197dbc26e82df01c804dba93e8aa327aeb9cb248a07eeda7a7c636c
+  metadata.gz: 89a089888f5511f4ab76971cae27948689a4137fb3122401c246bbc67ce58049
+  data.tar.gz: ded502b6c132f7e84c4d3d42ae69ed9a999d3ca83f085498599e7b6bb58eb5e1
 SHA512:
-  metadata.gz: f81e00f7455a03b12996724fd35404d81dff4cbc934e1868a2329c26cbaae5cb7f5edcde6c9766f754844e8ce0b839d5ca10781e0c1c08702020e938956703b3
-  data.tar.gz: 4ea9d2ffa5988996517ba096ef8985331a213fadbdb6d81b2597012a0d7ada3da3716422ba155accd0a9932bf5802a905a3b19162526c5f2a501f45e0b46537e
+  metadata.gz: a10c20a7a0c870fcbc18df563e3284917308e1f4ff6eec5e39af2bad02bcd7ed185233fd62e39f05dea5a2d1190440515225d6cba4a045f3a57c7b6505bfdbfd
+  data.tar.gz: b42f96d99629bee47c10d7a28bd13f3fb2a0d5e320efc6617167bd593e0df183a27a7e3b49f22bdc6b7af99e2c989170f9efcc32a0fa71fe4b0f766e0b533251

data/.travis.yml

@@ -3,26 +3,23 @@ dist: trusty
 cache: bundler
 bundler_args: --without benchmarks docs
 script:
-  - bundle exec rspec spec $RSPEC_OPTS
+  - bundle exec rspec spec
 before_install:
   - gem update --system
   - gem install bundler
 after_success:
   - "[ -d coverage ] && bundle exec codeclimate-test-reporter"
 rvm:
-  - 2.4.6
-  - 2.5.5
-  - 2.6.3
+  - 2.4.7
+  - 2.5.6
+  - 2.6.4
+  - ruby-head
   - jruby-9.2.7.0
 env:
   global:
     - JRUBY_OPTS='--dev -J-Xmx1024M'
     - COVERAGE=true
-    - RSPEC_OPTS='--exclude-pattern spec/integration/pattern_matching_spec.rb'
 matrix:
-  include:
-    - rvm: 2.7
-      env: "RSPEC_OPTS=''"
   allow_failures:
     - rvm: ruby-head
 

data/CHANGELOG.md

@@ -1,23 +1,31 @@
+# v1.3.1 2019-09-07
+
+## Fixed
+
+- Added missing `None#maybe` :sweat_smile: (flash-gordon)
+
+[Compare v1.3.0...v1.3.1](https://github.com/dry-rb/dry-monads/compare/v1.3.0...v1.3.1)
+
 # v1.3.0 2019-08-03
 
 ## BREAKING CHANGES
 
-* Support for Ruby 2.3 was dropped.
+- Support for Ruby 2.3 was dropped.
 
 ## Added
 
-* `Result#either` (waiting-for-dev)
+- `Result#either` (waiting-for-dev)
   ```ruby
   Success(1).either(-> x { x + 1 }, -> x { x + 2 }) # => 2
   Failure(1).either(-> x { x + 1 }, -> x { x + 2 }) # => 3
   ```
-* `Maybe#to_result` (SpyMachine + flash-gordon)
+- `Maybe#to_result` (SpyMachine + flash-gordon)
   ```ruby
   Some(3).to_result(:no_value)   # => Success(3)
   None().to_result { :no_value } # => Failure(:no_value)
   None().to_result               # => Failure()
   ```
-* Do notation can be used with `extend`. This simplifies usage in class methods and in other "complicated" cases (gogiel + flash-gordon)
+- Do notation can be used with `extend`. This simplifies usage in class methods and in other "complicated" cases (gogiel + flash-gordon)
 
   ```ruby
   class CreateUser
@@ -34,24 +42,27 @@
     end
   end
   ```
-  
+
   Or you can bind values directly:
+
   ```ruby
   ma = Dry::Monads.Success(1)
   mb = Dry::Monads.Success(2)
-  
+
   Dry::Monads::Do.() do
     a = Dry::Monads::Do.bind(ma)
     b = Dry::Monads::Do.bind(mb)
-    
+
     Dry::Monads.Success(a + b)
   end
   ```
-* `{Some,Success,Failure}#[]` shortcuts for building arrays wrapped within monadic value (flash-gordon)
+
+- `{Some,Success,Failure}#[]` shortcuts for building arrays wrapped within monadic value (flash-gordon)
   ```ruby
-  Success[1, 2] # => Success([1, 2]) 
+  Success[1, 2] # => Success([1, 2])
   ```
-* `List.unfold` yields a block returning `Maybe<Any>`. If the block returns `Some(a)` `a` is appended to the output list. Returning `None` halts the unfloding (flash-gordon)
+- `List.unfold` yields a block returning `Maybe<Any>`. If the block returns `Some(a)` `a` is appended to the output list. Returning `None` halts the unfloding (flash-gordon)
+
   ```ruby
   List.unfold(0) do |x|
     if x > 5
@@ -61,8 +72,9 @@
     end
   end # => List[1, 2, 3, 4, 5]
   ```
-  
-* Experimental support for pattern matching! :tada: (flash-gordon)
+
+- Experimental support for pattern matching! :tada: (flash-gordon)
+
   ```ruby
   case value
   in Failure(_) then :failure
@@ -75,28 +87,31 @@
   in Success({ code: 200..300 => x }) then x
   end
   ```
-  Read more about pattern matching in Ruby: 
+
+  Read more about pattern matching in Ruby:
+
   - https://medium.com/@baweaver/ruby-2-7-pattern-matching-destructuring-on-point-90f56aaf7b4e
   - https://bugs.ruby-lang.org/issues/14912
-  
+
   Keep in mind this feature is experimental and can be changed by 2.7 release. But it rocks already!
-  
+
 [Compare v1.2.0...v1.3.0](https://github.com/dry-rb/dry-monads/compare/v1.2.0...v1.3.0)
 
 # 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.
+- 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)
+- 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)
+- `List#collect` gathers `Some` values from the list (flash-gordon)
+
   ```ruby
   include Dry::Monads::List::Mixin
   include Dry::Monads::Maybe::Mixin
@@ -118,9 +133,10 @@
   # => [10, 6]
   ```
 
-* Right-biased monads got `#flatten` and `#and` (falsh-gordon)
+- 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
 
@@ -128,11 +144,15 @@
   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
 
@@ -145,7 +165,7 @@
   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)
+- 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'
@@ -169,7 +189,8 @@
     end
   end
   ```
-* `Task.failed` is a counterpart of `Task.pure`, accepts an exception and returns a failed task immediately (flash-gordon)
+
+- `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)
 
@@ -177,11 +198,12 @@
 
 ## Fixed
 
-* Do notation was made to work nicely with inheritance. This shouldn't break any existing code but if it does please report (flash-gordon)
+- Do notation was made to work nicely with inheritance. This shouldn't break any existing code but if it does please report (flash-gordon)
 
 ## Added
 
-* `Success()`, `Failure()`, and `Some()` now have `Unit` as a default argument:
+- `Success()`, `Failure()`, and `Some()` now have `Unit` as a default argument:
+
   ```ruby
   include Dry::Monads::Result::Mixin
   include Dry::Monads::Do
@@ -200,11 +222,11 @@
 
 ## Fixed
 
-* Fixed behavior of `List<Validated>#traverse` in presence of `Valid` values (flash-gordon + SunnyMagadan)
+- Fixed behavior of `List<Validated>#traverse` in presence of `Valid` values (flash-gordon + SunnyMagadan)
 
 ## Added
 
-* `to_proc` was added to value constructors (flash-gordon)
+- `to_proc` was added to value constructors (flash-gordon)
   ```ruby
   [1, 2, 3].map(&Some) # => [Some(1), Some(2), Some(3)]
   ```
@@ -215,7 +237,7 @@
 
 ## Added
 
-* `do`-like notation (the idea comes from Haskell of course). This is the biggest and most important addition to the release which greatly increases the ergonomics of using monads in Ruby. Basically, almost everything it does is passing a block to a given method. You call `yield` on monads to extract the values. If any operation fails i.e. no value can be extracted, the whole computation is halted and the failing step becomes a result. With `Do` you don't need to chain monadic values with `fmap/bind` and block, everything can be done on a single level of indentation. Here is a more or less real-life example:
+- `do`-like notation (the idea comes from Haskell of course). This is the biggest and most important addition to the release which greatly increases the ergonomics of using monads in Ruby. Basically, almost everything it does is passing a block to a given method. You call `yield` on monads to extract the values. If any operation fails i.e. no value can be extracted, the whole computation is halted and the failing step becomes a result. With `Do` you don't need to chain monadic values with `fmap/bind` and block, everything can be done on a single level of indentation. Here is a more or less real-life example:
 
   ```ruby
   class CreateUser
@@ -266,7 +288,7 @@
 
   In the code above any `yield` can potentially fail and return the failure reason as a result. In other words, `yield None` acts as `return None`. Internally, `Do` uses exceptions, not `return`, this is somewhat slower but allows to detect failed operations in DB-transactions and roll back the changes which far more useful than an unjustifiable speed boost (flash-gordon)
 
-* The `Task` monad based on `Promise` from the [`concurrent-ruby` gem](https://github.com/ruby-concurrency/concurrent-ruby/). `Task` represents an asynchronous computation which _can be_ (doesn't have to!) run on a separated thread. `Promise` already offers a good API and implemented in a safe manner so `dry-monads` just adds a monad-compatible interface for it. Out of the box, `concurrent-ruby` has three types of executors for running blocks: `:io`, `:fast`, `:immediate`, check out [the docs](http://ruby-concurrency.github.io/concurrent-ruby/root/Concurrent.html#executor-class_method) for details. You can provide your own executor if needed (flash-gordon)
+- The `Task` monad based on `Promise` from the [`concurrent-ruby` gem](https://github.com/ruby-concurrency/concurrent-ruby/). `Task` represents an asynchronous computation which _can be_ (doesn't have to!) run on a separated thread. `Promise` already offers a good API and implemented in a safe manner so `dry-monads` just adds a monad-compatible interface for it. Out of the box, `concurrent-ruby` has three types of executors for running blocks: `:io`, `:fast`, `:immediate`, check out [the docs](http://ruby-concurrency.github.io/concurrent-ruby/root/Concurrent.html#executor-class_method) for details. You can provide your own executor if needed (flash-gordon)
 
   ```ruby
   include Dry::Monads::Task::Mixin
@@ -292,9 +314,9 @@
   end
   ```
 
-* `Lazy` is a copy of `Task` that isn't run until you ask for the value _for the first time_. It is guaranteed the evaluation is run at most once as opposed to lazy assignment `||=` which isn't synchronized. `Lazy` is run on the same thread asking for the value (flash-gordon)
+- `Lazy` is a copy of `Task` that isn't run until you ask for the value _for the first time_. It is guaranteed the evaluation is run at most once as opposed to lazy assignment `||=` which isn't synchronized. `Lazy` is run on the same thread asking for the value (flash-gordon)
 
-* Automatic type inference with `.typed` for lists was deprecated. Instead, typed list builders were added
+- Automatic type inference with `.typed` for lists was deprecated. Instead, typed list builders were added
 
   ```ruby
   list = List::Task[Task { get_name }, Task { get_email }]
@@ -303,7 +325,7 @@
 
   The code above runs two tasks in parallel and automatically combines their results with `traverse` (flash-gordon)
 
-* `Try` got a new call syntax supported in Ruby 2.5+
+- `Try` got a new call syntax supported in Ruby 2.5+
 
   ```ruby
     Try[ArgumentError, TypeError] { unsafe_operation }
@@ -311,7 +333,7 @@
 
   Prior to 2.5, it wasn't possible to pass a block to `[]`.
 
-* The `Validated` “monad” that represents a result of a validation. Suppose, you want to collect all the errors and return them at once. You can't have it with `Result` because when you `traverse` a `List` of `Result`s it returns the first value and this is the correct behavior from the theoretical point of view. `Validated`, in fact, doesn't have a monad instance but provides a useful variant of applicative which concatenates the errors.
+- The `Validated` “monad” that represents a result of a validation. Suppose, you want to collect all the errors and return them at once. You can't have it with `Result` because when you `traverse` a `List` of `Result`s it returns the first value and this is the correct behavior from the theoretical point of view. `Validated`, in fact, doesn't have a monad instance but provides a useful variant of applicative which concatenates the errors.
 
   ```ruby
     include Dry::Monads
@@ -335,13 +357,13 @@
 
   In the example above an array of `Validated` values is implicitly coerced to `List::Validated`. It's supported because it's useful but don't forget it's all about types so don't mix different types of monads in a single array, the consequences are unclear. You always can be explicit with `List::Validated[validate_name(...), ...]`, choose what you like (flash-gordon).
 
-* `Failure`, `None`, and `Invalid` values now store the line where they were created. One of the biggest downsides of dealing with monadic code is lack of backtraces. If you have a long list of computations and one of them fails how do you know where did it actually happen? Say, you've got `None` and this tells you nothing about _what variable_ was assigned to `None`. It makes sense to use `Result` instead of `Maybe` and use distinct errors everywhere but it doesn't always look good and forces you to think more. TLDR; call `.trace` to get the line where a fail-case was constructed
+- `Failure`, `None`, and `Invalid` values now store the line where they were created. One of the biggest downsides of dealing with monadic code is lack of backtraces. If you have a long list of computations and one of them fails how do you know where did it actually happen? Say, you've got `None` and this tells you nothing about _what variable_ was assigned to `None`. It makes sense to use `Result` instead of `Maybe` and use distinct errors everywhere but it doesn't always look good and forces you to think more. TLDR; call `.trace` to get the line where a fail-case was constructed
 
   ```ruby
   Failure(:invalid_name).trace # => app/operations/create_user.rb:43
   ```
 
-* `Dry::Monads::Unit` which can be used as a replacement for `Success(nil)` and in similar situations when you have side effects yet doesn't return anything meaningful as a result. There's also the `.discard` method for mapping any successful result (i.e. `Success(?)`, `Some(?)`, `Value(?)`, etc) to `Unit`.
+- `Dry::Monads::Unit` which can be used as a replacement for `Success(nil)` and in similar situations when you have side effects yet doesn't return anything meaningful as a result. There's also the `.discard` method for mapping any successful result (i.e. `Success(?)`, `Some(?)`, `Value(?)`, etc) to `Unit`.
 
   ```ruby
     # we're making an HTTP request but "forget" any successful result,
@@ -353,12 +375,12 @@
 
 ## Deprecations
 
-* `Either`, the former name of `Result`, is now deprecated
+- `Either`, the former name of `Result`, is now deprecated
 
 ## BREAKING CHANGES
 
-* `Either#value` and `Maybe#value` were both droped, use `value_or` or `value!` when you :100: sure it's safe
-* `require 'dry/monads'` doesn't load all monads anymore, use `require 'dry/monads/all'` instead or cherry pick them with `require 'dry/monads/maybe'` etc (timriley)
+- `Either#value` and `Maybe#value` were both droped, use `value_or` or `value!` when you :100: sure it's safe
+- `require 'dry/monads'` doesn't load all monads anymore, use `require 'dry/monads/all'` instead or cherry pick them with `require 'dry/monads/maybe'` etc (timriley)
 
 [Compare v0.4.0...v1.0.0](https://github.com/dry-rb/dry-monads/compare/v0.4.0...v1.0.0)
 
@@ -366,16 +388,16 @@
 
 ## Changed
 
-* The `Either` monad was renamed to `Result` which sounds less nerdy but better reflects the purpose of the type. `Either::Right` became `Result::Success` and `Either::Left` became `Result::Failure`. This change is backward-compatible overall but you will see the new names when using old `Left` and `Right` methods (citizen428)
-* Consequently, `Try::Success` and `Try::Failure` were renamed to `Try::Value` and `Try::Error` (flash-gordon)
+- The `Either` monad was renamed to `Result` which sounds less nerdy but better reflects the purpose of the type. `Either::Right` became `Result::Success` and `Either::Left` became `Result::Failure`. This change is backward-compatible overall but you will see the new names when using old `Left` and `Right` methods (citizen428)
+- Consequently, `Try::Success` and `Try::Failure` were renamed to `Try::Value` and `Try::Error` (flash-gordon)
 
 ## Added
 
-* `Try#or`, works as `Result#or` (flash-gordon)
-* `Maybe#success?` and `Maybe#failure?` (aliases for `#some?` and `#none?`) (flash-gordon)
-* `Either#flip` inverts a `Result` value  (flash-gordon)
-* `List#map` called without a block returns an `Enumerator` object (flash-gordon)
-* Right-biased monads (`Maybe`, `Result`, and `Try`) now implement the `===` operator which is used for equality checks in the `case` statement (flash-gordon)
+- `Try#or`, works as `Result#or` (flash-gordon)
+- `Maybe#success?` and `Maybe#failure?` (aliases for `#some?` and `#none?`) (flash-gordon)
+- `Either#flip` inverts a `Result` value (flash-gordon)
+- `List#map` called without a block returns an `Enumerator` object (flash-gordon)
+- Right-biased monads (`Maybe`, `Result`, and `Try`) now implement the `===` operator which is used for equality checks in the `case` statement (flash-gordon)
   ```ruby
     case value
     when Some(1..100)       then :ok
@@ -387,7 +409,7 @@
 
 ## Deprecated
 
-* Direct accessing `value` on right-biased monads has been deprecated, use the `value!` method instead. `value!` will raise an exception if it is called on a Failure/None/Error instance (flash-gordon)
+- Direct accessing `value` on right-biased monads has been deprecated, use the `value!` method instead. `value!` will raise an exception if it is called on a Failure/None/Error instance (flash-gordon)
 
 [Compare v0.3.1...v0.4.0](https://github.com/dry-rb/dry-monads/compare/v0.3.1...v0.4.0)
 
@@ -395,20 +417,21 @@
 
 ## Fixed
 
-* Fixed unexpected coercing to `Hash` on `.bind` call (flash-gordon)
+- Fixed unexpected coercing to `Hash` on `.bind` call (flash-gordon)
 
 [Compare v0.3.0...v0.3.1](https://github.com/dry-rb/dry-monads/compare/v0.3.0...v0.3.1)
 
 # 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)
+
+- 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.2.1...v0.3.0](https://github.com/dry-rb/dry-monads/compare/v0.2.1...v0.3.0)
 
@@ -416,12 +439,12 @@
 
 ## Added
 
-* Added `Either#tee` that is similar to `Object#tap` but executes the block only for `Right` instances (saverio-kantox)
+- 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)
+- `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.0...v0.2.1](https://github.com/dry-rb/dry-monads/compare/v0.2.0...v0.2.1)
 
@@ -429,8 +452,8 @@
 
 ## 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)
+- 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)
 
@@ -438,7 +461,7 @@
 
 ## Fixed
 
-* Added explicit requires of `dry-equalizer`. This allows to safely load only specific monads (artofhuman)
+- 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)
 
@@ -446,11 +469,11 @@
 
 ## Added
 
-* Support for passing extra arguments to the block in `.bind` and `.fmap` (flash-gordon)
+- Support for passing extra arguments to the block in `.bind` and `.fmap` (flash-gordon)
 
 ## Changed
 
-* Dropped MRI 2.0 support (flash-gordon)
+- 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)
 
@@ -458,8 +481,8 @@
 
 ## 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)
+- 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)
 

data/lib/dry/monads/maybe.rb

@@ -163,6 +163,10 @@ module Dry
           @trace = trace
         end
 
+        # @!method maybe(*args, &block)
+        #   Alias of fmap, returns self back
+        alias_method :maybe, :fmap
+
         # If a block is given passes internal value to it and returns the result,
         # otherwise simply returns the parameter val.
         #

data/lib/dry/monads/version.rb

@@ -1,6 +1,6 @@
 module Dry
   module Monads
     # Gem version
-    VERSION = '1.3.0'.freeze
+    VERSION = '1.3.1'.freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dry-monads
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.3.1
 platform: ruby
 authors:
 - Nikita Shilnikov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-08-03 00:00:00.000000000 Z
+date: 2019-09-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-equalizer