lab42_core 0.3.3 → 0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5cd12ff6e489be963c104371e4e2af457aba6074
-  data.tar.gz: d0c1dd7b78302cc8326c092d05331d0fdb9d6498
+  metadata.gz: 2a45782982c7efdf61bb0193996363a204b8ee05
+  data.tar.gz: cd38beb0ab0b09bf8db7fc185089ff89880b02db
 SHA512:
-  metadata.gz: cc889bb8bb613314b00811dce275fb55516f40a862339ec96353a20d0ff75d26329b44c1996c70fc8fae895ee644687c79971d11e790fa81c2e4d24d689a4ae8
-  data.tar.gz: 3188d4c7607973f5b4c2d5d4fba1d00c86548249ba1134af74555b922e69fc6cfa802ec932ba5323a9970bfad0e73adc7eb7d5c26624ea54e5518604ae4bfab3
+  metadata.gz: 058204661c72349652027840bc10509e9724cf6abe528ad5d4d0f90a1d022204c9f8542ff07d25ddeb6bf1186abbc026573a9edab2a51ae12d7634f186a2f658
+  data.tar.gz: a7464e37bf5228c2bb75981bf18c047e3d84e90b5ddfa0701f59788aa4ba02069c7f65013a728ef69aeefe646cd8ae2c6e3e77f1396075b640df945b931c4928

data/README.md

@@ -23,7 +23,7 @@ API will remain the same, require will change to `require 'lab42_more/fn'`
 ##### fn like function
 
 ```ruby
-    Dir.files [APP_ROOT, 'spec', 'support', '**', '*.rb'], Kernel.fn.require
+    Dir.files [APP_ROOT, 'spec', 'support', '**', '*.rb'], &Kernel.fn.require
 
     Dir.files( %w{.. assets ** *.txt} ).sort_by &File.fn.mtime
 ```
@@ -40,20 +40,30 @@ upon call, once it has been transformed by `#to_proc`
 
 For details see the corresponding [QED demo](https://github.com/RobertDober/lab42_core/blob/master/demo/fn.md).
 
-## Behave
+#### Behave or B for Message Sending
 
-We exposed methods as _functions_ in the previous chapter. However we are subject to sematic confusion
-with terms like _methods_, _procedures_, _lambdas_ and _functions_. 
+This is a more general approach than `fn` or `fm` as we do not even know the class of the future receiver of the
+message.
 
-Is it not time to abstract a little bit?
+The subtle difference can be made clear with an example
 
-Enter **Behave**, which is everything that behaves, right?
+```ruby
+    adder = B( :+ )
+    # can be used for Fixnums
+    adder.(1,41) # --> 42
+    # or Arrays
+    adder.(%w/a b/, %w&c d&) #--> %w%a b c d%
+```
 
-Let us see how that behaves.
+Which can of course not be accomplished by `Fixnum.fm.+` 
 
 
 For details see the corresponding [QED demo](https://github.com/RobertDober/lab42_core/blob/master/demo/behave.md).
 
+#### All Behavior is Composable
+
+The above methods all return instances of `Behavior` and `Behavor` has a much richer API than Ruby's core _callables_ like `Proc` or `Method` 
+
 #### Memoization and Lazy Attributes
 
 ##### Memoization
@@ -254,6 +264,31 @@ are provided (after all there is a !).
 
 For details see the corresponding [QED demo](https://github.com/RobertDober/lab42_core/blob/master/demo/hash.md).
 
+#### replace_rec
+
+Recursive Replacement
+
+##### Original Object untouched of course
+
+```ruby
+
+    a = {a: 42, x: {a: 43}}
+    b = a.replace_rec( :a, &:succ )
+    a.assert == {a: 42, x: {a: 43}}
+    b.assert == {a: 43, x: {a: 44}}
+    
+```
+
+For bulk replacements and how to specify limits, please refer to [QED demo](https://github.com/RobertDober/lab42_core/blob/master/demo/hash.md).
+
+#### without
+
+```ruby
+    h = {a: 1, b: 2, c: 3}
+  
+    h.without( :b, :c, :d ).assert == {a: 1}
+    h.assert == {a: 1, b: 2, c: 3}
+```
 
 ### Object
 

data/lib/lab42/core/b.rb

@@ -1,5 +1,8 @@
+require 'lab42/core/fn'
 require_relative 'behavior'
 
-def B *a, &b
-  Lab42::Meta::Behavior *a, &b
+def B msg, *a, &b
+  Lab42::Behavior::SendBehavior.new msg, *a, &b
 end
+
+Identity = Lab42::Behavior::ProcBehavior.new{ |x| x }

data/lib/lab42/core/behavior/bound_behavior.rb

@@ -0,0 +1,41 @@
+require 'forwarder'
+require_relative 'composition'
+module Lab42
+  module Behavior
+    # Thank youn my dear Proxy, for sending me all the information
+    # I, the clever guy, who is having all the fun, will make best
+    # use of it by being an extremly, yes I said *extremly* clever
+    # callable object representing the methods or instance methods
+    # represented by the calls to `Object#fn` or `Module#fm`. 
+    # Did I tell you yet? It is sooooo out not be functional...
+    class BoundBehavior
+      include Behavior
+      attr_reader :args, :block, :method, :receiver
+
+      extend Forwarder
+      forward :arity, to: :method
+
+      def call *a, &b
+        method
+        .( *(a + args), &(b||block) )
+      end
+      alias_method :[], :call
+
+      def to_proc
+        -> *a, &b do
+          method
+          .( *(a + args), &(b||block) )
+        end
+      end
+
+      private
+      def initialize receiver, method, *args, &block
+        @receiver = receiver
+        @method   = method
+        @args     = args
+        @block    = block
+      end
+
+    end # class BoundBehavior
+  end # module Behavior
+end # module Lab42

data/lib/lab42/core/behavior/composition.rb

@@ -0,0 +1,31 @@
+
+module Lab42
+  module Behavior
+    module Composer extend self
+      def zero_arity_composition lhs, rhs
+        Lab42::Behavior::ProcBehavior.new do |*args, &blk|
+          lhs.( *args, &blk )
+          rhs.()
+        end
+      end
+      def arg_passing_composition lhs, rhs
+        Lab42::Behavior::ProcBehavior.new do |*args, &blk|
+          rhs
+          .( lhs
+            .( *args, &blk ) )
+        end
+      end
+    end # module Composer
+
+    module Composition
+      def | behavior
+        if behavior.arity.zero?
+          Composer.zero_arity_composition self, behavior
+        else
+          Composer.arg_passing_composition self, behavior
+        end
+      end
+    end # module Composition
+    include Composition
+  end # class Behavior
+end # module Lab42

data/lib/lab42/core/behavior/negation.rb

@@ -0,0 +1,13 @@
+
+module Lab42
+  module Behavior
+    module Negation
+      def negated
+        ProcBehavior.new do |*args, &blk|
+          !self.(*args, &blk)
+        end
+      end
+    end # module Composition
+    include Negation
+  end # class Behavior
+end # module Lab42

data/lib/lab42/core/behavior/proc_behavior.rb

@@ -0,0 +1,23 @@
+require 'forwarder'
+module Lab42
+  module Behavior
+    class ProcBehavior
+      include Behavior
+      attr_reader :behavior
+
+      extend Forwarder
+      forward_all :arity, :call, :to_proc, to: :behavior
+
+      private
+      def initialize proc=nil, &blk
+        @behavior = proc || blk || ->{}
+      end
+    end # class ProcBehavior
+
+    class ::Proc
+      def to_behavior
+        Lab42::Behavior::ProcBehavior.new self
+      end
+    end
+  end # module Behavior
+end # module Lab42

data/lib/lab42/core/behavior/proxy.rb

@@ -1,7 +1,7 @@
-require_relative '../behavior'
-require_relative '../unbound_behavior'
+require_relative 'unbound_behavior'
+require_relative 'bound_behavior'
 module Lab42
-  class Behavior
+  module Behavior
     # Hey man really, that's all??? All my responsibility is to intercept
     # missing methods and sending them off to that Lab42::Behavior bloke,
     # having him have all the fun!!!! You cannott be serious by any known 
@@ -16,9 +16,9 @@ module Lab42
 
       def method_missing *args, &blk
         fm ?
-          Lab42::UnboundBehavior.new( receiver, receiver.instance_method( args.first ), *args.drop(1), &blk ) :
-          Lab42::Behavior.new( receiver, receiver.method( args.first ), *args.drop(1), &blk )
+          Lab42::Behavior::UnboundBehavior.new( receiver, receiver.instance_method( args.first ), *args.drop(1), &blk ) :
+          Lab42::Behavior::BoundBehavior.new( receiver, receiver.method( args.first ), *args.drop(1), &blk )
       end
     end # class Proxy
-  end # class Behavior
+  end # module Behavior
 end # module Lab42

data/lib/lab42/core/behavior/send_behavior.rb

@@ -0,0 +1,36 @@
+module Lab42
+  module Behavior
+    class SendBehavior
+      include Behavior
+      attr_reader :args, :block, :method
+
+      def arity; -1 end
+
+      def call rcv, *a, &b
+        rcv.send( method, *(a+args), &(b||block) )
+      end
+
+      def to_proc
+        -> rcv, *a, &b do
+          rcv.send( method, *(a+args), &(b||block) )
+        end
+      end
+
+      # Rebinding:
+      # We still apply our LIFO policy! So much for the proverbial
+      # "The early bird catches the worm"? Anyway, what would I do
+      # with a worm??? (Mescal maybe?)
+      def _ *a, &b
+        self.class.new method, *(a + args), &(b||block)
+      end
+
+      private
+      def initialize method, *args, &block
+        @method = method
+        @args   = args
+        @block  = block
+      end
+
+    end # class SendBehavior
+  end # module Behavior
+end # module Lab42

data/lib/lab42/core/behavior/unbound_behavior.rb

@@ -0,0 +1,53 @@
+require_relative 'composition'
+module Lab42
+  module Behavior
+
+    # Thank youn my dear Proxy, for sending me all the information
+    # I, the clever guy, who is having all the fun, will make best
+    # use of it by being an extremly, yes I said *extremly* clever
+    # callable object representing the methods or instance methods
+    # represented by the calls to `Object#fn` or `Module#fm`. 
+    # Did I tell you yet? It is sooooo out not be functional...
+    class UnboundBehavior
+      include Behavior
+      attr_reader :args, :block, :method
+      
+      # Increment method's arity by one as we need to bind the
+      # first argument to the method
+      def arity
+        method.arity.succ
+      end
+
+      def call *a, &b
+        available_args = a + args
+        m = method.bind available_args.first
+        m.( *available_args.drop(1), &(b||block) )
+      end
+
+      def to_proc
+        -> *a, &b do
+          available_args = a + args
+          method.bind( available_args.first )
+          .( *available_args.drop(1), &(b||block) )
+        end
+      end
+
+      # Rebinding:
+      # We still apply our LIFO policy! So much for the proverbial
+      # "The early bird catches the worm"? Anyway, what would I do
+      # with a worm??? (Mescal maybe?)
+      def _ *a, &b
+        self.class.new @klass, method, *(a + args), &(b||block)
+      end
+
+      private
+      def initialize klass, method, *args, &block
+        @klass  = klass
+        @method = method
+        @args   = args
+        @block  = block
+      end
+
+    end # class UnboundBehavior
+  end # module Behavior
+end # module Lab42

data/lib/lab42/core/behavior.rb

@@ -1,38 +1,13 @@
 require 'forwarder'
+require_relative 'behavior/composition'
+require_relative 'behavior/negation'
+require_relative 'behavior/proc_behavior'
+require_relative 'behavior/proxy'
+require_relative 'behavior/send_behavior'
+require_relative 'behavior/bound_behavior'
+require_relative 'behavior/unbound_behavior'
 
 module Lab42
-  # Thank youn my dear Proxy, for sending me all the information
-  # I, the clever guy, who is having all the fun, will make best
-  # use of it by being an extremly, yes I said *extremly* clever
-  # callable object representing the methods or instance methods
-  # represented by the calls to `Object#fn` or `Module#fm`. 
-  # Did I tell you yet? It is sooooo out not be functional...
-  class Behavior
-    attr_reader :args, :block, :method, :receiver
-
-
-    def call *a, &b
-      method
-        .( *(a + args), &(b||block) )
-    end
-    alias_method :[], :call
-
-    def to_proc
-      -> *a, &b do
-        method
-          .( *(a + args), &(b||block) )
-      end
-    end
-
-    
-    private
-    def initialize receiver, method, *args, &block
-      @receiver = receiver
-      @method   = method
-      @args     = args
-      @block    = block
-    end
-
-
-  end # class Behavior
+  module Behavior
+  end # module Behavior
 end # module Lab42

data/lib/lab42/core/dir.rb

@@ -2,21 +2,21 @@ require_relative 'meta'
 class << Dir
   def abs_files glob_para, *rst, &blk
     glob_para = File.join( *glob_para ) if Array === glob_para
-    blk = Lab42::Meta::Behavior *rst, &blk
+    blk = Lab42::Meta::Behavior.behavior *rst, &blk
 
     __files__ :last, glob_para, &blk
   end
 
   def files glob_para, *rst, &blk
     glob_para = File.join( *glob_para ) if Array === glob_para
-    blk = Lab42::Meta::Behavior *rst, &blk
+    blk = Lab42::Meta::Behavior.behavior *rst, &blk
 
     __files__ :both, glob_para, &blk
   end
 
   def rel_files glob_para, *rst, &blk
     glob_para = File.join( *glob_para ) if Array === glob_para
-    blk = Lab42::Meta::Behavior *rst, &blk
+    blk = Lab42::Meta::Behavior.behavior *rst, &blk
 
     __files__ :first, glob_para, &blk
   end

data/lib/lab42/core/fn.rb

@@ -1,4 +1,4 @@
-require_relative 'behavior/proxy'
+require_relative 'behavior'
  
 class Object
   def fn

data/lib/lab42/core/hash.rb

@@ -1,6 +1,19 @@
 require_relative 'meta'
 class Hash
 
+  def fetch! key, *defaults, &defblk
+    default_present = !(defaults.empty? && defblk.nil?)
+    return fetch key unless default_present
+    fetch key do
+      self[ key ] = defblk ? defblk.() : defaults.first
+    end
+  end
+  
+  def replace_rec *keys, limit: nil, limits: nil, &valblock
+    raise ArgumentError, "must not pass in limit: and limits: keyword parameters" if limit && limits
+    return Lab42::Meta::Hash.hash_replace_rec self, keys, valblock, limit || limits
+  end
+
   def only *args
     args.inject Hash.new do | r, k |
       if has_key? k
@@ -12,12 +25,12 @@ class Hash
   end
 
   def reject_values *behavior, &beh
-    beh = Lab42::Meta::Behavior *behavior, &beh
+    beh = Lab42::Meta::Behavior.behavior *behavior, &beh
     reject{ |_, v| beh.(v) }
   end
 
   def select_values *behavior, &beh
-    beh = Lab42::Meta::Behavior *behavior, &beh
+    beh = Lab42::Meta::Behavior.behavior *behavior, &beh
     select{ |_, v| beh.(v) }
   end
 
@@ -38,12 +51,4 @@ class Hash
       end
     end
   end
-
-  def fetch! key, *defaults, &defblk
-    default_present = !(defaults.empty? && defblk.nil?)
-    return fetch key unless default_present
-    fetch key do
-      self[ key ] = defblk ? defblk.() : defaults.first
-    end
-  end
 end # class Hash

data/lib/lab42/core/kernel.rb

@@ -0,0 +1,10 @@
+module Kernel
+  def require_relative_dir &blk
+    raise ArgumentError, 'need a block to determine source location' unless blk
+    dir = File.expand_path File.join( '..', blk.(), '*.rb'), blk.source_location.first
+    Dir.glob( dir ).each do | file |
+      require file
+    end
+  end
+end
+include Kernel

data/lib/lab42/core/memoization.rb

@@ -1,38 +1,43 @@
 require_relative 'hash'
 
-module Lab42::Unmemoizer
-  def unmemoize_memo method_name, *args
-    ivar_name =  "@__#{method_name}__"
-    return unless instance_variable_defined? ivar_name
-    return instance_variable_set ivar_name, {} if args.empty?
-    instance_variable_get( ivar_name ).delete args
+module Lab42::Memoizer extend self
+  def make_ivar_name from_sym
+    [
+      '@',
+    from_sym
+      .to_s
+      .sub('!', 'bang')
+      .sub('?', '_p'),
+      Time.now.nsec.to_s(36),
+      SecureRandom.uuid.gsub('-','')
+    ].join("_")
   end
-end
+  
+end # module Lab42::Memoizer
 
 class Module
 
-  include Lab42::Unmemoizer
-
   def lazy_attr sym, &blk
     raise ArgumentError, 'missing initialization block' unless blk
-    define_method sym do
-      ivar_name = "@__#{sym}__" 
-      return instance_variable_get( ivar_name ) if instance_variable_defined? ivar_name
-      instance_variable_set ivar_name, instance_eval( &blk )
-    end
+    memo sym, &blk
   end
 
   def memoize sym
-    include Lab42::Unmemoizer
     orig_method = instance_method sym
+    ivar_name = Lab42::Memoizer.make_ivar_name sym
+
     define_method sym do |*args|
-      ivar_name = "@__#{sym}__" 
       instance_variable_set ivar_name, {} unless instance_variable_defined? ivar_name
       instance_variable_get( ivar_name ).fetch! args do
-        # Not cached yet!!!
+        # Not cached yet, caching by means of fetch!
         orig_method.bind( self ).( *args )
       end
     end
+
+    define_method "unmemoize_memo_#{sym}" do | *args |
+      return instance_variable_set ivar_name, {} if args.empty?
+      instance_variable_get( ivar_name ).delete args
+    end
   end
 
   def memo *args, &blk

data/lib/lab42/core/meta/behavior.rb

@@ -0,0 +1,34 @@
+module Lab42
+  module Meta
+    module Behavior extend self
+      def behavior *args, &blk
+        return blk if blk
+        determine_behavior_from args
+      end 
+
+      def call_with_arity blk, params, base_arity: 1
+        return blk.(*params.first(base_arity)) if blk.arity < 0
+        blk.(*params.first(blk.arity))
+      end
+
+      private
+      def determine_behavior_from args
+        return make_callable args.last if args.last && args.last.respond_to?(  :call )
+        return make_message_sender args if Symbol === args.first
+      end
+
+      def make_callable callable
+        return callable if Proc === callable
+        -> *a, &b do
+          callable.(*a, &b)
+        end
+      end
+
+      def make_message_sender args
+        -> (rcv, *late_args) do
+          rcv.send( args.first, *( late_args + args.drop(1) ) )
+        end
+      end
+    end # module Behavior
+  end # module Meta
+end # module Lab42

data/lib/lab42/core/meta/hash.rb

@@ -0,0 +1,50 @@
+module Lab42
+  module Meta
+    module Hash extend self
+      def hash_replace_rec orig, keys, valblock, limits
+        return unlimited_hash_replace_rec orig, keys, valblock unless limits
+        limits = ::Hash[ *keys.zip( [limits] * keys.size ).flatten ] unless ::Hash === limits
+        limited_hash_replace_rec orig, keys, valblock, limits
+      end
+
+      private
+      def limited_hash_replace_rec orig, keys, valblock, limits
+        orig.inject ::Hash.new do | h, (k, v) |
+          h.merge! k => limited_value( keys, k, v, valblock, limits )
+        end
+      end
+
+      def limited_value keys, k, v, valblock, limits
+        if keys.include?( k ) && limits.fetch(k, 1) > 0
+          limits[k] and limits[k] -= 1
+          Behavior.call_with_arity valblock, [v, k]
+        else
+          recur_or_value keys, v, valblock, limits
+        end
+      end
+
+      def recur_or_value keys, v, valblock, limits
+        if ::Hash === v
+          limited_hash_replace_rec v, keys, valblock, limits
+        else
+          v
+        end
+      end
+
+      def unlimited_hash_replace_rec orig, keys, valblock
+        orig.inject ::Hash.new do | h, (k, v) |
+          h.merge! k => unlimited_value( keys, k, v, valblock )
+        end
+      end
+      def unlimited_value keys, k, v, valblock
+        if keys.include? k
+          Behavior.call_with_arity valblock, [v, k]
+        elsif ::Hash === v
+          unlimited_hash_replace_rec v, keys, valblock
+        else
+          v
+        end
+      end
+    end # module Hash
+  end # module Meta
+end # module Lab42

data/lib/lab42/core/meta.rb

@@ -1,27 +1 @@
-module Lab42
-  module Meta extend self
-    def Behavior *args, &blk
-      return blk if blk
-      determine_behavior_from args
-    end 
-
-    private
-    def determine_behavior_from args
-      return make_callable args.last if args.last && args.last.respond_to?(  :call )
-      return make_message_sender args if Symbol === args.first
-    end
-
-    def make_callable callable
-      return callable if Proc === callable
-      -> *a, &b do
-        callable.(*a, &b)
-      end
-    end
-
-    def make_message_sender args
-      -> (rcv, *late_args) do
-        rcv.send( args.first, *( late_args + args.drop(1) ) )
-      end
-    end
-  end # module Meta
-end # module Lab42
+require_relative_dir{ 'meta' }

data/lib/lab42/core/open_object.rb

@@ -42,6 +42,14 @@ class OpenObject
     def inherited *args, **kwds, &blk
       raise RuntimeError, "I prefer delegation to inheritance, if you do not, MP me"
     end
+
+    def merging *args
+      new **(
+        args.inject Hash.new do |r, arg|
+          r.merge arg.to_hash
+        end
+      )
+    end
   end
 end # class OpenObject
 

data/lib/lab42/core/version.rb

@@ -1,5 +1,5 @@
 module Lab42
   module Core
-    VERSION = "0.3.3"
+    VERSION = "0.4"
   end # module Core
 end # module Lab42

data/lib/lab42/core.rb

@@ -1,6 +1,7 @@
 
 require_relative './core/old_ruby2' if RUBY_VERSION < '2.2'
 
+require_relative './core/kernel'
 require_relative './core/array'
 require_relative './core/dir'
 require_relative './core/enumerable'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lab42_core
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: '0.4'
 platform: ruby
 authors:
 - Robert Dober
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-31 00:00:00.000000000 Z
+date: 2015-09-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: forwarder2
@@ -120,9 +120,14 @@ files:
 - lib/lab42/core.rb
 - lib/lab42/core/array.rb
 - lib/lab42/core/b.rb
-- lib/lab42/core/behave.rb
 - lib/lab42/core/behavior.rb
+- lib/lab42/core/behavior/bound_behavior.rb
+- lib/lab42/core/behavior/composition.rb
+- lib/lab42/core/behavior/negation.rb
+- lib/lab42/core/behavior/proc_behavior.rb
 - lib/lab42/core/behavior/proxy.rb
+- lib/lab42/core/behavior/send_behavior.rb
+- lib/lab42/core/behavior/unbound_behavior.rb
 - lib/lab42/core/console_tools.rb
 - lib/lab42/core/console_tools/enumerable.rb
 - lib/lab42/core/console_tools/func.rb
@@ -134,9 +139,10 @@ files:
 - lib/lab42/core/kernel.rb
 - lib/lab42/core/memoization.rb
 - lib/lab42/core/meta.rb
+- lib/lab42/core/meta/behavior.rb
+- lib/lab42/core/meta/hash.rb
 - lib/lab42/core/old_ruby2.rb
 - lib/lab42/core/open_object.rb
-- lib/lab42/core/unbound_behavior.rb
 - lib/lab42/core/version.rb
 - lib/lab42/file.rb
 - lib/lab42/lazy.rb
@@ -160,7 +166,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: Simple Ruby Core Module Extensions (for more see lab42_more)

data/lib/lab42/core/unbound_behavior.rb

@@ -1,44 +0,0 @@
-require_relative 'behavior'
-
-module Lab42
-  # Thank youn my dear Proxy, for sending me all the information
-  # I, the clever guy, who is having all the fun, will make best
-  # use of it by being an extremly, yes I said *extremly* clever
-  # callable object representing the methods or instance methods
-  # represented by the calls to `Object#fn` or `Module#fm`. 
-  # Did I tell you yet? It is sooooo out not be functional...
-  class UnboundBehavior
-    attr_reader :args, :block, :method
-
-    def call *a, &b
-      available_args = a + args
-      m = method.bind available_args.first
-      m.( *available_args.drop(1), &(b||block) )
-    end
-
-    def to_proc
-      -> *a, &b do
-        available_args = a + args
-        method.bind( available_args.first )
-          .( *available_args.drop(1), &(b||block) )
-      end
-    end
-
-    # Rebinding:
-    # We still apply our LIFO policy! So much for the proverbial
-    # "The early bird catches the worm"? Anyway, what would I do
-    # with a worm??? (Mescal maybe?)
-    def _ *a, &b
-      self.class.new @klass, method, *(a + args), &(b||block)
-    end
-
-    private
-    def initialize klass, method, *args, &block
-      @klass  = klass
-      @method = method
-      @args   = args
-      @block  = block
-    end
-
-  end # class Behavior
-end # module Lab42