From: Brian Candler <lists@...>
Date: 2012-09-18T04:37:06+09:00
Subject: Re: "Anonymous classes or modules", what they are? (Marshaling)

Damián M. González wrote in post #1076236:
> Brian Candler wrote in post #1076224:
>
>> It is, but this is a special case.
>>
>> {"foo" => String, "bar" => Array}
>> is serialised as just references to the class named "String" and "Array"
>>
>> If it worked the way you wanted, then instead of serializing the name it
>> would have to serialize everything needed to reconstruct the classes
>> "String" and "Array" - including the methods.
>>
>> So what we gain is the ability to have objects which contain references
>> to (named) classes, which is useful, without being able to serialize the
>> classes themselves.
>
>  Can you give me a short example?

Any object which includes a Class in an instance variable. I dunno:

class Factory
  def initialize(klass)
    @klass = klass
  end
  def make(*args)
    @klass.new(*args)
  end
end

class Foo
  class <<self; attr_accessor :count; end
  @count = 1
end

f = Factory.new(Foo)
f.make
p Marshal.dump(f)

Now I can happily Marshal.dump(f), even though it contains a reference 
to a class (Foo). When I reload the object later, it will still contain 
a reference to class Foo. However no attempt is made to restore the 
state of Foo itself; that would be an unwanted side-effect, to have the 
current class Foo's state changed to how it was at the time when f was 
serialized.

The alternative would be to return an anonymous class with the state of 
Foo at the time when f was serialized. However that's not an accurate 
representation of f (it wasn't pointing to an anonymous class, it was 
pointing to Foo). Moreover, we can't serialise anonymous classes anyway, 
because that would mean serializing all the methods of that class.

-- 
Posted via http://www.ruby-forum.com/.