From: Dave Burt <dave@...>
Date: 2005-07-12T22:40:51+09:00
Subject: Re: Discussion of SOLUTION for SerializableProc (#38)

Proc's documentation tells us that "Proc objects are blocks of code that 
have been bound to a set of local variables." (That is, they are "closures" 
with "bindings".) Do any of the proposed solutions so far store local 
variables?

# That is, can the following Proc be serialized?
  local_var = 42
  code = proc { local_var += 1 }  # <= what should that look like in YAML?
  code.call  #=> 43
  File.open("proc.marshalled", "w") { |file| Marshal.dump(code, file) }

# New context, e.g. new file:
  code = File.open("proc.marshalled") { |file| Marshal.load(file) }
  code.call  #=> 44
  local_var  #=> NameError - undefined here

AFAICT, the only one is Christian Neukirchen's Nodewrap suggestion, which 
looks very cool. From <http://rubystuff.org/nodewrap/>:

Sample code
This will dump the class Foo (including its instance methods, class 
variables, etc.) and re-load it as an anonymous class:
  class Foo
    def foo; puts "this is a test..."; end
  end

  s = Marshal.dump(Foo)
  p Marshal.load(s) #=> #<Class 0lx4027be20>

Here's another, trickier test for SerializableProcs. Can multiple Procs 
sharing context, as returned by the following method, be made to behave 
consistently across serialization?  If the Procs are serialized 
independently, I believe this is impossible - an inherent problem with the 
idea of serializing Procs (or anything with shared context).
  def two_procs
    x = 1
    [proc { x }, proc { x += 1 }]
  end

  p1, p2 = two_procs
  [p1.call, p2.call, p1.call, p2.call]  #=> [1, 2, 2, 3]
  q1, q2 = Marshal.load(Marshal.dump(p1)), Marshal.load(Marshal.dump(p2))
  [q1.call, q2.call, q1.call, q2.call]  #=> [3, 4, 4, 5]
  # I expect Nodewrap can get [3, 4, 3, 5] for this last result.

Dave