fear 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4f87d9ddc3fd6c7bdd259ed164ca27668c3421f1
-  data.tar.gz: f1cd2982080e8b8f302be524f55ef18f9406b3e6
+  metadata.gz: 9f6f57b15284f2ed3034bc697608d9c44e7401b1
+  data.tar.gz: 439fb988ae4fab755815100e092a65db332e960e
 SHA512:
-  metadata.gz: 18926b68929c6b68b8e7e3fe1f5352a2998dade76e1860097b470a93e7d236142a84b1cf98a2413b6b093dd412461bc5fa764f10a3753cf932ab0558d8d59d9e
-  data.tar.gz: 95c5eecb1b37444c63fdf713bcee58306053ba5708b10b4c7f6d4fa4dd53804143bc321cb5b10927297f136951d83573d9924086b6faa0794a239513603b12c3
+  metadata.gz: 8409d00dd720c5dfbd623e73d72abd86ae5c90235e08dd646ad2e9c19b17c502d1a3d0f9a372ae23bb1af1e6cd9571cd425a6c7305e95256746031a6a634c71b
+  data.tar.gz: 051a50aa71c6fad65b52798ee303f59037c988365a449afa4653afab5f62d53443c31d0d731d07f09a39c564d330cd927243b701e7925aefa913f78ba7fd52fb

data/.rubocop.yml

@@ -1,6 +1,10 @@
 inherit_gem:
   spbtv_code_style: .strict_rubocop.yml
 
+AllCops:
+  Exclude:
+  - 'gemfiles/**/*'
+
 Style/MethodName:
   Enabled: false
 

data/.travis.yml

@@ -1,9 +1,17 @@
+---
 language: ruby
 rvm:
-  - 2.3.7
-  - 2.4.4
-  - 2.5.1
+- 2.4.5
+- 2.5.3
+- 2.6.1
+before_script:
+- bundle install
 script:
- - rubocop -D
- - bundle exec rspec spec
-env: CODECLIMATE_REPO_TOKEN=548312a77df2507c49494d3c6e78cc62631517c39440644c38217d9be1f47e26
+- bundle exec rspec
+- bundle exec rubocop --fail-level C
+gemfile:
+- gemfiles/dry_equalizer_0.2.1.gemfile
+- gemfiles/dry_equalizer_0.1.0.gemfile
+addons:
+  code_climate:
+    repo_token: c326cca5984d0e32d2c6b5d9b985756ee9312f63fc6a9480fc9cfa55c454d68a

data/Appraisals

@@ -0,0 +1,36 @@
+require 'yaml'
+
+ruby_versions = %w(2.4.5 2.5.3 2.6.1)
+dry_equalizer_versions = %w(0.1.0 0.2.1)
+
+dry_equalizer_versions.each do |version|
+  appraise "dry-equalizer-#{version}" do
+    gem 'dry-equalizer', version
+  end
+end
+
+Dir.glob('gemfiles/*.gemfile').tap do |gemfiles|
+  travis = ::YAML.dump(
+    'language' => 'ruby',
+    'rvm' => ruby_versions,
+    'before_script' => [
+      'bundle install',
+    ],
+    'script' => [
+      'bundle exec rspec',
+      'bundle exec rubocop --fail-level C',
+    ],
+    'gemfile' => gemfiles,
+    'addons' => {
+      'code_climate' => {
+        'repo_token' => 'c326cca5984d0e32d2c6b5d9b985756ee9312f63fc6a9480fc9cfa55c454d68a'
+      }
+    }
+
+
+  )
+
+  ::File.open('.travis.yml', 'w+') do |file|
+    file.write(travis)
+  end
+end

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 0.10.0
+
+* Test against last supported ruby versions: 2.4.5, 2.5.3, 2.6.1 ([@bolshakov][])
+* You can use `fear` with any `dry-equalizer` version (up to 0.2.1) ([@bolshakov][])
+
 ## 0.9.0
 
 * Test against last supported ruby versions: 2.3.7, 2.4.4, 2.5.1 ([@bolshakov][])

data/README.md

@@ -25,60 +25,371 @@ Or install it yourself as:
 
 ## Usage
 
+* [Option](#option-documentation) 
+* [Try](#try-documentation)
+* [Either](#either-documentation)
+* [For composition](#for-composition)
+* [Pattern Matching](#pattern-matching)
+
 ### Option ([Documentation](http://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`.
 
-The most idiomatic way to use an `Option` instance is to treat it
-as a collection and use `map`, `flat_map`, `select`, or `each`:
+The most idiomatic way to use an `Option` instance is to treat it as a collection
 
 ```ruby
-include Fear::Option::Mixin
+name = Option(params[:name])
+upper = name.map(&:strip).select { |n| n.length != 0 }.map(&:upcase)
+puts upper.get_or_else('')
+```
+
+This allows for sophisticated chaining of `Option` values without
+having to check for the existence of a value.
 
-def normalize_name(name)
-  Option(name)
-    .map(&:strip)
-    .select { |n| n.length != 0 }
-    .map(&:upcase)
-    .get_or_else('NONAME')
+A less-idiomatic way to use `Option` values is via pattern matching
+
+```ruby
+name = Option(params[:name])
+case name
+when Some
+ puts name.strip.upcase
+when None
+ puts 'No name value'
 end
+```
+
+or manually checking for non emptiness
 
-normalize_name('robert paulson ') #=> 'ROBERT PAULSON'
-normalize_name(nil) #=> 'NONAME' 
+```ruby
+name = Option(params[:name])
+if name.empty?
+ puts 'No name value'
+else
+ puts name.strip.upcase
+end
 ```
 
-This allows for sophisticated chaining of `Option` values without
-having to check for the existence of a value.
+#### 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
+
+Some(42).get_or_else(12)  #=> 42
+None().get_or_else(12)    #=> 12
+```
+
+#### Option#or_else
+
+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()
+```
+
+#### Option#inlude?
+
+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
+```
+
+#### Option#each
+
+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
+```
+
+#### Option#map 
+
+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()
+```
+
+#### Option#flat_map
+
+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()
+```
+
+#### Option#to_a
+
+Returns an `Array` containing the `Some` value or an empty `Array` if this is a `None`
+
+```ruby
+Some(42).to_a #=> [21]
+None().to_a   #=> []
+```
+
+#### Option#any?
+
+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
+```
+
+#### Option#select
+
+Returns self if it is nonempty and applying the predicate to this `Option`'s value returns `true`. Otherwise, 
+return `None`.
+
+```ruby 
+Some(42).select { |v| v > 40 } #=> Success(21)
+Some(42).select { |v| v < 40 } #=> None()
+None().select { |v| v < 40 }   #=> None()
+```
+
+#### Option#reject
+
+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
+```
+
+#### Option#get
+
+Not an idiomatic way of using Option at all. Returns values of raise `NoSuchElementError` error if option is empty.
+   
+#### Option#empty?
+
+Returns `true` if the `Option` is `None`, `false` otherwise.
+
+```ruby
+Some(42).empty? #=> false
+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))
 
-The `Try` represents a computation that may either result in an exception, 
-or return a successfully computed value.  Instances of `Try`, are either 
-an instance of `Success` or `Failure`.
+The `Try` represents a computation that may either result
+in an exception, or return a successfully computed value. Instances of `Try`,
+are either an instance of `Success` or `Failure`.
 
-For example, `Try` can be used to perform division on a user-defined input, 
-without the need to do explicit exception-handling in all of the places 
-that an exception might occur.
+For example, `Try` can be used to perform division on a
+user-defined input, without the need to do explicit
+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]) }
+problem = dividend.flat_map { |x| divisor.map { |y| x / y } }
 
-result = dividend.flat_map { |x| divisor.map { |y| x / y } }
-
-if result.success?
-  puts "Result of #{dividend.get} / #{divisor.get} is: #{result.get}"
+if problem.success?
+  puts "Result of #{dividend.get} / #{divisor.get} is: #{problem.get}"
 else
   puts "You must've divided by zero or entered something wrong. Try again"
-  puts "Info from the exception: #{result.exception.message}"
+  puts "Info from the exception: #{problem.exception.message}"
 end
 ```
 
-### Either ([Documentation](http://www.rubydoc.info/github/bolshakov/fear/master/Fear/Either))
+An important property of `Try` shown in the above example is its
+ability to _pipeline_, or chain, operations, catching exceptions
+along the way. The `flat_map` and `map` combinators in the above
+example each essentially pass off either their successfully completed
+value, wrapped in the `Success` type for it to be further operated
+upon by the next combinator in the chain, or the exception wrapped
+in the `Failure` type usually to be simply passed on down the chain.
+Combinators such as `recover_with` and `recover` are designed to provide some
+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.
+
+#### 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
+```
+
+#### Try#include?
+
+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
+```
+
+#### Try#each
+
+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
+```
+
+#### Try#map
+
+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)
+```
+
+#### Try#flat_map
+
+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)
+```
+
+#### Try#to_a
+
+Returns an `Array` containing the `Success` value or an empty `Array` if this is a `Failure`.
+
+```ruby
+Success(42).to_a                 #=> [21]
+Failure(ArgumentError.new).to_a  #=> []
+```
+
+#### Try#to_option
+
+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()
+```
+
+#### Try#any?
+
+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
+```
+
+#### Try#success? and Try#failure?
+
+
+```ruby
+Success(12).success? #=> true
+Success(12).failure? #=> true
+
+Failure(ArgumentError.new).success? #=> false
+Failure(ArgumentError.new).failure? #=> true
+```
+
+#### Try#get
+
+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
+```
+
+#### Try#or_else
+
+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'))
+```
+
+#### Try#flatten
+
+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)
+```
+
+#### Try#select
+
+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)
+```
 
+#### Try#recover_with
+
+Applies the given block to exception. This is like `flat_map` for the exception.
+
+```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| fail }
+  #=> Failure(RuntimeError)
+```
+
+#### Try#recover
+
+Applies the given block to exception. This is like `map` for the exception.
+
+```ruby
+Success(42).recover { |e| e.massage }
+  #=> Success(42)
+Failure(ArgumentError.new).recover { |e| e.massage }
+  #=> Success('ArgumentError')
+Failure(ArgumentError.new).recover { |e| fail }
+  #=> Failure(RuntimeError)
+```
+
+#### Try#to_either
+
+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)
+```
+
+### Either ([Documentation](http://www.rubydoc.info/github/bolshakov/fear/master/Fear/Either))
+  
 Represents a value of one of two possible types (a disjoint union.)
 An instance of `Either` is either an instance of `Left` or `Right`.
 
@@ -86,19 +397,17 @@ A common use of `Either` is as an alternative to `Option` for dealing
 with possible missing values.  In this usage, `None` is replaced
 with a `Left` which can contain useful information.
 `Right` takes the place of `Some`. Convention dictates
-that `Left` is used for failure and `Right` is used for success.
+that `Left` is used for failure and `Right` is used for Right.
 
-For example, you could use `Either<String, Fixnum>` to select whether a
-received input is a `String` or an `Fixnum`.
+For example, you could use `Either<String, Fixnum>` to `#select_or_else` whether a
+received input is a +String+ or an +Fixnum+.
 
 ```ruby
-include Fear::Either::Mixin
-
-input = Readline.readline('Type Either a string or an Int: ', true)
+in = Readline.readline('Type Either a string or an Int: ', true)
 result = begin
-  Right(Integer(input))
+  Right(Integer(in))
 rescue ArgumentError
-  Left(input)
+  Left(in)
 end
 
 puts(
@@ -107,7 +416,197 @@ puts(
     -> (x) { "You passed me the Int: #{x}, which I will increment. #{x} + 1 = #{x+1}" }
   )
 )
-``` 
+```
+
+Either is right-biased, which means that `Right` is assumed to be the default case to
+operate on. If it is `Left`, operations like `#map`, `#flat_map`, ... return the `Left` value
+unchanged.
+
+#### 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
+
+Right(42).get_or_else(12)         #=> 42
+Left('undefined').get_or_else(12) #=> 12
+```
+
+#### Either#or_else
+
+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')
+```
+
+#### Either#include?
+
+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
+```
+
+#### Either#each
+
+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
+```
+
+#### Either#map
+
+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')
+```
+
+#### Either#flat_map
+
+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')
+```
+
+#### Either#to_a
+
+Returns an `Array` containing the `Right` value or an empty `Array` if this is a `Left`.
+
+```ruby
+Right(42).to_a          #=> [21]
+Left('undefined').to_a  #=> []
+```
+
+#### Either#to_option
+
+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()
+```
+
+#### Either#any?
+
+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
+```
+
+#### Either#right?, Either#success?
+
+Returns `true` if this is a `Right`, `false` otherwise.
+
+```ruby
+Right(42).right?   #=> true
+Left('err').right? #=> false
+```
+
+#### Either#left?, Either#failure?
+
+Returns `true` if this is a `Left`, `false` otherwise.
+
+```ruby
+Right(42).left?   #=> false
+Left('err').left? #=> true
+```
+
+#### Either#select_or_else
+
+Returns `Left` of the default if the given predicate does not hold for the right value, otherwise, 
+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)
+```
+
+#### Either#select
+
+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)
+```
+
+#### Either#reject
+
+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)
+```
+
+#### Either#swap
+
+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')
+```
+
+#### Either#reduce
+
+Applies `reduce_left` if this is a `Left` or `reduce_right` if this is a `Right`.
+
+```ruby
+result = possibly_failing_operation()
+log(
+  result.reduce(
+    ->(ex) { "Operation failed with #{ex}" },
+    ->(v) { "Operation produced value: #{v}" },
+  )
+)
+```
+
+#### Either#join_right
+
+Joins an `Either` through `Right`. This method requires that the right side of this `Either` is itself an
+`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"))
+```
+
+#### Either#join_right
+
+Joins an `Either` through `Left`. This method requires that the left side of this `Either` is itself an
+`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"))
+```
   
 ### For composition
 
@@ -116,49 +615,41 @@ It supports two such operations - `flat_map` and `map`. Any class providing them
 is supported by `For`.
 
 ```ruby
-include Fear::For::Mixin
+For(a: Some(2), b: Some(3)) { a * b } #=> Some(6)
+```
 
-def divide(dividend, divisor)
-  For(x: dividend, y: divisor) do 
-    x / y
-  end
-end
+If one of operands is None, the result is None
+
+```ruby
+For(a: Some(2), b: None()) { a * b } #=> None()
+For(a: None(), b: Some(2)) { a * b } #=> None()
+```
 
-dividend = Try { Integer(params[:dividend]) } #=> Try(4)
-divisor = Try { Integer(params[:divisor]) } #=> Try(2)
+Lets look at first example:
 
-divide(dividend, divisor) #=> Try(2)
+```ruby
+For(a: Some(2), b: Some(3)) { a * b }
 ```
 
-It would be translated to 
+would be translated to:
 
 ```ruby
-Success(4).flat_map do |x|
-  Success(2).map do |y|
-    x / y
+Some(2).flat_map do |a|
+  Some(3).map do |b|
+    a * b
   end
 end
 ```
 
-If one of operands is Failure, the result is Failure
+It works with arrays as well
 
 ```ruby
+For(a: [1, 2], b: [2, 3], c: [3, 4]) { a * b * c }
+  #=> [6, 8, 9, 12, 12, 16, 18, 24]
 
-dividend = Try { 42 }
-divisor = Try { Integer('ehuton') }
-
-divide(dividend, divisor) #=> Failure(<ArgumentError: invalid value for Integer(): "ehuton">)
 ```
 
-`For` works with arrays as well
-
-```ruby
-For(a: [1, 2], b: [2, 3], c: [3, 4]) do 
-  a * b * c
-end #=> [6, 8, 9, 12, 12, 16, 18, 24]
-```
- 
-would be translated to:
+it is translated to:
 
 ```ruby
 [1, 2].flat_map do |a|
@@ -170,6 +661,25 @@ would be translated to:
 end
 ```
 
+If you pass lambda as a variable value, it would be evaluated
+only on demand.
+
+```ruby
+For(a: -> { None() }, b: -> { fail 'kaboom' } ) { a * b }
+  #=> None()
+```
+
+It does not fail since `b` is not evaluated.
+You can refer to previously defined variables from within lambdas.
+
+```ruby
+maybe_user = find_user('Paul') #=> <#Option value=<#User ...>>
+
+For(user: maybe_user, birthday: -> { user.birthday }) do
+  "#{user.name} was born on #{birthday}"
+end #=> Some('Paul was born on 1987-06-17')
+```
+
 ### Pattern Matching
 
 `Option`, `Either`, and `Try` contains enhanced version of `#===` method. It performs matching not 

data/fear.gemspec

@@ -19,13 +19,14 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^spec\/})
   spec.require_paths = ['lib']
 
-  spec.add_runtime_dependency 'dry-equalizer', '0.2.0'
+  spec.add_runtime_dependency 'dry-equalizer', '<= 0.2.1'
 
-  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'appraisal'
+  spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'rspec', '~> 3.1'
-  spec.add_development_dependency 'spbtv_code_style'
-  spec.add_development_dependency 'rubocop-rspec', '1.13.0'
   spec.add_development_dependency 'rubocop', '0.47.1'
+  spec.add_development_dependency 'rubocop-rspec', '1.13.0'
   spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'spbtv_code_style'
 end

data/gemfiles/dry_equalizer_0.1.0.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "dry-equalizer", "0.1.0"
+
+gemspec path: "../"

data/gemfiles/dry_equalizer_0.1.0.gemfile.lock

@@ -0,0 +1,78 @@
+PATH
+  remote: ..
+  specs:
+    fear (0.10.0)
+      dry-equalizer (<= 0.2.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    appraisal (2.2.0)
+      bundler
+      rake
+      thor (>= 0.14.0)
+    ast (2.4.0)
+    diff-lcs (1.3)
+    docile (1.3.1)
+    dry-equalizer (0.1.0)
+    json (2.1.0)
+    parser (2.6.0.0)
+      ast (~> 2.4.0)
+    powerpack (0.1.2)
+    rainbow (2.2.2)
+      rake
+    rake (10.5.0)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.0)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.0)
+    rspec_junit_formatter (0.4.1)
+      rspec-core (>= 2, < 4, != 2.12.0)
+    rubocop (0.47.1)
+      parser (>= 2.3.3.1, < 3.0)
+      powerpack (~> 0.1)
+      rainbow (>= 1.99.1, < 3.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (~> 1.0, >= 1.0.1)
+    rubocop-checkstyle_formatter (0.4.0)
+      rubocop (>= 0.35.1)
+    rubocop-rspec (1.13.0)
+      rubocop (>= 0.42.0)
+    ruby-progressbar (1.10.0)
+    simplecov (0.16.1)
+      docile (~> 1.1)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.2)
+    spbtv_code_style (1.7.0)
+      rspec_junit_formatter
+      rubocop-checkstyle_formatter
+    thor (0.20.3)
+    unicode-display_width (1.4.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  appraisal
+  bundler
+  dry-equalizer (= 0.1.0)
+  fear!
+  rake (~> 10.0)
+  rspec (~> 3.1)
+  rubocop (= 0.47.1)
+  rubocop-rspec (= 1.13.0)
+  simplecov
+  spbtv_code_style
+
+BUNDLED WITH
+   1.16.2

data/gemfiles/dry_equalizer_0.2.1.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "dry-equalizer", "0.2.1"
+
+gemspec path: "../"

data/gemfiles/dry_equalizer_0.2.1.gemfile.lock

@@ -0,0 +1,78 @@
+PATH
+  remote: ..
+  specs:
+    fear (0.10.0)
+      dry-equalizer (<= 0.2.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    appraisal (2.2.0)
+      bundler
+      rake
+      thor (>= 0.14.0)
+    ast (2.4.0)
+    diff-lcs (1.3)
+    docile (1.3.1)
+    dry-equalizer (0.2.1)
+    json (2.1.0)
+    parser (2.6.0.0)
+      ast (~> 2.4.0)
+    powerpack (0.1.2)
+    rainbow (2.2.2)
+      rake
+    rake (10.5.0)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.0)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.0)
+    rspec_junit_formatter (0.4.1)
+      rspec-core (>= 2, < 4, != 2.12.0)
+    rubocop (0.47.1)
+      parser (>= 2.3.3.1, < 3.0)
+      powerpack (~> 0.1)
+      rainbow (>= 1.99.1, < 3.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (~> 1.0, >= 1.0.1)
+    rubocop-checkstyle_formatter (0.4.0)
+      rubocop (>= 0.35.1)
+    rubocop-rspec (1.13.0)
+      rubocop (>= 0.42.0)
+    ruby-progressbar (1.10.0)
+    simplecov (0.16.1)
+      docile (~> 1.1)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.2)
+    spbtv_code_style (1.7.0)
+      rspec_junit_formatter
+      rubocop-checkstyle_formatter
+    thor (0.20.3)
+    unicode-display_width (1.4.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  appraisal
+  bundler
+  dry-equalizer (= 0.2.1)
+  fear!
+  rake (~> 10.0)
+  rspec (~> 3.1)
+  rubocop (= 0.47.1)
+  rubocop-rspec (= 1.13.0)
+  simplecov
+  spbtv_code_style
+
+BUNDLED WITH
+   1.16.2

data/lib/fear/version.rb

@@ -1,3 +1,3 @@
 module Fear
-  VERSION = '0.9.0'.freeze
+  VERSION = '0.10.0'.freeze
 end

metadata

@@ -1,43 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: fear
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Tema Bolshakov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-08-21 00:00:00.000000000 Z
+date: 2019-02-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-equalizer
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "<="
       - !ruby/object:Gem::Version
-        version: 0.2.0
+        version: 0.2.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: 0.2.1
+- !ruby/object:Gem::Dependency
+  name: appraisal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.2.0
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -67,19 +81,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3.1'
 - !ruby/object:Gem::Dependency
-  name: spbtv_code_style
+  name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.47.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.47.1
 - !ruby/object:Gem::Dependency
   name: rubocop-rspec
   requirement: !ruby/object:Gem::Requirement
@@ -95,21 +109,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 1.13.0
 - !ruby/object:Gem::Dependency
-  name: rubocop
+  name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.47.1
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.47.1
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: simplecov
+  name: spbtv_code_style
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -134,12 +148,17 @@ files:
 - ".rubocop.yml"
 - ".travis.yml"
 - ".yardopts"
+- Appraisals
 - CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - fear.gemspec
+- gemfiles/dry_equalizer_0.1.0.gemfile
+- gemfiles/dry_equalizer_0.1.0.gemfile.lock
+- gemfiles/dry_equalizer_0.2.1.gemfile
+- gemfiles/dry_equalizer_0.2.1.gemfile.lock
 - lib/fear.rb
 - lib/fear/done.rb
 - lib/fear/either.rb