Add docs

Author: flash-gordon

docsite/source/maybe.html.md

@@ -105,6 +105,14 @@ Maybe(nil).bind(add_two).or(Some(0)) # => Some(0)
 Maybe(nil).bind(add_two).or { Some(0) } # => Some(0)
 ```
 
+There's an alias operator for `or`:
+
+```ruby
+extend Dry::Monads[:maybe]
+
+None() | Some(1) | Some(2) # => Some(1)
+```
+
 ### `and`
 
 Two values can be chained using `.and`:
@@ -144,3 +152,14 @@ None().to_result # => Failure()
 None().to_result(:error) # => Failure(:error)
 None().to_result { :block_value } # => Failure(:block_value)
 ```
+
+### `filter`
+
+`Maybe#filter` runs a predicate against the wrapped value. Returns `None` if the result is false:
+
+```ruby
+Some(3).filter(&:odd?)  # => Some(3)
+Some(3).filter(&:even?) # => None
+# no block given
+Some(3 == 5).filter     # => None
+```

docsite/source/result.html.md

@@ -157,6 +157,13 @@ Success(1).either(-> x { x + 1 }, -> x { x + 2 }) # => 2
 Failure(1).either(-> x { x + 1 }, -> x { x + 2 }) # => 3
 ```
 
+### `alt_map`
+
+`alt_map` channels failure values, it's an `fmap` for `Failure`:
+
+```ruby
+Failure("oops").alt_map(&:upcase) # => Failure("OOPS")
+```
 
 ### Adding constraints to `Failure` values.
 You can add type constraints to values passed to `Failure`. This will raise an exception if value doesn't meet the constraints:

docsite/source/try.html.md

@@ -73,3 +73,31 @@ Use `value!` for unwrapping a `Success` and `exception` for getting error object
 ### `to_result` and `to_maybe`
 
 `Try`'s `Value` and `Error` can be transformed to `Success` and `Failure` correspondingly by calling `to_result` and to `Some` and `None` by calling `to_maybe`. Keep in mind that by transforming `Try` to `Maybe` you lose the information about an exception so be sure that you've processed the error before doing so.
+
+### `recover`
+
+Recovers from an error:
+
+```ruby
+extend Dry::Monads[:try]
+
+Try { 10 / 0 }.recover(ZeroDivisionError) { 1 } # => Try::Value(1)
+```
+
+No explicit list of exceptions required, StandardError will be the default:
+```ruby
+extend Dry::Monads[:try]
+Try { Hash.new.fetch(:missing) }.recover { :found } # => Try::Value(:found)
+```
+
+Of course, it's a no-op on values:
+```ruby
+Try { 10 }.recover { 1 } # => Try::Value(10)
+```
+
+Multiple exception types are allowed:
+```ruby
+extend Dry::Monads[:try]
+
+Try { bang! }.recover(KeyError, ArgumentError) { :failsafe }
+```