fear 0.11.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: f2a2b3d7163ba41625120e4681b75a845e5d9da9
-  data.tar.gz: 5d85fb64e778587e9f8f85695acb4f19602ae47e
+SHA256:
+  metadata.gz: b04f2a97dbf830e68f70c42b703e2e70f7baf389da09871b2024effe95f51c68
+  data.tar.gz: 7852518363fe60c10e9c60da873462e84e9b1ad567c760992bbf595b5eb388fb
 SHA512:
-  metadata.gz: 99ff3b3886920d253e835b6d1346ff7680f26650a01087cbd83629ec3ba3e7a152ef7714937c653639eef1689dcbac242c7a18cfd26db8d41155f5f4cc9bd80b
-  data.tar.gz: 7fcabd7b3cada123a3d2988c4cc4c19bf2af8195e10ff151a886f9a24e1b12dfa73061ca9bc323c056aee9f0be985886b74a02b23a2eeacc10d39e8da2735fb5
+  metadata.gz: 3b166826f4b02237d1614e334b98991271b8825d98cdb879d863abacdfc72587c0dfa47fe8762cab3b29cd7fa8472a5069092e1f8766e68807f8311bfe1c1614
+  data.tar.gz: 8393f1845627f280e8e65caf2f4f36b329106beef35445ef58d3a8d053b8f2fb6644060a0139256bb7e120d4005efcb1427debbec495c97205719614361c73ab

data/.gitignore

@@ -1,6 +1,5 @@
 /.bundle/
 /.yardoc
-/Gemfile.lock
 /_yardoc/
 /coverage/
 /doc/

data/.rubocop.yml

@@ -1,6 +1,17 @@
+inherit_mode:
+  merge:
+  - Exclude
+
 AllCops:
   Exclude:
   - 'gemfiles/**/*'
+  - 'vendor/bundle/'
+
+Layout/MultilineMethodCallIndentation:
+  EnforcedStyle: indented
+
+Metrics/ClassLength:
+  Enabled: false
 
 Naming/MethodName:
   Enabled: false
@@ -35,11 +46,18 @@ Style/TrailingCommaInHashLiteral:
 Style/NumericPredicate:
   Enabled: false
 
+Style/CommentedKeyword:
+  Enabled: false
+
+Layout/IndentHeredoc:
+  Enabled: false
+
 Metrics/BlockLength:
   Exclude:
     - spec/**/*
     - Rakefile
     - fear.gemspec
+    - examples/**/*
 
 Metrics/LineLength:
   Max: 120

data/.travis.yml

@@ -11,6 +11,3 @@ before_script:
 script:
 - bundle exec rspec
 - bundle exec rubocop --fail-level C
-gemfile:
-- gemfiles/dry_equalizer_0.2.1.gemfile
-- gemfiles/dry_equalizer_0.1.0.gemfile

data/CHANGELOG.md

@@ -1,6 +1,17 @@
+## 0.x
+
+* Rename `Fear::Done` to `Fear::Unit` ([@bolshakov][])
+* Don't treat symbols as procs while pattern matching. See [#46](https://github.com/bolshakov/fear/pull/46) for motivation ([@bolshakov][])
+* Revert commit removing `Fear::Future`. Now you can use `Fear.future` again ([@bolshakov][])
+* Signatures of `Try#recover` and `Try#recover_with` changed. No it pattern match against container
+  see https://github.com/bolshakov/fear/issues/41 for details . ([@bolshakov][])
+* Add `#xcase` method to extract patterns ([@bolshakov][])
+* Add `Fear.option`, `Fear.some`, `Fear.none`, `Fear.try`, `Fear.left`, `Fear.right`, and `Fear.for` alternatives to
+  including mixins. ([@bolshakov][])
+
 ## 0.11.0
 
-* Implement pattern matching and partial functions. See [README](https://github.com/bolshakov/fear#pattern-matching-api-documentation) (([@bolshakov][]))
+* Implement pattern matching and partial functions. See [README](https://github.com/bolshakov/fear#pattern-matching-api-documentation) ([@bolshakov][])
 * `#to_a` method removed ([@bolshakov][])
 * `For` syntax changed. See [diff](https://github.com/bolshakov/fear/pull/22/files#diff-04c6e90faac2675aa89e2176d2eec7d8) ([@bolshakov][])
 * `Fear::None` is singleton object now and could not be instantiated ([@bolshakov][])

data/Gemfile

@@ -5,4 +5,5 @@ gemspec
 
 # gem 'codeclimate-test-reporter', group: :test, require: nil
 
+gem 'irb'
 gem 'qo', github: 'baweaver/qo'

data/{gemfiles/dry_equalizer_0.2.1.gemfile.lock → Gemfile.lock}

@@ -6,28 +6,35 @@ GIT
       any (= 0.1.0)
 
 PATH
-  remote: ..
+  remote: .
   specs:
-    fear (0.11.0)
-      dry-equalizer (<= 0.2.1)
+    fear (1.0.0)
+      lru_redux
+      treetop
 
 GEM
   remote: https://rubygems.org/
   specs:
     any (0.1.0)
-    appraisal (2.2.0)
-      bundler
-      rake
-      thor (>= 0.14.0)
     ast (2.4.0)
     benchmark-ips (2.7.2)
+    concurrent-ruby (1.1.5)
     diff-lcs (1.3)
-    dry-equalizer (0.2.1)
+    dry-core (0.4.7)
+      concurrent-ruby (~> 1.0)
+    dry-equalizer (0.2.2)
     dry-matcher (0.7.0)
+    dry-monads (1.2.0)
+      concurrent-ruby (~> 1.0)
+      dry-core (~> 0.4, >= 0.4.4)
+      dry-equalizer
+    irb (1.0.0)
     jaro_winkler (1.5.2)
+    lru_redux (1.1.0)
     parallel (1.14.0)
     parser (2.6.0.0)
       ast (~> 2.4.0)
+    polyglot (0.3.5)
     powerpack (0.1.2)
     psych (3.1.0)
     rainbow (3.0.0)
@@ -57,7 +64,8 @@ GEM
     rubocop-rspec (1.32.0)
       rubocop (>= 0.60.0)
     ruby-progressbar (1.10.0)
-    thor (0.20.3)
+    treetop (1.6.10)
+      polyglot (~> 0.3)
     unicode-display_width (1.4.1)
     yard (0.9.18)
 
@@ -65,12 +73,13 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
-  appraisal
   benchmark-ips
   bundler
-  dry-equalizer (= 0.2.1)
+  concurrent-ruby
   dry-matcher
+  dry-monads
   fear!
+  irb
   qo!
   rake (~> 10.0)
   rspec (~> 3.1)
@@ -79,4 +88,4 @@ DEPENDENCIES
   yard
 
 BUNDLED WITH
-   1.16.2
+   1.17.2

data/README.md

@@ -26,10 +26,11 @@ Or install it yourself as:
 * [Option](#option-documentation) 
 * [Try](#try-documentation)
 * [Either](#either-documentation)
+* [Future](#future-documentation)
 * [For composition](#for-composition)
 * [Pattern Matching](#pattern-matching-api-documentation)
 
-### Option ([Documentation](http://www.rubydoc.info/github/bolshakov/fear/master/Fear/Option))
+### Option ([API Documentation](https://www.rubydoc.info/github/bolshakov/fear/master/Fear/Option))
 
 Represents optional (nullable) values. Instances of `Option` are either an instance of 
 `Some` or the object `None`.
@@ -37,7 +38,7 @@ Represents optional (nullable) values. Instances of `Option` are either an insta
 The most idiomatic way to use an `Option` instance is to treat it as a collection
 
 ```ruby
-name = Option(params[:name])
+name = Fear.option(params[:name])
 upper = name.map(&:strip).select { |n| n.length != 0 }.map(&:upcase)
 puts upper.get_or_else('')
 ```
@@ -48,7 +49,7 @@ having to check for the existence of a value.
 A less-idiomatic way to use `Option` values is via pattern matching
 
 ```ruby
-Option(params[:name]).match do |m|
+Fear.option(params[:name]).match do |m|
   m.some { |name| name.strip.upcase }
   m.none { 'No name value' }
 end
@@ -57,7 +58,7 @@ end
 or manually checking for non emptiness
 
 ```ruby
-name = Option(params[:name])
+name = Fear.option(params[:name])
 if name.empty?
  puts 'No name value'
 else
@@ -65,16 +66,29 @@ else
 end
 ```
 
+Alternatively, include `Fear::Option::Mixin` to use `Option()`, `Some()` and `None()` methods:
+
+```ruby
+include Fear::Option::Mixin 
+
+Option(42) #=> #<Fear::Some get=42>
+Option(nil) #=> #<Fear::None>
+
+Some(42) #=> #<Fear::Some get=42>
+Some(nil) #=> #<Fear::Some get=nil>
+None() #=> #<Fear::None>
+``` 
+
 #### Option#get_or_else
 
 Returns the value from this `Some` or evaluates the given default argument if this is a `None`.
 
 ```ruby
-Some(42).get_or_else { 24/2 } #=> 42
-None.get_or_else { 24/2 }   #=> 12
+Fear.some(42).get_or_else { 24/2 } #=> 42
+Fear.none.get_or_else { 24/2 }   #=> 12
 
-Some(42).get_or_else(12)  #=> 42
-None.get_or_else(12)    #=> 12
+Fear.some(42).get_or_else(12)  #=> 42
+Fear.none.get_or_else(12)    #=> 12
 ```
 
 #### Option#or_else
@@ -82,9 +96,9 @@ None.get_or_else(12)    #=> 12
 returns self `Some` or the given alternative if this is a `None`.
 
 ```ruby
-Some(42).or_else { Some(21) } #=> Some(42)
-None.or_else { Some(21) }   #=> Some(21)
-None.or_else { None }     #=> None
+Fear.some(42).or_else { Fear.some(21) } #=> Fear.some(42)
+Fear.none.or_else { Fear.some(21) }   #=> Fear.some(21)
+Fear.none.or_else { None }     #=> None
 ```
 
 #### Option#inlude?
@@ -92,9 +106,9 @@ None.or_else { None }     #=> None
 Checks if `Option` has an element that is equal (as determined by `==`) to given values.
 
 ```ruby
-Some(17).include?(17) #=> true
-Some(17).include?(7)  #=> false
-None.include?(17)   #=> false
+Fear.some(17).include?(17) #=> true
+Fear.some(17).include?(7)  #=> false
+Fear.none.include?(17)   #=> false
 ```
 
 #### Option#each
@@ -102,8 +116,8 @@ None.include?(17)   #=> false
 Performs the given block if this is a `Some`.
 
 ```ruby
-Some(17).each { |value| puts value } #=> prints 17
-None.each { |value| puts value } #=> does nothing
+Fear.some(17).each { |value| puts value } #=> prints 17
+Fear.none.each { |value| puts value } #=> does nothing
 ```
 
 #### Option#map 
@@ -111,8 +125,8 @@ None.each { |value| puts value } #=> does nothing
 Maps the given block to the value from this `Some` or returns self if this is a `None`
 
 ```ruby
-Some(42).map { |v| v/2 } #=> Some(21)
-None.map { |v| v/2 }   #=> None
+Fear.some(42).map { |v| v/2 } #=> Fear.some(21)
+Fear.none.map { |v| v/2 }   #=> None
 ```
 
 #### Option#flat_map
@@ -120,8 +134,8 @@ None.map { |v| v/2 }   #=> None
 Returns the given block applied to the value from this `Some` or returns self if this is a `None`
 
 ```ruby
-Some(42).flat_map { |v| Some(v/2) }   #=> Some(21)
-None.flat_map { |v| Some(v/2) }     #=> None
+Fear.some(42).flat_map { |v| Fear.some(v/2) }   #=> Fear.some(21)
+Fear.none.flat_map { |v| Fear.some(v/2) }     #=> None
 ```
 
 #### Option#any?
@@ -129,9 +143,9 @@ None.flat_map { |v| Some(v/2) }     #=> None
 Returns `false` if `None` or returns the result of the application of the given predicate to the `Some` value.
 
 ```ruby 
-Some(12).any?( |v| v > 10)  #=> true
-Some(7).any?( |v| v > 10)   #=> false
-None.any?( |v| v > 10)    #=> false
+Fear.some(12).any?( |v| v > 10)  #=> true
+Fear.some(7).any?( |v| v > 10)   #=> false
+Fear.none.any?( |v| v > 10)    #=> false
 ```
 
 #### Option#select
@@ -140,9 +154,9 @@ Returns self if it is nonempty and applying the predicate to this `Option`'s val
 return `None`.
 
 ```ruby 
-Some(42).select { |v| v > 40 } #=> Success(21)
-Some(42).select { |v| v < 40 } #=> None
-None.select { |v| v < 40 }   #=> None
+Fear.some(42).select { |v| v > 40 } #=> Fear.success(21)
+Fear.some(42).select { |v| v < 40 } #=> None
+Fear.none.select { |v| v < 40 }   #=> None
 ```
 
 #### Option#reject
@@ -150,9 +164,9 @@ None.select { |v| v < 40 }   #=> None
 Returns `Some` if applying the predicate to this `Option`'s value returns `false`. Otherwise, return `None`.
 
 ```ruby 
-Some(42).reject { |v| v > 40 } #=> None
-Some(42).reject { |v| v < 40 } #=> Some(42)
-None.reject { |v| v < 40 }   #=> None
+Fear.some(42).reject { |v| v > 40 } #=> None
+Fear.some(42).reject { |v| v < 40 } #=> Fear.some(42)
+Fear.none.reject { |v| v < 40 }   #=> None
 ```
 
 #### Option#get
@@ -164,14 +178,14 @@ Not an idiomatic way of using Option at all. Returns values of raise `NoSuchElem
 Returns `true` if the `Option` is `None`, `false` otherwise.
 
 ```ruby
-Some(42).empty? #=> false
-None.empty?   #=> true
+Fear.some(42).empty? #=> false
+Fear.none.empty?   #=> true
 ```
 
 @see https://github.com/scala/scala/blob/2.11.x/src/library/scala/Option.scala
  
 
-### Try ([Documentation](http://www.rubydoc.info/github/bolshakov/fear/master/Fear/Try))
+### Try ([API Documentation](http://www.rubydoc.info/github/bolshakov/fear/master/Fear/Try))
 
 The `Try` represents a computation that may either result
 in an exception, or return a successfully computed value. Instances of `Try`,
@@ -183,10 +197,8 @@ exception-handling in all of the places that an exception
 might occur.
 
 ```ruby
-include Fear::Try::Mixin
-
-dividend = Try { Integer(params[:dividend]) }
-divisor = Try { Integer(params[:divisor]) }
+dividend = Fear.try { Integer(params[:dividend]) }
+divisor = Fear.try { Integer(params[:divisor]) }
 problem = dividend.flat_map { |x| divisor.map { |y| x / y } }
 
 problem.match |m|
@@ -218,13 +230,22 @@ type of default behavior in the case of failure.
 *NOTE*: Only non-fatal exceptions are caught by the combinators on `Try`.
 Serious system errors, on the other hand, will be thrown.
 
+Alternatively, include `Fear::Try::Mixin` to use `Try()` method:
+
+```ruby
+include Fear::Try::Mixin 
+
+Try { 4/0 }  #=> #<Fear::Failure exception=...>
+Try { 4/2 }  #=> #<Fear::Success value=2>
+```
+
 #### Try#get_or_else
 
 Returns the value from this `Success` or evaluates the given default argument if this is a `Failure`.
 
 ```ruby
-Success(42).get_or_else { 24/2 }                #=> 42
-Failure(ArgumentError.new).get_or_else { 24/2 } #=> 12
+Fear.success(42).get_or_else { 24/2 }                #=> 42
+Fear.failure(ArgumentError.new).get_or_else { 24/2 } #=> 12
 ```
 
 #### Try#include?
@@ -232,9 +253,9 @@ Failure(ArgumentError.new).get_or_else { 24/2 } #=> 12
 Returns `true` if it has an element that is equal given values, `false` otherwise.
 
 ```ruby
-Success(17).include?(17)                #=> true
-Success(17).include?(7)                 #=> false
-Failure(ArgumentError.new).include?(17) #=> false
+Fear.success(17).include?(17)                #=> true
+Fear.success(17).include?(7)                 #=> false
+Fear.failure(ArgumentError.new).include?(17) #=> false
 ```
 
 #### Try#each
@@ -243,8 +264,8 @@ Performs the given block if this is a `Success`. If block raise an error,
 then this method may raise an exception.
 
 ```ruby
-Success(17).each { |value| puts value }  #=> prints 17
-Failure(ArgumentError.new).each { |value| puts value } #=> does nothing
+Fear.success(17).each { |value| puts value }  #=> prints 17
+Fear.failure(ArgumentError.new).each { |value| puts value } #=> does nothing
 ```
 
 #### Try#map
@@ -252,8 +273,8 @@ Failure(ArgumentError.new).each { |value| puts value } #=> does nothing
 Maps the given block to the value from this `Success` or returns self if this is a `Failure`.
 
 ```ruby
-Success(42).map { |v| v/2 }                 #=> Success(21)
-Failure(ArgumentError.new).map { |v| v/2 }  #=> Failure(ArgumentError.new)
+Fear.success(42).map { |v| v/2 }                 #=> Fear.success(21)
+Fear.failure(ArgumentError.new).map { |v| v/2 }  #=> Fear.failure(ArgumentError.new)
 ```
 
 #### Try#flat_map
@@ -261,8 +282,8 @@ Failure(ArgumentError.new).map { |v| v/2 }  #=> Failure(ArgumentError.new)
 Returns the given block applied to the value from this `Success`or returns self if this is a `Failure`.
 
 ```ruby
-Success(42).flat_map { |v| Success(v/2) } #=> Success(21)
-Failure(ArgumentError.new).flat_map { |v| Success(v/2) } #=> Failure(ArgumentError.new)
+Fear.success(42).flat_map { |v| Fear.success(v/2) } #=> Fear.success(21)
+Fear.failure(ArgumentError.new).flat_map { |v| Fear.success(v/2) } #=> Fear.failure(ArgumentError.new)
 ```
 
 #### Try#to_option
@@ -270,8 +291,8 @@ Failure(ArgumentError.new).flat_map { |v| Success(v/2) } #=> Failure(ArgumentErr
 Returns an `Some` containing the `Success` value or a `None` if this is a `Failure`.
 
 ```ruby
-Success(42).to_option                 #=> Some(21)
-Failure(ArgumentError.new).to_option  #=> None
+Fear.success(42).to_option                 #=> Fear.some(21)
+Fear.failure(ArgumentError.new).to_option  #=> None
 ```
 
 #### Try#any?
@@ -279,20 +300,20 @@ Failure(ArgumentError.new).to_option  #=> None
 Returns `false` if `Failure` or returns the result of the application of the given predicate to the `Success` value.
 
 ```ruby
-Success(12).any?( |v| v > 10)                #=> true
-Success(7).any?( |v| v > 10)                 #=> false
-Failure(ArgumentError.new).any?( |v| v > 10) #=> false
+Fear.success(12).any?( |v| v > 10)                #=> true
+Fear.success(7).any?( |v| v > 10)                 #=> false
+Fear.failure(ArgumentError.new).any?( |v| v > 10) #=> false
 ```
 
 #### Try#success? and Try#failure?
 
 
 ```ruby
-Success(12).success? #=> true
-Success(12).failure? #=> true
+Fear.success(12).success? #=> true
+Fear.success(12).failure? #=> true
 
-Failure(ArgumentError.new).success? #=> false
-Failure(ArgumentError.new).failure? #=> true
+Fear.failure(ArgumentError.new).success? #=> false
+Fear.failure(ArgumentError.new).failure? #=> true
 ```
 
 #### Try#get
@@ -300,8 +321,8 @@ Failure(ArgumentError.new).failure? #=> true
 Returns the value from this `Success` or raise the exception if this is a `Failure`.
 
 ```ruby
-Success(42).get                 #=> 42
-Failure(ArgumentError.new).get  #=> ArgumentError: ArgumentError
+Fear.success(42).get                 #=> 42
+Fear.failure(ArgumentError.new).get  #=> ArgumentError: ArgumentError
 ```
 
 #### Try#or_else
@@ -309,9 +330,9 @@ Failure(ArgumentError.new).get  #=> ArgumentError: ArgumentError
 Returns self `Try` if it's a `Success` or the given alternative if this is a `Failure`.
 
 ```ruby
-Success(42).or_else { Success(-1) }                 #=> Success(42)
-Failure(ArgumentError.new).or_else { Success(-1) }  #=> Success(-1)
-Failure(ArgumentError.new).or_else { Try { 1/0 } }  #=> Failure(ZeroDivisionError.new('divided by 0'))
+Fear.success(42).or_else { Fear.success(-1) }                 #=> Fear.success(42)
+Fear.failure(ArgumentError.new).or_else { Fear.success(-1) }  #=> Fear.success(-1)
+Fear.failure(ArgumentError.new).or_else { Fear.try { 1/0 } }  #=> Fear.failure(ZeroDivisionError.new('divided by 0'))
 ```
 
 #### Try#flatten
@@ -319,10 +340,10 @@ Failure(ArgumentError.new).or_else { Try { 1/0 } }  #=> Failure(ZeroDivisionErro
 Transforms a nested `Try`, ie, a `Success` of `Success`, into an un-nested `Try`, ie, a `Success`.
 
 ```ruby
-Success(42).flatten                         #=> Success(42)
-Success(Success(42)).flatten                #=> Success(42)
-Success(Failure(ArgumentError.new)).flatten #=> Failure(ArgumentError.new)
-Failure(ArgumentError.new).flatten { -1 }   #=> Failure(ArgumentError.new)
+Fear.success(42).flatten                         #=> Fear.success(42)
+Fear.success(Fear.success(42)).flatten                #=> Fear.success(42)
+Fear.success(Fear.failure(ArgumentError.new)).flatten #=> Fear.failure(ArgumentError.new)
+Fear.failure(ArgumentError.new).flatten { -1 }   #=> Fear.failure(ArgumentError.new)
 ```
 
 #### Try#select
@@ -330,38 +351,58 @@ Failure(ArgumentError.new).flatten { -1 }   #=> Failure(ArgumentError.new)
 Converts this to a `Failure` if the predicate is not satisfied.
 
 ```ruby
-Success(42).select { |v| v > 40 }
-  #=> Success(21)
-Success(42).select { |v| v < 40 }
-  #=> Failure(Fear::NoSuchElementError.new("Predicate does not hold for 42"))
-Failure(ArgumentError.new).select { |v| v < 40 }
-  #=> Failure(ArgumentError.new)
+Fear.success(42).select { |v| v > 40 }
+  #=> Fear.success(21)
+Fear.success(42).select { |v| v < 40 }
+  #=> Fear.failure(Fear::NoSuchElementError.new("Predicate does not hold for 42"))
+Fear.failure(ArgumentError.new).select { |v| v < 40 }
+  #=> Fear.failure(ArgumentError.new)
 ```
 
-#### Try#recover_with
+#### Recovering from errors
 
-Applies the given block to exception. This is like `flat_map` for the exception.
+There are two ways to recover from the error. `Try#recover_with` method  is like `flat_map` for the exception. And 
+you can pattern match against the error!
 
 ```ruby
-Success(42).recover_with { |e| Success(e.massage) }
-  #=> Success(42)
-Failure(ArgumentError.new).recover_with { |e| Success(e.massage) }
-  #=> Success('ArgumentError')
-Failure(ArgumentError.new).recover_with { |e| raise }
-  #=> Failure(RuntimeError)
+Fear.success(42).recover_with do |m|
+  m.case(ZeroDivisionError) { Fear.success(0) }
+end #=> Fear.success(42)
+
+Fear.failure(ArgumentError.new).recover_with do |m|
+  m.case(ZeroDivisionError) { Fear.success(0) }
+  m.case(ArgumentError) { |error| Fear.success(error.class.name) }
+end #=> Fear.success('ArgumentError')
 ```
 
-#### Try#recover
+If the block raises error, this new error returned as an result
 
-Applies the given block to exception. This is like `map` for the exception.
+```ruby
+Fear.failure(ArgumentError.new).recover_with do
+  raise
+end #=> Fear.failure(RuntimeError)
+```
+
+The second possibility for recovery is `Try#recover` method. It is like `map` for the exception. And it's also heavely
+relies on pattern matching.
 
 ```ruby
-Success(42).recover { |e| e.massage }
-  #=> Success(42)
-Failure(ArgumentError.new).recover { |e| e.massage }
-  #=> Success('ArgumentError')
-Failure(ArgumentError.new).recover { |e| raise }
-  #=> Failure(RuntimeError)
+Fear.success(42).recover do |m|
+  m.case(&:message)
+end #=> Fear.success(42)
+
+Fear.failure(ArgumentError.new).recover do |m|
+  m.case(ZeroDivisionError) { 0 }
+  m.case(&:message)
+end #=> Fear.success('ArgumentError')
+```
+
+If the block raises an error, this new error returned as an result
+
+```ruby
+Fear.failure(ArgumentError.new).recover do |m|
+  raise
+end #=> Fear.failure(RuntimeError)
 ```
 
 #### Try#to_either
@@ -369,11 +410,11 @@ Failure(ArgumentError.new).recover { |e| raise }
 Returns `Left` with exception if this is a `Failure`, otherwise returns `Right` with `Success` value.
 
 ```ruby
-Success(42).to_either                #=> Right(42)
-Failure(ArgumentError.new).to_either #=> Left(ArgumentError.new)
+Fear.success(42).to_either                #=> Fear.right(42)
+Fear.failure(ArgumentError.new).to_either #=> Fear.left(ArgumentError.new)
 ```
 
-### Either ([Documentation](http://www.rubydoc.info/github/bolshakov/fear/master/Fear/Either))
+### Either ([API Documentation](https://www.rubydoc.info/github/bolshakov/fear/master/Fear/Option))
   
 Represents a value of one of two possible types (a disjoint union.)
 An instance of `Either` is either an instance of `Left` or `Right`.
@@ -390,9 +431,9 @@ received input is a +String+ or an +Fixnum+.
 ```ruby
 in = Readline.readline('Type Either a string or an Int: ', true)
 result = begin
-  Right(Integer(in))
+  Fear.right(Integer(in))
 rescue ArgumentError
-  Left(in)
+  Fear.left(in)
 end
 
 result.match do |m|
@@ -410,16 +451,25 @@ Either is right-biased, which means that `Right` is assumed to be the default ca
 operate on. If it is `Left`, operations like `#map`, `#flat_map`, ... return the `Left` value
 unchanged.
 
+Alternatively, include `Fear::Either::Mixin` to use `Left()`, and `Right()` methods:
+
+```ruby
+include Fear::Either::Mixin 
+
+Left(42)  #=> #<Fear::Left value=42>
+Right(42)  #=> #<Fear::Right value=42>
+```
+
 #### Either#get_or_else
 
 Returns the value from this `Right` or evaluates the given default argument if this is a `Left`.
 
 ```ruby
-Right(42).get_or_else { 24/2 }         #=> 42
-Left('undefined').get_or_else { 24/2 } #=> 12
+Fear.right(42).get_or_else { 24/2 }         #=> 42
+Fear.left('undefined').get_or_else { 24/2 } #=> 12
 
-Right(42).get_or_else(12)         #=> 42
-Left('undefined').get_or_else(12) #=> 12
+Fear.right(42).get_or_else(12)         #=> 42
+Fear.left('undefined').get_or_else(12) #=> 12
 ```
 
 #### Either#or_else
@@ -427,9 +477,9 @@ Left('undefined').get_or_else(12) #=> 12
 Returns self `Right` or the given alternative if this is a `Left`.
 
 ```ruby
-Right(42).or_else { Right(21) }           #=> Right(42)
-Left('unknown').or_else { Right(21) }     #=> Right(21)
-Left('unknown').or_else { Left('empty') } #=> Left('empty')
+Fear.right(42).or_else { Fear.right(21) }           #=> Fear.right(42)
+Fear.left('unknown').or_else { Fear.right(21) }     #=> Fear.right(21)
+Fear.left('unknown').or_else { Fear.left('empty') } #=> Fear.left('empty')
 ```
 
 #### Either#include?
@@ -437,9 +487,9 @@ Left('unknown').or_else { Left('empty') } #=> Left('empty')
 Returns `true` if `Right` has an element that is equal to given value, `false` otherwise.
 
 ```ruby
-Right(17).include?(17)         #=> true
-Right(17).include?(7)          #=> false
-Left('undefined').include?(17) #=> false
+Fear.right(17).include?(17)         #=> true
+Fear.right(17).include?(7)          #=> false
+Fear.left('undefined').include?(17) #=> false
 ```
 
 #### Either#each
@@ -447,8 +497,8 @@ Left('undefined').include?(17) #=> false
 Performs the given block if this is a `Right`.
 
 ```ruby
-Right(17).each { |value| puts value } #=> prints 17
-Left('undefined').each { |value| puts value } #=> does nothing
+Fear.right(17).each { |value| puts value } #=> prints 17
+Fear.left('undefined').each { |value| puts value } #=> does nothing
 ```
 
 #### Either#map
@@ -456,8 +506,8 @@ Left('undefined').each { |value| puts value } #=> does nothing
 Maps the given block to the value from this `Right` or returns self if this is a `Left`.
 
 ```ruby
-Right(42).map { |v| v/2 }          #=> Right(21)
-Left('undefined').map { |v| v/2 }  #=> Left('undefined')
+Fear.right(42).map { |v| v/2 }          #=> Fear.right(21)
+Fear.left('undefined').map { |v| v/2 }  #=> Fear.left('undefined')
 ```
 
 #### Either#flat_map
@@ -465,8 +515,8 @@ Left('undefined').map { |v| v/2 }  #=> Left('undefined')
 Returns the given block applied to the value from this `Right` or returns self if this is a `Left`.
 
 ```ruby
-Right(42).flat_map { |v| Right(v/2) }         #=> Right(21)
-Left('undefined').flat_map { |v| Right(v/2) } #=> Left('undefined')
+Fear.right(42).flat_map { |v| Fear.right(v/2) }         #=> Fear.right(21)
+Fear.left('undefined').flat_map { |v| Fear.right(v/2) } #=> Fear.left('undefined')
 ```
 
 #### Either#to_option
@@ -474,8 +524,8 @@ Left('undefined').flat_map { |v| Right(v/2) } #=> Left('undefined')
 Returns an `Some` containing the `Right` value or a `None` if this is a `Left`.
 
 ```ruby
-Right(42).to_option          #=> Some(21)
-Left('undefined').to_option  #=> None
+Fear.right(42).to_option          #=> Fear.some(21)
+Fear.left('undefined').to_option  #=> Fear::None
 ```
 
 #### Either#any?
@@ -483,9 +533,9 @@ Left('undefined').to_option  #=> None
 Returns `false` if `Left` or returns the result of the application of the given predicate to the `Right` value.
 
 ```ruby
-Right(12).any?( |v| v > 10)         #=> true
-Right(7).any?( |v| v > 10)          #=> false
-Left('undefined').any?( |v| v > 10) #=> false
+Fear.right(12).any?( |v| v > 10)         #=> true
+Fear.right(7).any?( |v| v > 10)          #=> false
+Fear.left('undefined').any?( |v| v > 10) #=> false
 ```
 
 #### Either#right?, Either#success?
@@ -493,8 +543,8 @@ Left('undefined').any?( |v| v > 10) #=> false
 Returns `true` if this is a `Right`, `false` otherwise.
 
 ```ruby
-Right(42).right?   #=> true
-Left('err').right? #=> false
+Fear.right(42).right?   #=> true
+Fear.left('err').right? #=> false
 ```
 
 #### Either#left?, Either#failure?
@@ -502,8 +552,8 @@ Left('err').right? #=> false
 Returns `true` if this is a `Left`, `false` otherwise.
 
 ```ruby
-Right(42).left?   #=> false
-Left('err').left? #=> true
+Fear.right(42).left?   #=> false
+Fear.left('err').left? #=> true
 ```
 
 #### Either#select_or_else
@@ -512,10 +562,10 @@ Returns `Left` of the default if the given predicate does not hold for the right
 returns `Right`.
 
 ```ruby
-Right(12).select_or_else(-1, &:even?)       #=> Right(12)
-Right(7).select_or_else(-1, &:even?)        #=> Left(-1)
-Left(12).select_or_else(-1, &:even?)        #=> Left(12)
-Left(12).select_or_else(-> { -1 }, &:even?) #=> Left(12)
+Fear.right(12).select_or_else(-1, &:even?)       #=> Fear.right(12)
+Fear.right(7).select_or_else(-1, &:even?)        #=> Fear.left(-1)
+Fear.left(12).select_or_else(-1, &:even?)        #=> Fear.left(12)
+Fear.left(12).select_or_else(-> { -1 }, &:even?) #=> Fear.left(12)
 ```
 
 #### Either#select
@@ -523,10 +573,10 @@ Left(12).select_or_else(-> { -1 }, &:even?) #=> Left(12)
 Returns `Left` of value if the given predicate does not hold for the right value, otherwise, returns `Right`.
 
 ```ruby
-Right(12).select(&:even?) #=> Right(12)
-Right(7).select(&:even?)  #=> Left(7)
-Left(12).select(&:even?)  #=> Left(12)
-Left(7).select(&:even?)   #=> Left(7)
+Fear.right(12).select(&:even?) #=> Fear.right(12)
+Fear.right(7).select(&:even?)  #=> Fear.left(7)
+Fear.left(12).select(&:even?)  #=> Fear.left(12)
+Fear.left(7).select(&:even?)   #=> Fear.left(7)
 ```
 
 #### Either#reject
@@ -534,10 +584,10 @@ Left(7).select(&:even?)   #=> Left(7)
 Returns `Left` of value if the given predicate holds for the right value, otherwise, returns `Right`.
 
 ```ruby
-Right(12).reject(&:even?) #=> Left(12)
-Right(7).reject(&:even?)  #=> Right(7)
-Left(12).reject(&:even?)  #=> Left(12)
-Left(7).reject(&:even?)   #=> Left(7)
+Fear.right(12).reject(&:even?) #=> Fear.left(12)
+Fear.right(7).reject(&:even?)  #=> Fear.right(7)
+Fear.left(12).reject(&:even?)  #=> Fear.left(12)
+Fear.left(7).reject(&:even?)   #=> Fear.left(7)
 ```
 
 #### Either#swap
@@ -545,8 +595,8 @@ Left(7).reject(&:even?)   #=> Left(7)
 If this is a `Left`, then return the left value in `Right` or vice versa.
 
 ```ruby
-Left('left').swap   #=> Right('left')
-Right('right').swap #=> Light('left')
+Fear.left('left').swap   #=> Fear.right('left')
+Fear.right('right').swap #=> Fear.left('left')
 ```
 
 #### Either#reduce
@@ -569,10 +619,10 @@ Joins an `Either` through `Right`. This method requires that the right side of t
 `Either` type. This method, and `join_left`, are analogous to `Option#flatten`
 
 ```ruby
-Right(Right(12)).join_right      #=> Right(12)
-Right(Left("flower")).join_right #=> Left("flower")
-Left("flower").join_right        #=> Left("flower")
-Left(Right("flower")).join_right #=> Left(Right("flower"))
+Fear.right(Fear.right(12)).join_right      #=> Fear.right(12)
+Fear.right(Fear.left("flower")).join_right #=> Fear.left("flower")
+Fear.left("flower").join_right        #=> Fear.left("flower")
+Fear.left(Fear.right("flower")).join_right #=> Fear.left(Fear.right("flower"))
 ```
 
 #### Either#join_right
@@ -581,32 +631,179 @@ Joins an `Either` through `Left`. This method requires that the left side of thi
 `Either` type. This method, and `join_right`, are analogous to `Option#flatten`
 
 ```ruby
-Left(Right("flower")).join_left #=> Right("flower")
-Left(Left(12)).join_left        #=> Left(12)
-Right("daisy").join_left        #=> Right("daisy")
-Right(Left("daisy")).join_left  #=> Right(Left("daisy"))
+Fear.left(Fear.right("flower")).join_left #=> Fear.right("flower")
+Fear.left(Fear.left(12)).join_left        #=> Fear.left(12)
+Fear.right("daisy").join_left        #=> Fear.right("daisy")
+Fear.right(Fear.left("daisy")).join_left  #=> Fear.right(Fear.left("daisy"))
 ```
-  
-### For composition
+
+### Future ([API Documentation](https://www.rubydoc.info/github/bolshakov/fear/master/Fear/Future))
+
+Asynchronous computations that yield futures are created
+with the `Fear.future` call
+
+```ruby
+success = "Hello"
+f = Fear.future { success + ' future!' }
+f.on_success do |result|
+  puts result
+end
+```
+
+Multiple callbacks may be registered; there is no guarantee
+that they will be executed in a particular order.
+
+The future may contain an exception and this means
+that the future failed. Futures obtained through combinators
+have the same error as the future they were obtained from.
+
+```ruby 
+f = Fear.future { 5 }
+g = Fear.future { 3 }
+
+f.flat_map do |x|
+  g.map { |y| x + y }
+end
+```
+
+Futures use [Concurrent::Promise](https://ruby-concurrency.github.io/concurrent-ruby/1.1.5/Concurrent/Promise.html#constructor_details)
+under the hood. `Fear.future` accepts optional configuration Hash passed directly to underlying promise. For example, 
+run it on custom thread pool.
+
+```ruby
+require 'open-uri'
+pool = Concurrent::FixedThreadPool.new(5)
+future = Fear.future(executor: pool) { open('https://example.com/') }
+future.map(&:read).each do |body| 
+  puts "#{body}"
+end
+
+``` 
+
+Futures support common monadic operations -- `#map`, `#flat_map`, and `#each`. That's why it's possible to combine them 
+using `Fear.for`, It returns the Future containing Success of `5 + 3` eventually.
+
+```ruby 
+f = Fear.future { 5 }
+g = Fear.future { 3 }
+
+Fear.for(f, g) do |x, y|
+  x + y
+end 
+``` 
+
+Future goes with the number of callbacks. You can register several callbacks, but the order of execution isn't guaranteed 
+
+```ruby
+f = Fear.future { ... } #  call external service
+f.on_success do |result|
+  # handle service response
+end
+
+f.on_failure do |error|
+  # handle exception
+end
+```
+
+or you can wait for Future completion
+
+```ruby 
+f.on_complete do |result|
+  result.match do |m|
+    m.success { |value| ... }
+    m.failure { |error| ... }
+  end
+end 
+```
+
+In sake of convenience `#on_success` callback aliased as `#each`.
+
+It's possible to get future value directly, but since it may be incomplete, `#value` method returns `Fear::Option`. So, 
+there are three possible responses:
+
+```ruby 
+future.value #=>
+# Fear::Some<Fear::Success> #=> future completed with value
+# Fear::Some<Fear::Failure> #=> future completed with error
+# Fear::None #=> future not yet completed
+```    
+
+There is a variety of methods to manipulate with futures. 
+
+```ruby
+Fear.future { open('http://example.com').read }
+  .transform(
+     ->(value) { ... },
+     ->(error) { ... },
+  )
+
+future = Fear.future { 5 }
+future.select(&:odd?) # evaluates to Fear.success(5)
+future.select(&:even?) # evaluates to Fear.error(NoSuchElementError)
+```
+
+You can zip several asynchronous computations into one future. For you can call two external services and 
+then zip the results into one future containing array of both responses:  
+
+```ruby 
+future1 = Fear.future { call_service1 }
+future1 = Fear.future { call_service2 }
+future1.zip(future2)
+``` 
+
+It  returns the same result as `Fear.future { [call_service1, call_service2] }`,  but the first version performs
+two simultaneous calls.
+
+There are two ways to recover from failure. `Future#recover` is live `#map` for failures:
+
+```ruby
+Fear.future { 2 / 0 }.recover do |m|
+  m.case(ZeroDivisionError) { 0 }
+end #=> returns new future of Fear.success(0)
+```
+
+If the future resolved to success or recovery matcher did not matched, it returns the future `Fear::Failure`.
+
+The second option is `Future#fallbock_to` method. It allows to fallback to result of another future in case of failure
+
+```ruby
+future = Fear.future { fail 'error' }
+fallback = Fear.future { 5 }
+future.fallback_to(fallback) # evaluates to 5
+```
+
+You can run callbacks in specific order using `#and_then` method:
+
+```ruby 
+f = Fear.future { 5 }
+f.and_then do
+  fail 'runtime error'
+end.and_then do |m|
+  m.success { |value| puts value } # it evaluates this branch
+  m.failure { |error| puts error.massage }
+end
+```
+
+### For composition ([API Documentation](http://www.rubydoc.info/github/bolshakov/fear/master/Fear/ForApi))
 
 Provides syntactic sugar for composition of multiple monadic operations. 
 It supports two such operations - `flat_map` and `map`. Any class providing them
 is supported by `For`.
 
 ```ruby
-For(Some(2), Some(3)) do |a, b|
+Fear.for(Fear.some(2), Fear.some(3)) do |a, b|
   a * b
-end #=> Some(6)
+end #=> Fear.some(6)
 ```
 
 If one of operands is None, the result is None
 
 ```ruby
-For(Some(2), None) do |a, b| 
+Fear.for(Fear.some(2), None) do |a, b| 
   a * b 
 end #=> None
 
-For(None, Some(2)) do |a, b| 
+Fear.for(None, Fear.some(2)) do |a, b| 
   a * b 
 end #=> None
 ```
@@ -614,7 +811,7 @@ end #=> None
 Lets look at first example:
 
 ```ruby
-For(Some(2), None) do |a, b| 
+Fear.for(Fear.some(2), None) do |a, b| 
   a * b 
 end #=> None
 ```
@@ -622,8 +819,8 @@ end #=> None
 it is translated to:
 
 ```ruby
-Some(2).flat_map do |a|
-  Some(3).map do |b|
+Fear.some(2).flat_map do |a|
+  Fear.some(3).map do |b|
     a * b
   end
 end
@@ -632,7 +829,7 @@ end
 It works with arrays as well
 
 ```ruby
-For([1, 2], [2, 3], [3, 4]) { |a, b, c| a * b * c }
+Fear.for([1, 2], [2, 3], [3, 4]) { |a, b, c| a * b * c }
   #=> [6, 8, 9, 12, 12, 16, 18, 24]
 
 ```
@@ -653,7 +850,7 @@ If you pass lambda as a variable value, it would be evaluated
 only on demand.
 
 ```ruby
-For(proc { None }, proc { raise 'kaboom' } ) do |a, b|
+Fear.for(proc { None }, proc { raise 'kaboom' } ) do |a, b|
   a * b
 end #=> None
 ```
@@ -664,131 +861,222 @@ You can refer to previously defined variables from within lambdas.
 ```ruby
 maybe_user = find_user('Paul') #=> <#Option value=<#User ...>>
 
-For(maybe_user, ->(user) { user.birthday }) do |user, birthday|
+Fear.for(maybe_user, ->(user) { user.birthday }) do |user, birthday|
   "#{user.name} was born on #{birthday}"
-end #=> Some('Paul was born on 1987-06-17')
+end #=> Fear.some('Paul was born on 1987-06-17')
 ```
 
-### Pattern Matching (API Documentation)
+### Pattern Matching ([API Documentation](https://www.rubydoc.info/github/bolshakov/fear/master/Fear/PatternMatchingApi))
 
-Pattern matcher is a combination of partial functions wrapped into nice DSL. Every partial function 
-defined on domain described with guard.
+#### Syntax
 
-```ruby
-pf = Fear.case(Integer) { |x| x / 2 }
-pf.defined_at?(4) #=> true
-pf.defined_at?('Foo') #=> false
-pf.call('Foo') #=> raises Fear::MatchError
-pf.call_or_else('Foo') { 'not a number' } #=> 'not a number'
-pf.call_or_else(4) { 'not a number' } #=> 2
-pf.lift.call('Foo') #=> Fear::None
-pf.lift.call(4) #=> Fear::Some(2)
+To pattern match against a value, use `Fear.match` function, and provide at least one case clause:
+
+```ruby 
+x = Random.rand(10)
+
+Fear.match(x) do |m|
+  m.case(0) { 'zero' }
+  m.case(1) { 'one' }
+  m.case(2) { 'two' }
+  m.else { 'many' }
+end
 ```
 
-It uses `#===` method under the hood, so you can pass:
+The `x` above is a random integer from 0 to 10. The last clause `else` is a “catch all” case 
+for anything other than `0`, `1`, and `2`. If you want to ensure that an Integer value is passed,
+matching against type available:
 
-* Class to check kind of an object.
-* Lambda to evaluate it against an object.
-* Any literal, like `4`, `"Foobar"`, etc.
-* Symbol -- it is converted to lambda using `#to_proc` method.
-* Qo matcher -- `m.case(Qo[name: 'John']) { .... }`
- 
-Partial functions may be combined with each other:
+```ruby 
+Fear.match(x) do |m|
+  m.case(Integer, 0) { 'zero' }
+  m.case(Integer, 1) { 'one' }
+  m.case(Integer, 2) { 'two' }
+  m.case(Integer) { 'many' }
+end
+```
 
-```ruby
-is_even = Fear.case(->(arg) { arg % 2 == 0}) { |arg| "#{arg} is even" }
-is_odd = Fear.case(->(arg) { arg % 2 == 1}) { |arg| "#{arg} is odd" }
+Providing  something other than Integer will raise `Fear::MatchError` error.
 
-(10..20).map(&is_even.or_else(is_odd))
+#### Pattern guards 
 
-to_integer = Fear.case(String, &:to_i)
-integer_two_times = Fear.case(Integer) { |x| x * 2 }
+You can use whatever you want as a pattern guard, if it respond to `#===` method to to make cases more specific. 
 
-two_times = to_integer.and_then(integer_two_times).or_else(integer_two_times)
-two_times.(4) #=> 8
-two_times.('42') #=> 84
+```ruby
+m.case(20..40) { |m| "#{m} is within range" }
+m.case(->(x) { x > 10}) { |m| "#{m} is greater than 10" } 
+m.case(:even?.to_proc) { |x| "#{x} is even" }
+m.case(:odd?.to_proc) { |x| "#{x} is odd" }
 ```
 
-To create custom pattern match use `Fear.match` method and `case` builder to define
-branches. For instance this matcher applies different functions to Integers and Strings
+It's also possible to create matcher and use it several times:
 
-```ruby 
-Fear.match(value) do |m|
+```ruby
+matcher = Fear.matcher do |m|
   m.case(Integer) { |n| "#{n} is a number" }
   m.case(String) { |n| "#{n} is a string" }
+  m.else  { |n| "#{n} is a #{n.class}" }
+end 
+
+matcher.(42) #=> "42 is a number"
+matcher.(10..20) #=> "10..20 is a Range"
+``` 
+
+#### Pattern extraction 
+
+It's possible to use special syntax to match against an object and extract a variable form this object.
+To perform such extraction, `#xcase` method should be used. The following example should give you a sense 
+how extraction works.
+
+```ruby
+matcher = Fear.matcher do |m|
+  m.xcase('[1, *tail]') { |tail:| tail }
 end
 ```
 
-if you pass something other than Integer or string, it will raise `Fear::MatchError` error.
-To avoid raising `MatchError`, you can use `else` method. It defines a branch matching
-on any value.
+It matches only on an array starting from `1` integer, and captures its tail:
+
+```ruby
+matcher.([1,2,3]) #=> [2,3]
+matcher.([2,3]) #=> raises MatchError
+``` 
+
+If you want to match against any value, use `_` 
 
 ```ruby 
-Fear.match(10..20) do |m|
-  m.case(Integer) { |n| "#{n} is a number" }
-  m.case(String) { |n| "#{n} is a string" }
-  m.else  { |n| "#{n} is a #{n.class}" }
-end #=> "10..20 is a Range"
+matcher = Fear.matcher do |m|
+  m.xcase('[1, _, 3]') { .. }
+end
 ```
 
-You can use anything as a guardian if it responds to `#===` method:
+It matches against `[1, 2, 3]`, `[1, 'foo', 3]`, but not `[1, 2]`. It's also possible to capture several variables
+at the same time. Tho following example describes an array starting from `1`, and captures second and third elements.
+
+
+```ruby 
+matcher = Fear.matcher do |m|
+  m.xcase('[1, second, third]') { |second:, third: |.. }
+end
+``` 
+
+Matching on deeper structures is possible as well:
+
+```ruby 
+matcher = Fear.matcher do |m|
+  m.xcase('[["status", first_status], 4, *tail]') { |first_status:, tail: |.. }
+end
+``` 
+
+If you want to capture variable of specific type, there is a type matcher for that case:
+
+```ruby 
+matcher = Fear.matcher do |m|
+  m.xcase('[head : String, 2, *]') { |head: | head }
+end
+matcher.(['foo', 2]) #=> 'foo'
+matcher.(['foo', 3]) #=> MatchError
+matcher.([1, 2]) #=> MatchError
+``` 
+
+You can extract variables from more complex objects. Fear packed with extractors for monads and `Date` object:
 
 ```ruby
-m.case(20..40) { |m| "#{m} is within range" }
-m.case(->(x) { x > 10}) { |m| "#{m} is greater than 10" }
+Fear.matcher do |m|
+  m.xcase('Date(year, 2, 29)', ->(year:) { year < 2000 }) do |year:|
+    "#{year} is a leap year before Millennium"
+  end
+  
+  m.xcase('Date(year, 2, 29)') do |year:|
+    "#{year} is a leap year after Millennium"
+  end
+  
+  m.case(Date) do |date|
+    "#{date.year} is not a leap year"
+  end
+end
+``` 
+
+This matcher extracts values from date object and match against them at the same time
+
+```ruby 
+matcher.(Date.new(1996,02,29)) #=> "1996 is a leap year before Millennium"
+matcher.(Date.new(2004,02,29)) #=> "1996 is a leap year after Millennium"
+matcher.(Date.new(2003,01,24)) #=> "2003 is not a leap year"
 ```
 
-If you pass a Symbol, it will be converted to proc using `#to_proc` method
+Nothing tricky here. The extractor object takes an object and tries to give back the arguments. It's like 
+constructor, but instead of construction an object, it deconstructs it. 
+
+An argument of an extractor may be also a pattern or even  introduce a new variable. 
 
 ```ruby 
-m.case(:even?) { |x| "#{x} is even" }
-m.case(:odd?) { |x| "#{x} is odd" }
+matcher = Fear.matcher do |m|
+  m.xcase('Some([status : Integer, body : String])') do |status:, body:|
+    "#{body.bytesize} bytes received with code #{status}"
+  end 
+end
+
+matcher.(Fear.some([200, 'hello'])) #=> "5 bytes received with code 200"
+matcher.(Fear.some(['hello', 200])) #=> MatchError 
 ```
 
-It's also possible to pass several guardians. All should match to pass
+You can provide extractors for you own classes
 
 ```ruby 
-m.case(Integer, :even?) { |x| ... }
-m.case(Integer, :odd?) { |x| ... }
+Fear.register_extractor(User, Fear.case(User) { |user| [user.id, user.email] }.lift)
+# is the same as
+Fear.register_extractor(User, proc do |user|
+  if user.is_a?(User)
+    Fear.some([user.id, user.email])
+  else
+    Fear.none
+  end
+end)
 ```
 
-It's also possible to create matcher and use it several times:
+Now extracting user's id and email is possible:
 
-```ruby
-matcher = Fear.matcher do |m|
-  m.case(Integer) { |n| "#{n} is a number" }
-  m.case(String) { |n| "#{n} is a string" }
-  m.else  { |n| "#{n} is a #{n.class}" }
-end 
 
-matcher.(42) #=> "42 is a number"
-matcher.(10..20) #=> "10..20 is a Range"
-``` 
+```ruby 
+Fear.match(user) do |m|
+  m.xcase('User(id, email)') { |id:, email:| }
+end
+```
 
-Since matcher is just a syntactic sugar for partial functions, you can combine matchers with partial
-functions and each other. 
+Note, registered extractor should return either array of arguments, or boolean.
+
+#### Extracting struct
+
+There is predefined `Struct` extractor:
 
 ```ruby
-handle_numbers = Fear.case(Integer, &:itself).and_then(
-  Fear.matcher do |m|
-    m.case(0) { 'zero' }
-    m.case(->(n) { n < 10 }) { 'smaller than ten' }  
-    m.case(->(n) { n > 10 }) { 'bigger than ten' }
-  end
-)
+Envelope = Struct.new(:id, :receiver, :sender, :message)
 
-handle_strings = Fear.case(String, &:itself).and_then(
-  Fear.matcher do |m|
-    m.case('zero') { 0 }
-    m.case('one') { 1 }
-    m.else { 'unexpected' }
+Fear.matcher do |m|
+  m.xcase('envelope @ Envelope(id, _, sender, _)') do |id:, sender:, envelope:|
+    acknowledge(id, sender)
+    process(acknowledge)
   end
-)
+end
+```
 
-handle = handle_numbers.or_else(handle_strings)
-handle.(0) #=> 'zero'
-handle.(12) #=> 'bigger than ten'
-handle.('one') #=> 1
+#### How to debug pattern extractors?
+
+You can build pattern manually and ask for failure reason:
+
+```ruby
+Fear['Some([:err, 444])'].failure_reason(Fear.some([:err, 445]))
+# =>
+Expected `445` to match:
+Some([:err, 444])
+~~~~~~~~~~~~^
+```
+
+by the way you can also match against such pattern
+
+```ruby
+Fear['Some([:err, 444])'] === Fear.some([:err, 445]) #=> false
+Fear['Some([:err, 444])'] === Fear.some([:err, 445]) #=> true
 ```
 
 #### More examples
@@ -811,7 +1099,6 @@ fibonnaci = Fear.matcher do |m|
   m.case(0) { 0 }
   m.case(1) { 1 }
   m.case(->(n) { n > 1}) { |n| fibonnaci.(n - 1) + fibonnaci.(n - 2) }
-  m.else { raise 'should be positive' }
 end
 
 fibonnaci.(10) #=> 55
@@ -827,7 +1114,7 @@ only on container itself, but on enclosed value as well.
 Pattern match against an `Option`
 
 ```ruby
-Some(42).match do |m|
+Fear.some(42).match do |m|
   m.some { |x| x * 2 }
   m.none { 'none' }
 end #=> 84
@@ -836,9 +1123,9 @@ end #=> 84
 pattern match on enclosed value
 
 ```ruby
-Some(41).match do |m|
-  m.some(:even?) { |x| x / 2 }
-  m.some(:odd?, ->(v) { v > 0 }) { |x| x * 2 }
+Fear.some(41).match do |m|
+  m.some(:even?.to_proc) { |x| x / 2 }
+  m.some(:odd?.to_proc, ->(v) { v > 0 }) { |x| x * 2 }
   m.none { 'none' }
 end #=> 82
 ``` 
@@ -846,8 +1133,8 @@ end #=> 82
 it raises `Fear::MatchError` error if nothing matched. To avoid exception, you can pass `#else` branch
 
 ```ruby
-Some(42).match do |m|
-  m.some(:odd?) { |x| x * 2 }
+Fear.some(42).match do |m|
+  m.some(:odd?.to_proc) { |x| x * 2 }
   m.else { 'nothing' }
 end #=> nothing
 ```
@@ -857,16 +1144,81 @@ Pattern matching works the similar way for `Either` and `Try` monads.
 In sake of performance, you may want to generate pattern matching function and reuse it multiple times:
 
 ```ruby
-matcher = Option.matcher do |m|
+matcher = Fear::Option.matcher do |m|
   m.some(42) { 'Yep' }
   m.some { 'Nope' }
   m.none { 'Error' } 
 end
 
-matcher.(Some(42)) #=> 'Yep'
-matcher.(Some(40)) #=> 'Nope'
+matcher.(Fear.some(42)) #=> 'Yep'
+matcher.(Fear.some(40)) #=> 'Nope'
 ``` 
 
+#### Under the hood 
+
+Pattern matcher is a combination of partial functions wrapped into nice DSL. Every partial function 
+defined on domain described with guard.
+
+```ruby
+pf = Fear.case(Integer) { |x| x / 2 }
+pf.defined_at?(4) #=> true
+pf.defined_at?('Foo') #=> false
+pf.call('Foo') #=> raises Fear::MatchError
+pf.call_or_else('Foo') { 'not a number' } #=> 'not a number'
+pf.call_or_else(4) { 'not a number' } #=> 2
+pf.lift.call('Foo') #=> Fear::None
+pf.lift.call(4) #=> Fear.some(2)
+```
+
+It uses `#===` method under the hood, so you can pass:
+
+* Class to check kind of an object.
+* Lambda to evaluate it against an object.
+* Any literal, like `4`, `"Foobar"`, `:not_found` etc.
+* Qo matcher -- `m.case(Qo[name: 'John']) { .... }`
+ 
+Partial functions may be combined with each other:
+
+```ruby
+is_even = Fear.case(->(arg) { arg % 2 == 0}) { |arg| "#{arg} is even" }
+is_odd = Fear.case(->(arg) { arg % 2 == 1}) { |arg| "#{arg} is odd" }
+
+(10..20).map(&is_even.or_else(is_odd))
+
+to_integer = Fear.case(String, &:to_i)
+integer_two_times = Fear.case(Integer) { |x| x * 2 }
+
+two_times = to_integer.and_then(integer_two_times).or_else(integer_two_times)
+two_times.(4) #=> 8
+two_times.('42') #=> 84
+```
+
+Since matcher is just a syntactic sugar for partial functions, you can combine matchers with partial
+functions and each other. 
+
+```ruby
+handle_numbers = Fear.case(Integer, &:itself).and_then(
+  Fear.matcher do |m|
+    m.case(0) { 'zero' }
+    m.case(->(n) { n < 10 }) { 'smaller than ten' }  
+    m.case(->(n) { n > 10 }) { 'bigger than ten' }
+  end
+)
+
+handle_strings = Fear.case(String, &:itself).and_then(
+  Fear.matcher do |m|
+    m.case('zero') { 0 }
+    m.case('one') { 1 }
+    m.else { 'unexpected' }
+  end
+)
+
+handle = handle_numbers.or_else(handle_strings)
+handle.(0) #=> 'zero'
+handle.(12) #=> 'bigger than ten'
+handle.('one') #=> 1
+```
+
 ## Testing
 
 To simplify testing, you may use [fear-rspec](https://github.com/bolshakov/fear-rspec) gem. It
@@ -882,6 +1234,7 @@ provides a bunch of rspec matchers.
 
 ## Alternatives
 
+* [algebrick](https://github.com/pitr-ch/algebrick)
 * [deterministic](https://github.com/pzol/deterministic)
 * [dry-monads](https://github.com/dry-rb/dry-monads)
 * [kleisli](https://github.com/txus/kleisli)