[ruby-core:52714] new feature : suggest - defclosure - similar to how labels in lisp can be used

class  Xray


  # new feature : suggest (we should have a defclosure) a way to define a
helper code that remembers
  # that the closure of variables reaches the upper block, below A and B
would be defined as in
  # scope of 1 up.
  #
  # pretend that  doXrayHelper_V1  was defined as:
  #
  #    defclosure doXrayHelper_V1(c) ;  a*3 + b*4 + c ; end
  #
  # and it stores a pointer the the enclosed scope, and only works within a
function.
  #
  # === Motivation:
  # Q: 1  is there any way to do what lisp calls: labels
  #   see @url: http://www.paulgraham.com/onlisptext.html for the following:
  #
  # Using labels we can write a function analogous to list+, but in which
the first argument to mapcar is a recursive function:
  #
  # (defun count-instances (obj lsts)
  #   (labels ((instances-in (lst)
  #      (if (consp lst)
  #            (+ (if (eq (car lst) obj) 1 0)
  #               (instances-in (cdr lst)))
  #            0)))
  #    (mapcar #段nstances-in lsts)))
  #
  #  above  labels instances-in  would be our defclosure instances-in , or
defclosure doXrayHelper_V1(c) ... below.
  #
  # Q: 2 :  what is the easiest way to efficiently define a helper method
that really is very static but
  #         is IN-A-FUNCTION  and hidden scope to the method?

  # Attempts below:
  # 1.  does not work because of local scope
  # 2.  works, but no fnct hide; and is efficient
  # 3.  works, via lambda define each function call, so not efficient

  #####################  V1 #########
  # This will not work, you get:
  #    `doXrayHelper_V1': undefined local variable or method `a' for
#<Xray:0x007ffd8d02e288> (NameError)
    #    ruby_closure_speed.rb:14:in `doXray_V1'
  #    ruby_closure_speed.rb:24:in `<top (required)>'
  ###################################
  def doXray_V1(a,b)


    def doXrayHelper_V1(c)
      a*3 + b*4 + c
    end

    doXrayHelper_V1(5)

  end


  #####################  V2 #########
  # This will work, and is efficient but we have leaked the helper function
outside the only place
  # that it is used
  ###################################
  def doXray_V2(a,b)

    doXrayHelper_V2(5,a,b)

  end

  def doXrayHelper_V2(c,a,b)            ### function leaked here
    a*3 + b*4 + c
  end
  private  :doXrayHelper_V2             ### make private so end users can
not see, still it is seen in this class

  #####################  V3 #########
  # This will  work, but as you will see it is not very efficient in that
we redefine the "helper fnct" that
  # we wanted to keep local to this function on each call.  We get sample
output of:
  #
  #  ["... debug doXrayHelper_V3.object_id: ", 70229925414620]
  #  ["... debug doXrayHelper_V3.object_id: ", 70229925414260]
  #  ["... debug doXrayHelper_V3.object_id: ", 70229925413920]
  #  ["... debug doXrayHelper_V3.object_id: ", 70229925413680]
  #  ["... debug doXrayHelper_V3.object_id: ", 70229925413440]
  #  ["... debug doXrayHelper_V3.object_id: ", 70229929690500]
  #
  # but look at all the work it does on each call, it creates another
closure , when you compile lisp code
  # there it will be smarter that this is just a helper function.
  ###################################
  def doXray_V3(a,b)


    doXrayHelper_V3 = lambda do |c|
      a*3 + b*4 + c
    end

    p ["... debug doXrayHelper_V3.object_id: ", doXrayHelper_V3.object_id]

    doXrayHelper_V3.call(5)

  end

end


a = Xray.new

a.doXray_V2(3,4)

a.doXray_V3(3,4)
a.doXray_V3(3,4)
a.doXray_V3(3,4)
a.doXray_V3(3,4)
a.doXray_V3(3,4)
a.doXray_V3(3,4)