I'm doing research in Smalltalk reflection, and I was wondering if it was possible to extend an individual object like that would be possible for instance in Ruby. With this I mean a selector that only particular objects respond to.
Here is some Ruby code that states what I mean. For clarification: in Ruby this open a virtual class for this object, and extends it with a new definition. The vital part here is that nothing changes to the class definition!
o = Object.new
o.instance_eval {def foo;puts "foo";end}
o.foo #=> "foo"
#however this will fail:
m = Object.new
m.foo #=> NoMethod error
More specifically my question is whether this is possible in standard Squeak/Pharo or other smalltalk implementations, without adding substantial structures or code to allow this. So with other words with regular reflective features that exist in Smalltalk.
As an example, it is possible to add methods, remove methods, compile new code into a class, change instance variables and just about anything, but I haven't found a way to extend a single object.
Test addInstVarNamed: #var.
Test compile: 'var ^var'.
t:= Test new.
Test instVarNames.
t instVarNamed: #var put: 666.
t var. #=> 666
If the answer is no, then explain why. I'm not looking for solving this problem but rather understanding why it isn't in smalltalk.
In Smalltalk there is no built in way of doing instance-specific behavior in that way. Smalltalk adheres to the principle that each object belongs to a class and its behavior and state shape depends on the class. That is why you can easily change the class (add inst vars, compile new methods, etc), but that means changing the behavior to all of its instances. There are, however, different approaches (according to the Smalltalk flavor) for achieving instance-specific behavior, such as Lightweight Classes, where the idea is to create a special (lightweight) class for a particular instance and replace the original class with the custom one. As a result you have a special class for each "special" instance. AFAIK in Digitalk St the dispatching mechanism is a bit more flexible and allows to easily implement instance-based behavior (see 4th link). I'll leave here some links that you may find useful:
HTH
Edit: the link posted by Hernan ("Debugging Objects" by Hinkle, Jones & Johnson) is the one to which I was referring and that couldn't find.