fear 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3ab163e8a3ccc420c6c1436e42c269e36e333b36
-  data.tar.gz: ac6d7a735f7c6ac3f20194438252b59fbdecf8c4
+  metadata.gz: 9cbecbc38d219215fb5b302a437db94936dd1d41
+  data.tar.gz: ed92b8831f89e7a31f7a91ab8a9e3992ab36dec0
 SHA512:
-  metadata.gz: 8a8f2500d2c88ba91388420a4d8e2f29ccc8d912b77c5c75484e1ff472dd1ca4ec64dbd9dc537e116845972dab0659219dc2aea9f549494d5266129771c3bbc0
-  data.tar.gz: a3c52d900667bd52580d2983cddafcb2e796524b19b418e4722fca99b520ce13232fc4ce18c433e01d653d1b5f3346ba5a27c7417114d807fe37b7ea16ac1db9
+  metadata.gz: d4390eccb7507ec87b1fe4d08e8fc86efe3274e9860a0b24ff1f5344f1512f018c8eb379fdf7a2fa3f97f0178dfad6b363dd7ac824ec570b211a21eb108bc2fc
+  data.tar.gz: 8437d3b4d64a69dbaaebb7a7a7d782df0966b10238cb8fe16c3e598ba47d196a3babf34447cfe51251900ce98bffa9c7048e7cfede886ef8a6d559a01c4bb5ab

data/lib/fear/for/evaluation_context.rb

@@ -0,0 +1,91 @@
+module Fear
+  # This class 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+.
+  #
+  #     For(a: Some(2), b: Some(3)) { a * b } #=> Some(6)
+  #
+  # If one of operands is None, the result is None
+  #
+  #     For(a: Some(2), b: None()) { a * b } #=> None()
+  #     For(a: None(), b: Some(2)) { a * b } #=> None()
+  #
+  # Lets look at first example:
+  #
+  #     For(a: Some(2), b: Some(3)) { a * b }
+  #
+  # would be translated to:
+  #
+  #     Some(2).flat_map do |a|
+  #       Some(3).map do |b|
+  #         a * b
+  #       end
+  #     end
+  #
+  # It works with arrays as well
+  #
+  #     For(a: [1, 2], b: [2, 3], c: [3, 4]) { a * b * c }
+  #       #=> [6, 8, 9, 12, 12, 16, 18, 24]
+  #
+  # would be translated to:
+  #
+  #     [1, 2].flat_map do |a|
+  #       [2, 3].flat_map do |b|
+  #         [3, 4].map do |c|
+  #           a * b * c
+  #         end
+  #       end
+  #     end
+  #
+  # If you pass lambda as a variable value, it would be evaluated
+  # only on demand.
+  #
+  #     For(a: -> { None() }, b: -> { fail 'kaboom' } ) { a * b }
+  #       #=> None()
+  #
+  # It does not fail since `b` is not evaluated.
+  # You can mix and match lambdas and variables.
+  #
+  #     For(a: -> None(), b: -> { fail 'kaboom' } ) { a * b }
+  #       #=> None()
+  #
+  class For
+    # Context of block evaluation. It respond to passed locals.
+    #
+    # @example
+    #   context = EvaluationContext.new
+    #   context.assign(:foo, 'bar')
+    #   context.foo #=> 'bar'
+    #
+    class EvaluationContext < BasicObject
+      include ::Fear::Option::Mixin
+      include ::Fear::Either::Mixin
+      include ::Fear::Try::Mixin
+
+      def initialize(outer_context)
+        @assigns = {}
+        @outer_context = outer_context
+      end
+
+      def __assign__(name, value)
+        @assigns[name] = value
+      end
+
+      def method_missing(name, *args, &block)
+        if @assigns.include?(name) && args.empty? && block.nil?
+          @assigns[name]
+        elsif @outer_context.respond_to?(name)
+          @outer_context.__send__(name, *args, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, _)
+        @assigns.key?(name) && args.empty? && block.nil?
+      end
+    end
+    private_constant(:EvaluationContext)
+  end
+end

data/lib/fear/for.rb

@@ -38,68 +38,78 @@ module Fear
   #       end
   #     end
   #
+  # If you pass lambda as a variable value, it would be evaluated
+  # only on demand.
+  #
+  #     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.
+  #
+  #     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')
+  #
   class For
-    # Context of block evaluation. It respond to passed locals.
-    #
-    # @example
-    #   context = EvaluationContext.new(foo: 'bar')
-    #   context.foo #=> 'bar'
-    #
-    class EvaluationContext < BasicObject
-      # @param locals [Hash{Symbol => any}]
-      #
-      def initialize(locals)
-        @locals = locals
-      end
-
-      def method_missing(name, *args, &block)
-        if @locals.include?(name) && args.empty? && block.nil?
-          @locals[name]
-        else
-          super
-        end
-      end
-
-      def respond_to_missing?(name, _)
-        @locals.key?(name)
-      end
-    end
-    private_constant(:EvaluationContext)
+    require_relative 'for/evaluation_context'
 
     # @param variables [Hash{Symbol => any}]
     #
-    def initialize(**variables)
+    def initialize(outer_context, **variables)
       @variables = variables
+      @evaluation_context = EvaluationContext.new(outer_context)
     end
-    attr_reader :variables
-    private :variables
 
     def call(&block)
       variable_name_and_monad, *tail = *variables
-      execute({}, *variable_name_and_monad, tail, &block)
+      execute(*variable_name_and_monad, tail, &block)
     end
 
     private
 
-    def execute(locals, variable_name, monad, monads, &block)
+    attr_reader :variables
+    attr_reader :evaluation_context
+
+    def execute(variable_name, monad, monads, &block) # rubocop:disable Metrics/MethodLength
       if monads.empty?
-        monad.map do |value|
-          EvaluationContext.new(locals.merge(variable_name => value)).instance_eval(&block)
+        resolve(monad).map do |value|
+          evaluation_context.__assign__(variable_name, value)
+          evaluation_context.instance_exec(&block)
         end
       else
-        monad.flat_map do |value|
+        resolve(monad).flat_map do |value|
+          evaluation_context.__assign__(variable_name, value)
           variable_name_and_monad, *tail = *monads
-          execute(locals.merge(variable_name => value), *variable_name_and_monad, tail, &block)
+          execute(*variable_name_and_monad, tail, &block)
         end
       end
     end
 
+    def resolve(monad_or_proc)
+      if monad_or_proc.respond_to?(:call)
+        evaluation_context.instance_exec(&monad_or_proc)
+      else
+        monad_or_proc
+      end
+    end
+
     # Include this mixin to access convenient factory method for +For+.
     # @example
     #   include Fear::For::Mixin
     #
-    #   For(a: Some(2), b: Some(3)) { a * b }   #=> Some(6)
-    #   For(a: Some(2), b: None()) { a * b }    #=> None()
+    #   For(a: Some(2), b: Some(3)) { a * b } #=> Some(6)
+    #   For(a: Some(2), b: None()) { a * b }  #=> None()
+    #
+    #   For(a: -> { Some(2) }, b: -> { Some(3) }) do
+    #     a * b
+    #   end #=> Some(6)
+    #
+    #   For(a: -> { None() }, b: -> { fail }) do
+    #     a * b
+    #   end #=> None()
     #
     #   For(a: Right(2), b: Right(3)) { a * b } #=> Right(6)
     #   For(a: Right(2), b: Left(3)) { a * b }  #=> Left(3)
@@ -112,7 +122,7 @@ module Fear
       # @return [{#map, #flat_map}]
       #
       def For(**locals, &block)
-        For.new(**locals).call(&block)
+        For.new(self, **locals).call(&block)
       end
     end
   end

data/lib/fear/version.rb

@@ -1,3 +1,3 @@
 module Fear
-  VERSION = '0.3.0'.freeze
+  VERSION = '0.4.0'.freeze
 end

data/spec/fear/for_spec.rb

@@ -17,6 +17,18 @@ RSpec.describe Fear::For do
     end
   end
 
+  context 'access method from outer scope' do
+    def two
+      2
+    end
+
+    subject do
+      For(a: Some(2)) { a * two }
+    end
+
+    it { is_expected.to eq(Some(4)) }
+  end
+
   context 'arrays' do
     subject do
       For(a: [1, 2], b: [2, 3], c: [3, 4]) do
@@ -41,7 +53,7 @@ RSpec.describe Fear::For do
       it { is_expected.to eq(Some(24)) }
     end
 
-    context 'first None' do
+    context 'first is None' do
       let(:first) { None() }
       let(:second) { Some(3) }
       let(:third) { Some(4) }
@@ -49,7 +61,7 @@ RSpec.describe Fear::For do
       it { is_expected.to eq(None()) }
     end
 
-    context 'second None' do
+    context 'second is None' do
       let(:first) { Some(2) }
       let(:second) { None() }
       let(:third) { Some(4) }
@@ -57,12 +69,54 @@ RSpec.describe Fear::For do
       it { is_expected.to eq(None()) }
     end
 
-    context 'last None' do
+    context 'last is None' do
       let(:first) { Some(2) }
       let(:second) { Some(3) }
       let(:third) { None() }
 
       it { is_expected.to eq(None()) }
     end
+
+    context 'all Same in lambdas' do
+      let(:first) { -> { Some(2) } }
+      let(:second) { -> { Some(3) } }
+      let(:third) { -> { Some(4) } }
+
+      it { is_expected.to eq(Some(24)) }
+    end
+
+    context 'first is None in lambda, second is failure in lambda' do
+      let(:first) { -> { None() } }
+      let(:second) { -> { fail 'kaboom' } }
+      let(:third) { -> {} }
+
+      it 'returns None without evaluating second and third' do
+        is_expected.to eq(None())
+      end
+    end
+
+    context 'second is None in lambda, third is failure in lambda' do
+      let(:first) { Some(2) }
+      let(:second) { -> { None() } }
+      let(:third) { -> { fail 'kaboom' } }
+
+      it 'returns None without evaluating third' do
+        is_expected.to eq(None())
+      end
+    end
+  end
+
+  context 'refer to previous variable from lambda' do
+    subject do
+      For(a: first, b: second, c: third) do
+        b * c
+      end
+    end
+
+    let(:first) { Some(Some(2)) }
+    let(:second) { -> { a } }
+    let(:third) { -> { Some(3) } }
+
+    it { is_expected.to eq(Some(6)) }
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fear
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Tema Bolshakov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-12-13 00:00:00.000000000 Z
+date: 2016-12-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-equalizer
@@ -129,6 +129,7 @@ files:
 - lib/fear/either.rb
 - lib/fear/failure.rb
 - lib/fear/for.rb
+- lib/fear/for/evaluation_context.rb
 - lib/fear/left.rb
 - lib/fear/none.rb
 - lib/fear/option.rb