Re: "Anonymous classes or modules", what they are? (Marshaling)

Dami=C3=A1n M. Gonz=C3=A1lez wrote in post #1076236:
> Brian Candler wrote in post #1076224:
>
>> It is, but this is a special case.
>>
>> {"foo" =3D> String, "bar" =3D> Array}
>> is serialised as just references to the class named "String" and "Arra=
y"
>>
>> 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 reference=
s
>> to (named) classes, which is useful, without being able to serialize t=
he
>> 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 =3D klass
  end
  def make(*args)
    @klass.new(*args)
  end
end

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

f =3D 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/.=