As a more specific example, consider some hopeful code for allowing
auto-creation of arrays from nil, perl-ish style:
class Nil
def push(*els)
a = Array.new
a.push(*els) #self = a # Nope! #self.class = Array # Nope!
end
end
This would allow:
a = nil
a.push(1,2,3)
puts “#{a.class}”
I know we have things like to_a, but that requires an assigment instead
of just the method call. Let’s just assume we need a way to do it like
this.
Is this just considered impossible, or is there a way to change/convert
the class of self from inside a method? I can imagine it would cause
complications the moment the class changes, since we’d suddenly be in
the method of the wrong class, but if any language had a way to do it, I
figure it’d be ruby.
As a more specific example, consider some hopeful code for allowing
auto-creation of arrays from nil, perl-ish style:
If you miss Perl that much you are probably using the wrong language
here.
a = nil
a.push(1,2,3)
puts “#{a.class}”
I know we have things like to_a, but that requires an assigment instead
of just the method call. Let’s just assume we need a way to do it like
this.
I am not ready to assume “that we need a way to do it like this”. The
Ruby idiom for this is
a = nil
…
(a ||=[]).push(1,2,3)
Is this just considered impossible, or is there a way to change/convert
the class of self from inside a method? I can imagine it would cause
complications the moment the class changes, since we’d suddenly be in
the method of the wrong class, but if any language had a way to do it, I
figure it’d be ruby.
There might be a way in a C extension but actually I consider it a bad
idea because it violates one of the basic assumptions of the language
(i.e. that the class of an instance does not change) - and it’s
unnecessary (see above).
What you can do is to use a proxy object like SimpleDelegator and
change the instance it points to later. But then you need to
initialize the variable and if you know it’s going to be an Array you
can just as well initialize with an empty Array instance.
I also don’t think you can reassign self without digging into Ruby’s
source code. My idea was to at least fake an object transformation by
making the nil instance a wrapper for an array:
#------------------
class NilClass
def push *values @array = values @array.methods.each do |method|
define_singleton_method method do |*args, &block| @array.send method, *args, &block
end
end
end
end
a = nil
a.push 1, 2
p a
puts a.class #------------------
But then I realized that nil is actually a singleton object (there’s
only one nil). This somewhat makes the whole thing pointless, because
any change to a nil instance would affect all “nils”.
I don’t see the point in this feature, anyway. It perhaps would make
some sense if you didn’t have to set the variable in the first place but
could magically create a new array by calling the push method on a new
identifier. PHP has this, for example:
$x[0] = “abc”; // this makes $x an array
But when you have to write “a = nil” first, then you might as well write
“a = []” and leave out all the magic.
I also don’t think you can reassign self without digging into Ruby’s
source code.
What are you guys talking about reassigning self all the time? David
wants to change the class of an instance - not its identity. Even if
you could reassign self inside a method all variable references still
point to the same old instance self pointed to before. This clearly
does not achieve the goal as stated.
My idea was to at least fake an object transformation by
making the nil instance a wrapper for an array:
But then I realized that nil is actually a singleton object (there’s
only one nil). This somewhat makes the whole thing pointless, because
any change to a nil instance would affect all “nils”.
Exactly.
I don’t see the point in this feature, anyway. It perhaps would make
some sense if you didn’t have to set the variable in the first place but
could magically create a new array by calling the push method on a new
identifier. PHP has this, for example:
$x[0] = “abc”; // this makes $x an array
But when you have to write “a = nil” first, then you might as well write
“a = []” and leave out all the magic.
The use case is probably rather instance variables which do not
require initialization and default to nil. Still, I don’t think it’s
needed. I believe OP hasn’t got the hang of how Ruby works yet.
Is this just considered impossible, or is there a way to change/convert
the class of self from inside a method? I can imagine it would cause
complications the moment the class changes, since we’d suddenly be in
the method of the wrong class, but if any language had a way to do it, I
figure it’d be ruby.
Fun fact: it’s possible in Python. (It tends to lead to segfaults.)
It’s not possible in Ruby, but may be achievable using a C extension.
Still, that seems like a very bad idea. I don’t know your usecase, but
you could probably either start with an empty array instead of nil, or
“guard” all array methods with “ary ||= []”.
Yes, indeed it is achievable using a C extension, at least for the
user-defined class.
Still it does not help for the use case at hand since nil is a
singleton instance. All others will also see nil turn into an Array
which will have dramatic effects. This is a classical Bad Idea™.
you could probably either start with an empty array instead of nil, or
“guard” all array methods with “ary ||= []”.
A related and useful idiom is auto-vivification of Hash elements:
h = Hash.new { |h,k| h[k] = [] }
h[:foo] << “bar”
h[:foo] << “baz”
p h # {:foo=>[“bar”, “baz”]}
Objects in ruby cannot change their class. If you really need to do
this, then you can have a proxy object which delegates calls, and you
can change the target object dynamically: