lab42_curry 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 364ab07ebc3ae04d88f52078f9685de77f1ac5f7acc22c0fdc14352c80e14c93
-  data.tar.gz: fe68d0fa92be55bae32d4eee096ef0989a94381701e9a41a31b31c516977145b
+  metadata.gz: 81a83bce0a791069efb5bf01049fb137367565cc1289d2824a43aae3b4336a72
+  data.tar.gz: 66479962f8bd6be1d89c29794fa7d09d1a84971520b8cf277804f6c722d60f9d
 SHA512:
-  metadata.gz: e98215ae8b0a6ea139afe52e4f98648e351f48c950f336231002b134837b15254687649357205c6942e9659a9c3966a0464b875cc6dce949b4410857fe7979ba
-  data.tar.gz: 27948a35f86d517a2eb681a2d378b0d13fee608990d2f958eff1fc206551b3cfdc69d01ab09b4c2630eaf6761d9298a13bfd020eb703a1135b49be05d422c282
+  metadata.gz: aadb1fda7c8a06586ce81fbc43e6d3f21fa20ec7c56297265f6a8330cc088740f3c197f7eac25e76a5a7bfc94d8267b7bc31a267ceb1cdaf9657196ff12a6554
+  data.tar.gz: '08c4b31e4d94aa2cd8a943e52a753b330cfbfacc402ae5ba22cf5d1cb4caea222d4a11983e33f5da4a1f52898797a8d966d6cf3f50f15e3f167f11f2bdc96c89'

data/README.md

@@ -54,8 +54,8 @@ Then we see that
 
 Given the total reorder form
 ```ruby
-    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
+    let(:twohundred_three) { curry(:adder, runtime_arg(1), 1, runtime_arg(0)) }
+    # now first argument is c (index 1) and second a (index 0) and b = 1
     # Like Elixir's &adder(&2, 1, &1)
 ```
 Then we have
@@ -134,8 +134,106 @@ But we can create a more lenient curry with `curry!`
     .to eq([1, 2, 0, :blue])
 ```
 
+### Context Currying Blocks
 
+Often times it is the block which might be the fixed point in a series of computations, for
+that reason we will curry a block
 
+Given a function that takes a block
+```ruby
+    let(:sub_with) { ->(a, b, &blk) { blk.(a - b) } }
+    let(:double_diff) { curry( sub_with ) { _1 * 2 } }
+```
+Then it does just that
+```ruby
+     expect( double_diff.(22, 1)  ).to eq(42)
+```
+And of course we can also curry a positional argument
+```ruby
+    triple_dec = curry( sub_with, rt_arg, 1 ) { _1 * 3 } 
+    expect( triple_dec.(15) ).to eq(42)
+```
+
+#### Context Currying on Unbound Methods
+
+Can be a very useful exercise, we will see that `curry` creates a curred function that will bind when called
+
+Given the classical map example:
+```ruby
+   let(:incrementer) { curry(Enumerable.instance_method(:map)) { _1 + 1} }
+```
+
+Then we can use it by  binding it to an `Enumerable` object
+```ruby
+    expect( incrementer.([1, 2]) ).to eq([2, 3])
+```
+
+But we must not provide a block **again**
+```ruby
+    expect{ incrementer.([]) {_1 + 2} }
+      .to raise_error(
+        Lab42::Curry::DuplicateBlock,
+        "block has already been curried")
+```
+
+This again can be authorized by using the more lenient `curry!` version
+And therefor
+```ruby
+    maybe_incrementer = curry!(Enumerable.instance_method(:map)) {_1 + 1}
+    expect( maybe_incrementer.([1, 2], &:itself) ).to eq([1, 2])
+```
+
+But of course we can also bind to unbound methods w/o a block
+
+Given
+```ruby
+    let(:length) { curry(String.instance_method(:size)) }
+```
+Then we can call it in a functional way
+```ruby
+    expect( length.("") ).to be_zero
+```
+
+### Context Computed Arguments
+
+Let us say we want to define a specialisation of a function
+Given
+```ruby
+    def add a, b, c
+      a + b + c
+    end
+    let(:adddiff) { curry(:add, comp{ _2 - _3}) }
+```
+Then the first parameter will be the diff of the second and third argument
+```ruby
+    expect( adddiff.(21, 1) ).to eq(42)
+```
+
+When we specify a position for `comp` the computed argument gets this place
+```ruby
+    def args *a
+      a
+    end
+    let(:sum_middle) { curry(:args, comp(1){ _1 + _3 } ) }
+```
+Then we get
+```ruby
+    expect( sum_middle.(1, 2) ).to eq([1, 3, 2])
+```
+
+#### Context Computed Keywords
+
+Given
+```ruby
+    def kwds *, **k
+      k
+    end
+    let(:sum) { curry(:kwds, a: comp{ _1 + _2}) }
+```
+Then we can expect that sum corresponds
+```ruby
+    expect( sum.(1, 2) ).to eq({a: 3})
+```
 # LICENSE
 
 Copyright 2020,1 Robert Dober robert.dober@gmail.com

data/lib/lab42/curry.rb

@@ -1,18 +1,16 @@
-require_relative "curry/data"
-require_relative "curry/runtime_arg"
 require_relative "curry/compiletime_args"
+require_relative "curry/computed_arg"
+require_relative "curry/currier"
+require_relative "curry/runtime_arg"
 
 module Lab42
   module Curry
     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
+      Currier.new(method_or_name, curry_time_args, curry_time_kwds, context: self, &blk)
     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
+      Currier.new(method_or_name, curry_time_args, curry_time_kwds, context: self, allow_override: true, &blk)
     end
 
     def compiletime_args(positions)
@@ -20,8 +18,13 @@ module Lab42
     end
     alias_method :ct_args, :compiletime_args
 
-    def runtime_arg(*args)
-      RuntimeArg.new(*args)
+    def compute_arg(position = nil, &blk)
+      ComputedArg.new(position, blk)
+    end
+    alias_method :comp, :compute_arg
+
+    def runtime_arg position=nil
+      RuntimeArg.new position
     end
     alias_method :rt_arg, :runtime_arg
   end

data/lib/lab42/curry/arg_compiler.rb

@@ -1,76 +1,76 @@
-require_relative 'runtime_arg'
+require_relative 'arg_compiler/positionals'
+require_relative 'arg_compiler/phase2'
 require_relative 'compiletime_args'
+require_relative 'computed_arg'
+require_relative 'runtime_arg'
+
 require_relative 'errors'
 
 module Lab42
   module Curry
     class ArgCompiler
 
-      def compile_args rt_args
-        @__compiled_args__ ||= _compile_args(rt_args)
-      end
+      attr_reader :ct_blk
 
-      private
-      def initialize(ct_args)
-        _init
-        _determine_predefined_positions! ct_args
+      def allows_override?; @allow_override end
+
+      def compile(rt_args, rt_kwds, rt_blk)
+        Phase2.new(self, rt_args, rt_kwds, rt_blk).compile
       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)
+      #
+      #  0 based
+      #
+      def positionals
+        @__positionals__ ||= Positionals.new 
       end
 
-      def _determine_predefined_positions! ct_args
-        ct_args.each(&method(:_set_ct_arg))
+      def final_kwds
+        @__final_kwds__ ||= {}
       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 = {}
+      private
+      def initialize(ct_args, ct_kwds, allow_override:, &blk)
+        @allow_override = allow_override
+        @ct_args = ct_args
+        @ct_blk  = blk
+        @ct_kwds = ct_kwds
+
+        _precompile!
       end
 
-      def _set_ct_arg ct_arg
+      def _ct_arg ct_arg
         case ct_arg
         when RuntimeArg
-          _set_target_position! ct_arg.position
+          positionals.set_runtime_arg ct_arg
         when CompiletimeArgs
           _set_positions! ct_arg
+        when ComputedArg
+          positionals.set_computation ct_arg
         else
           _set_final! ct_arg
         end
       end
 
-      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
+      def _ct_kwd((key, val))
+        final_kwds[key]  = val
       end
 
-      def _set_position!((position, value))
-        _set_final! value, position
+      def _precompile!
+        @ct_args.each(&method(:_ct_arg))
+        @ct_kwds.each(&method(:_ct_kwd))
       end
 
-      def _set_positions! ct_arg
-        ct_arg.each(&method(:_set_position!))
+      def _set_final! value, pos=nil
+        positionals.set_value! value, pos
       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
+      def _set_position!((position, value))
+        positionals.set_value! value, position
       end
 
-      def _set_target_position! position
-        @rt_arg_positions << (position || @pos)
-        _set_final! RuntimeArg, position
+      def _set_positions! ct_arg
+        ct_arg.each(&method(:_set_position!))
       end
 
     end

data/lib/lab42/curry/arg_compiler/phase2.rb

@@ -0,0 +1,75 @@
+require_relative '../errors'
+require_relative 'positionals'
+module Lab42
+  module Curry
+    class ArgCompiler
+      class Phase2
+
+        attr_reader :compiler, :rt_args, :rt_blk, :rt_kwds
+
+        # TODO: Easy, peasy sequential refactor
+        def compile
+          if rt_blk && compiler.ct_blk && !compiler.allows_override?
+            raise Lab42::Curry::DuplicateBlock, "block has already been curried"
+          end
+          @blk = rt_blk || compiler.ct_blk
+          @kwds = compiler.final_kwds.merge(rt_kwds){ |k, old, new|
+            raise Lab42::Curry::DuplicateKeywordArgument,
+              "keyword argument :#{k} is already defined with value #{old.inspect} cannot override with #{new.inspect}" unless compiler.allows_override?
+            new
+          }
+          @args = compiler.positionals.export_args
+          @first_free = 0
+          rt_args.each_with_index do |rt_arg, idx|
+            computed   = compiler.positionals.computed(idx)
+            if computed
+            end
+            translated = compiler.positionals.translation(idx)
+            if translated
+              @args[translated] = rt_arg
+            else
+              # @args[idx + some_dynamic_offset] = rt_arg ???
+              _occupy_first_free rt_arg
+            end
+          end
+          compiler.positionals.computations do |idx, computed_arg|
+            @args[idx] = _compute(computed_arg)
+          end
+          @kwds.each do |kwd, val|
+            case val
+            when ComputedArg
+              @kwds[kwd] = _compute(val)
+            end
+          end
+          # TODO: Raise ArgumentError if holes are left in @args, but for that reason we must make compiler.final_args compact
+          # and indicate wholes with RuntimeArg, not sure this is done same for holes in @kwds
+          [@args, @kwds, @blk]
+        end
+
+        private
+
+        def initialize(compiler, rt_args, rt_kwds, rt_blk)
+          @compiler = compiler
+          @rt_args  = rt_args
+          @rt_blk   = rt_blk
+          @rt_kwds  = rt_kwds
+        end
+
+        def _compute computed_arg
+          computed_arg.(*@args, **@kwds)
+        end
+
+        def _occupy_first_free with_value
+          return @args << with_value unless @first_free
+          @first_free = 
+            (@first_free..@args.size).find {|idx| @args[idx] == RuntimeArg}
+          if @first_free
+            @args[@first_free] = with_value
+          else
+            @args << with_value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lab42/curry/arg_compiler/positionals.rb

@@ -0,0 +1,96 @@
+require_relative '../errors'
+require_relative '../runtime_arg'
+# Represents the positionitional arguments as
+# a hash idx -> value with operations to
+# fill the "holes" with args provisioned
+# at runtime.
+# The filling of the holes is done at runtime
+# by translating runtime argument indices with
+# the @translations hash.
+module Lab42
+  module Curry
+    class ArgCompiler
+      class Positionals
+
+        attr_reader :ct_pos, :rt_pos
+
+        def computations
+          @computations.each { |idx, comp| yield idx, comp }
+        end
+
+        def computed idx
+          @computations[idx]
+        end
+
+        def export_args
+          (0...(@args.keys.max&.succ||0))
+            .inject [] do |result, idx|
+              if @args.has_key?(idx)
+                result << @args[idx]
+              else
+                result << RuntimeArg
+              end
+              result
+            end
+        end
+
+        def set_computation comp_arg
+          @args[comp_arg.position || ct_pos]         = comp_arg.class
+          @computations[comp_arg.position || rt_pos] = comp_arg
+        end
+
+        # An rt_arg placeholder
+        def set_runtime_arg rt_arg 
+          @args[ct_pos] = rt_arg.class
+          @translations[rt_arg.position || rt_pos] = ct_pos
+          _update_positions
+        end
+
+        # A curried value or computation, occurs from `ct_args` or literal values in which case `ct_pos` is `nil` 
+        def set_value! value, ct_pos=nil
+          ct_pos ||= @ct_pos
+          raise Lab42::Curry::DuplicatePositionSpecification,
+            "There is already a curried value #{@args[ct_pos].inspect} at index #{ct_pos}" if _occupied?(ct_pos)
+          @args[ct_pos] = value
+
+          (@ct_pos..ct_pos.pred).each(&method(:_occupy))
+          # TODO: Need to check if we have to fill the holes with RuntimeArg
+          # and allow @ct_pos to point to present RuntimeArg values?
+
+          _update_positions
+        end
+
+        def translation idx
+          @translations[idx]
+        end
+
+        private
+        def initialize
+          @args         = {}
+          @computations = {}
+          @ct_pos       = 0
+          @rt_pos       = 0
+          @translations = {}
+        end
+
+        def _occupied? key
+          @args.has_key?(key) && @args[key] != RuntimeArg
+        end
+
+        def _occupy idx
+          @args[idx] = RuntimeArg unless @args.has_key?(idx)
+        end
+
+        def _update_positions
+          while @args.has_key?(@ct_pos)
+            @ct_pos += 1
+          end
+          while @translations.has_key?(@rt_pos)
+            @rt_pos += 1
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/lab42/curry/computed_arg.rb

@@ -0,0 +1,18 @@
+module Lab42
+  module Curry
+    class ComputedArg
+
+      attr_reader :position
+
+      def call(*args, **kwds)
+        @blk.call(*args, **kwds)
+      end
+      
+      private
+      def initialize(position, blk)
+        @blk = blk
+        @position = position
+      end
+    end
+  end
+end

data/lib/lab42/curry/currier.rb

@@ -0,0 +1,61 @@
+require_relative 'arg_compiler'
+
+module Lab42
+  module Curry
+    class Currier
+      attr_reader :arg_compiler, :context, :ct_args, :ct_blk, :ct_kwds, :mthd
+
+      def call(*args, **kwds, &blk)
+        case mthd
+        when UnboundMethod
+          _bind_and_call(args, kwds, blk)
+        else
+          _just_call(args, kwds, blk)
+        end
+      end
+
+      def _bind_and_call(args, kwds, blk)
+        receiver = args.shift
+        mthd = @mthd.bind(receiver)
+        rt_args, rt_kwds, rt_blk = arg_compiler.compile(args, kwds, blk)
+        if rt_blk
+          mthd.(*rt_args, **rt_kwds, &rt_blk)
+        else
+          mthd.(*rt_args, **rt_kwds)
+        end
+      end
+
+      def _just_call(args, kwds, blk)
+        rt_args, rt_kwds, rt_blk = arg_compiler.compile(args, kwds, blk)
+        if rt_blk
+          mthd.(*rt_args, **rt_kwds, &rt_blk)
+        else
+          mthd.(*rt_args, **rt_kwds)
+        end
+      end
+
+      private
+      def initialize(method_or_name, ct_args, ct_kwds, context:, allow_override: false, &ct_blk)
+        @allow_override = allow_override
+        @context = context
+        @ct_args = ct_args
+        @ct_blk = ct_blk
+        @ct_kwds = ct_kwds
+
+        @arg_compiler = ArgCompiler.new(ct_args, ct_kwds, allow_override: allow_override, &ct_blk)
+
+        _init_mthd method_or_name
+      end
+
+      def _init_mthd method_or_name
+        @mthd = 
+          case method_or_name
+          when Symbol
+            context.method(method_or_name)
+          else
+            method_or_name
+          end
+      end
+    end
+  end
+end

data/lib/lab42/curry/errors.rb

@@ -1,7 +1,8 @@
 module Lab42
   module Curry
-    DuplicatePositionSpecification = Class.new RuntimeError
+    DuplicateBlock                 = Class.new RuntimeError
     DuplicateKeywordArgument       = Class.new RuntimeError
+    DuplicatePositionSpecification = 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.1"
+    VERSION = "0.2.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lab42_curry
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Robert Dober
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-12-27 00:00:00.000000000 Z
+date: 2021-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -63,8 +63,11 @@ files:
 - README.md
 - lib/lab42/curry.rb
 - lib/lab42/curry/arg_compiler.rb
+- lib/lab42/curry/arg_compiler/phase2.rb
+- lib/lab42/curry/arg_compiler/positionals.rb
 - lib/lab42/curry/compiletime_args.rb
-- lib/lab42/curry/data.rb
+- lib/lab42/curry/computed_arg.rb
+- lib/lab42/curry/currier.rb
 - lib/lab42/curry/errors.rb
 - lib/lab42/curry/runtime_arg.rb
 - lib/lab42/curry/version.rb

data/lib/lab42/curry/data.rb

@@ -1,44 +0,0 @@
-require_relative 'arg_compiler'
-
-module Lab42
-  module Curry
-    class Data
-      attr_accessor :allow_kwd_override
-      attr_reader :context, :ct_args, :ct_kwds, :curried
-
-      private
-      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
-        when Symbol
-          context.method(method_or_name)
-        else
-          method_or_name
-        end
-
-        @arg_compiler = ArgCompiler.new(ct_args)
-        _curry(&blk)
-      end
-
-      def _curry(&blk)
-        @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
-end