lab42_curry 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9a551847324f71962eb05cec99769fc9a945b68d31b65a3ce94bd338e4f88b72
-  data.tar.gz: 6bb0044d5af9008de8ff78d00f4b5a7e1d79c9c341f2e78f1f0012a909670160
+  metadata.gz: 364ab07ebc3ae04d88f52078f9685de77f1ac5f7acc22c0fdc14352c80e14c93
+  data.tar.gz: fe68d0fa92be55bae32d4eee096ef0989a94381701e9a41a31b31c516977145b
 SHA512:
-  metadata.gz: f0028228fd18f8cc4ec1b4a865ad64e3b57ea99a2ded385cfbea0527fb61744c03d2bf35163ea4a5698bdc85c67e9e469b7ea213c7a25781f9b9e365387a02a1
-  data.tar.gz: f9ed56c17f25fe649f2507cae0cc2a55f4a6170b7901b3096235742f155aa34e80f592ab219f1d2a9a1665239e62e71e7a0d5db80e27d1f880b563d9e9a92f0e
+  metadata.gz: e98215ae8b0a6ea139afe52e4f98648e351f48c950f336231002b134837b15254687649357205c6942e9659a9c3966a0464b875cc6dce949b4410857fe7979ba
+  data.tar.gz: 27948a35f86d517a2eb681a2d378b0d13fee608990d2f958eff1fc206551b3cfdc69d01ab09b4c2630eaf6761d9298a13bfd020eb703a1135b49be05d422c282

data/README.md

@@ -1,5 +1,6 @@
-[![Gem Version](https://badge.fury.io/rb/lab42_curry.svg)](http://badge.fury.io/rb/lab42_curry)
-
+[![Gem Version](http://img.shields.io/gem/v/lab42_curry.svg)](https://rubygems.org/gems/lab42_curry)
+[![CI](https://github.com/robertdober/lab42_curry/workflows/CI/badge.svg)](https://github.com/robertdober/lab42_curry/actions)
+[![Coverage Status](https://coveralls.io/repos/github/RobertDober/lab42_curry/badge.svg?branch=master)](https://coveralls.io/github/RobertDober/lab42_curry?branch=master)
 
 # Lab42::Curry
 
@@ -20,8 +21,9 @@ Given such a simple funcion
 ```ruby
     def adder(a, b, c); a + 10*b + 100*c end
     let(:add_to_1) {curry(:adder, 1)}
+    # Equivalent to Elixir's &adder(1, &1, &2)
 ```
-**N.B.** that `Lab42::Curry` has been included into Examples **and** ExampleGroups in `spec/spec_helper.rb` 
+**N.B.** that `Lab42::Curry` has been included into Examples **and** ExampleGroups in `spec/spec_helper.rb`
 
 Then very unsurprisingly:
 ```ruby
@@ -31,7 +33,7 @@ Then very unsurprisingly:
 We call the arguments passed into `curry` the _compiletime arguments_, and the arguments passed into the
 invocation of the _curried function_, which has been returned by the invocation of `curry`, the _runtime arguments_.
 
-In our case the _compiletime arguments_ were `[1]`  and the _runtime arguments_ were `[2, 3]` 
+In our case the _compiletime arguments_ were `[1]`  and the _runtime arguments_ were `[2, 3]`
 
 ### Reordering
 
@@ -39,7 +41,8 @@ There are several methods of reordering arguments, the simplest is probably usin
 
 When a placeholder is provided (`Lab42::Curry.runtime_arg` aliased as `rt_arg` )
 ```ruby
-    let(:add_to_30) { curry(:adder, rt_arg, 3)  } 
+    let(:add_to_30) { curry(:adder, rt_arg, 3) }
+    # Equivalent to Elixir's &adder(&1, 3, &2)
 ```
 Then we see that
 ```ruby
@@ -47,30 +50,33 @@ Then we see that
 ```
 #### Total control over argument order...
 
-... can be achieved by passing the index of the positional argument to be used into `Lab42::Curry.runtime_arg` 
+... can be achieved by passing the index of the positional argument to be used into `Lab42::Curry.runtime_arg`
 
 Given the total reorder form
 ```ruby
-    let(:mul_decrement) { curry(:adder, runtime_arg(2), runtime_arg(0), 1) } # now first argument is c (index 2) and second a (index 0) and b = 1
+    let(:twohundred_three) { curry(:adder, runtime_arg(2), runtime_arg(0), 1) }
+    # now first argument is c (index 2) and second a (index 0) and b = 1
+    # Like Elixir's &adder(&2, 1, &1)
 ```
 Then we have
 ```ruby
-    expect( mul_decrement.(2, 3) ).to eq(213)
+    expect( twohundred_three.(2, 3) ).to eq(213)
 ```
 
-#### Picking a positon for a compiletime argument
+#### Picking a position for a compiletime argument
 
-It might be cumbersome to write things like: `curry(..., rt_arg, rt_arg, ..., rt_arg, 42)` 
+It might be cumbersome to write things like: `curry(..., rt_arg, rt_arg, ..., rt_arg, 42)`
 
-Therefore we can express the same much more concisely with `Lab42::Curry.compiletime_args`, and its alias `ct_args` 
+Therefore we can express the same much more concisely with `Lab42::Curry.compiletime_args`, and its alias `ct_args`
 
 Given
 ```ruby
-    let(:doubler) { curry(:adder, ct_args(2 => 2)) } # same as curry(:adder, rt_arg, rt_arg, 2)
+    let(:twohundred) { curry(:adder, ct_args(2 => 2)) }
+    # same as curry(:adder, rt_arg, rt_arg, 2)
 ```
 Then we get
 ```ruby
-    expect( doubler.(4, 3) ).to eq(234)
+    expect( twohundred.(4, 3) ).to eq(234)
 ```
 
 **N.B.** that we could have defined `add_to_30` as `curry(:adder, rt_arg, 3, rt_arg)` of course
@@ -78,10 +84,10 @@ Then we get
 
 #### Error Handling
 
-When you indicate values for the same position multiple times 
+When you indicate values for the same position multiple times
 Then the `ArgumentCompiler` saves you:
 ```ruby
-    expect{ curry(:adder, 1, ct_args(0 => 1)).() }.to raise_error(Lab42::Curry::DuplicatePositionSpecification)
+    expect{ curry(:adder, 1, ct_args(0 => 1)) }.to raise_error(Lab42::Curry::DuplicatePositionSpecification)
 ```
 
 ### Context With proc like objects
@@ -95,6 +101,41 @@ Then we will get the negative value
 ```ruby
     expect( inverse.(2, 1) ).to eq(-1)
 ```
+
+### Context Keyword Arguments
+
+Given a function which takes keyword arguments like the following
+```ruby
+    def rectangle(length, width, border: 0, color: )
+      [length, width, border, color]
+    end
+    let(:red_rectangle) { curry(:rectangle, color: :red) }
+    let(:wide_bordered) { curry(:rectangle, rt_arg, 999, border: 1) }
+```
+
+Then the red rectangle gives us
+```ruby
+    expect( red_rectangle.(1, 2) ).to eq([1, 2, 0, :red])
+    expect( red_rectangle.(1, 2, border: 1) ).to eq([1, 2, 1, :red])
+```
+
+Can we override curried values, normally not
+Example: cannot override
+```ruby
+    expect{ red_rectangle.(1, 2, color: :blue) }
+      .to raise_error(
+        Lab42::Curry::DuplicateKeywordArgument,
+        "keyword argument :color is already defined with value :red cannot override with :blue")
+```
+
+But we can create a more lenient curry with `curry!`
+```ruby
+  expect( curry!(:rectangle, 1, 2, color: :red ).(color: :blue) )
+    .to eq([1, 2, 0, :blue])
+```
+
+
+
 # LICENSE
 
 Copyright 2020,1 Robert Dober robert.dober@gmail.com

data/lib/lab42/curry.rb

@@ -4,8 +4,14 @@ require_relative "curry/compiletime_args"
 
 module Lab42
   module Curry
-    def curry(method_or_name, *curry_time_args, &blk)
-      curry_data = Data.new(self, method_or_name, *curry_time_args, &blk)
+    def curry(method_or_name, *curry_time_args, **curry_time_kwds, &blk)
+      curry_data = Data.new(self, method_or_name, *curry_time_args, **curry_time_kwds, &blk)
+      curry_data.curried
+    end
+
+    def curry!(method_or_name, *curry_time_args, **curry_time_kwds, &blk)
+      curry_data = Data.new(self, method_or_name, *curry_time_args, **curry_time_kwds, &blk)
+      curry_data.allow_kwd_override = true
       curry_data.curried
     end
 

data/lib/lab42/curry/arg_compiler.rb

@@ -5,74 +5,74 @@ require_relative 'errors'
 module Lab42
   module Curry
     class ArgCompiler
-      attr_reader :ct_args, :rt_args
-      
-      def compile_args
-        _init
-        ct_args.each(&method(:_set_ct_arg))
-        rt_args.each(&method(:_set_rt_arg))
-        @final.map.sort_by(&:first).map(&:last)
+
+      def compile_args rt_args
+        @__compiled_args__ ||= _compile_args(rt_args)
       end
-      
+
       private
-      def initialize(ct_args:, rt_args:)
-        @ct_args = ct_args
+      def initialize(ct_args)
+        _init
+        _determine_predefined_positions! ct_args
+      end
+
+      def _compile_args rt_args
         @rt_args = rt_args
+        @rt_arg_positions.each(&method(:_set_rt_arg))
+        @rt_args.each(&method(:_set_final!))
+        @final.map.sort_by(&:first).map(&:last)
+      end
+
+      def _determine_predefined_positions! ct_args
+        ct_args.each(&method(:_set_ct_arg))
       end
 
       def _init
+        @rt_arg_positions = []
+        # invariant @pos is lowest free index in @final
+        # update both together with _set_final!( value, idx = @pos )
         @pos = 0
         @final = {}
       end
 
-      def _set_compiletime_arg ct_arg
-        _store_into_next(ct_arg)
-      end
-
       def _set_ct_arg ct_arg
         case ct_arg
         when RuntimeArg
-          _set_runtime_arg! ct_arg # changes @rt_args, I know, I know, TODO: make this w/o side effect
+          _set_target_position! ct_arg.position
         when CompiletimeArgs
-          _set_positions ct_arg
+          _set_positions! ct_arg
         else
-          _set_compiletime_arg ct_arg
+          _set_final! ct_arg
         end
       end
 
-      def _set_position((pos, val))
-        _store_at! val, pos
+      def _set_final! value, pos=nil
+        pos ||= @pos
+        raise DuplicatePositionSpecification, "There is already a curried value for #{pos}" if @final.has_key?(pos)
+        @final[pos] = value
+        while @final.has_key?(@pos)
+          @pos += 1
+        end
       end
 
-      def _set_positions ct_arg
-        ct_arg.each(&method(:_set_position))
+      def _set_position!((position, value))
+        _set_final! value, position
       end
 
-      def _set_rt_arg rt_arg
-        _store_into_next(rt_arg)
+      def _set_positions! ct_arg
+        ct_arg.each(&method(:_set_position!))
       end
 
-      def _set_runtime_arg! ct_arg 
-        if ct_arg.position 
-          _store_at! rt_args.shift, ct_arg.position # This is the culprit
-        else
-          _store_into_next(rt_args.shift) # Oops I did it again
-        end
+      def _set_rt_arg rt_arg_position
+        raise MissingRuntimeArg, "for position #{rt_arg_position}" if @rt_args.empty?
+        @final[rt_arg_position] = @rt_args.shift
       end
 
-      def _store_at!(value, pos=nil)
-        pos ||= @pos
-        raise DuplicatePositionSpecification, "There is already a curried value #{@final[pos].inspect} at position #{pos}, attempting to override with #{value.inspect}" if
-          @final.has_key?(pos)
-        @final[pos] = value
+      def _set_target_position! position
+        @rt_arg_positions << (position || @pos)
+        _set_final! RuntimeArg, position
       end
 
-      def _store_into_next(value)
-        while @final.has_key?(@pos)
-          @pos += 1
-        end
-        _store_at! value
-      end
     end
   end
 end

data/lib/lab42/curry/data.rb

@@ -3,12 +3,15 @@ require_relative 'arg_compiler'
 module Lab42
   module Curry
     class Data
-      attr_reader :context, :ct_args, :curried
+      attr_accessor :allow_kwd_override
+      attr_reader :context, :ct_args, :ct_kwds, :curried
 
       private
-      def initialize(ctxt, method_or_name, *curry_time_args, &blk)
+      def initialize(ctxt, method_or_name, *curry_time_args, **curry_time_kwds, &blk)
+        @allow_kwd_override
         @context = ctxt
         @ct_args = curry_time_args
+        @ct_kwds = curry_time_kwds
 
         @mthd = 
         case method_or_name
@@ -17,16 +20,24 @@ module Lab42
         else
           method_or_name
         end
-        _curry(&blk)
-      end
 
-      def _compile_final_args(rt_args)
-        arg_compiler = ArgCompiler.new(ct_args: ct_args, rt_args: rt_args)
-        arg_compiler.compile_args
+        @arg_compiler = ArgCompiler.new(ct_args)
+        _curry(&blk)
       end
 
       def _curry(&blk)
-        @curried = ->(*rt_args) { @mthd.(*_compile_final_args(rt_args)) }
+        @curried = ->(*rt_args, **rt_kwds) do
+          @mthd.(
+            *@arg_compiler.compile_args(rt_args),
+            **@ct_kwds.merge(rt_kwds) { |kwd, old_val, new_val|
+              if allow_kwd_override
+                new_val
+              else
+                raise DuplicateKeywordArgument, "keyword argument #{kwd.inspect} is already defined with value #{old_val.inspect} cannot override with #{new_val.inspect}"
+              end
+            }
+          )
+        end
       end
     end
   end

data/lib/lab42/curry/errors.rb

@@ -1,5 +1,7 @@
 module Lab42
   module Curry
     DuplicatePositionSpecification = Class.new RuntimeError
+    DuplicateKeywordArgument       = Class.new RuntimeError
+    MissingRuntimeArg              = Class.new RuntimeError
   end
 end

data/lib/lab42/curry/version.rb

@@ -1,5 +1,5 @@
 module Lab42
   module Curry
-    VERSION = "0.1.0"
+    VERSION = "0.1.1"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lab42_curry
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Robert Dober
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-12-26 00:00:00.000000000 Z
+date: 2020-12-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -80,7 +80,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.0.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="