Why no singleton methods on Symbol?

Are there other objects that are also not allowed to have singleton methods?

itsme213 wrote:

Why no singleton methods on Symbol?

Are there other objects that are also not allowed to have singleton
methods?


Singleton methods can not be defined for "immediate" Objects.
Immediate Objects are stored directly by their id which means they are
very cheap to use.

Immediate objects include all Fixnums, Symbols, true, false and nil
(but note that def true.foo; end will silently add the method directly
to TrueClass because there is guaranteed to be only one instance,
true, for it.)
You can also not add methods to Floats and Bignums (this is for
consistency with Fixnums), but this can be changed by overriding
Numeric#singleton_method_added

irb(main):025:0> x = :any
=> :any
irb(main):026:0> def x.include(obj); true; end
TypeError: can't define singleton method "include" for Symbol
from (irb):26

Why no singleton methods on Symbol?

Are there other objects that are also not allowed to have singleton methods?


Yes you can't define singleton methods for Fixnums either - originally

a = "x"
def (a).foo ...

You can view "x" as an object constructor (much similar to 1, [] {1=>2}
etc.). Different from 1 "x" creates new instances every time it is
executed:
That explains why a) it doesn't make sense to do 'def "x".foo()...end'
(regardless of the number of brackets around "x") and b) Ruby issues the
warning / error message.

You can view "x" as an object constructor (much similar to 1, []
{1=>2}
etc.). Different from 1 "x" creates new instances every time it is
executed:
That explains why a) it doesn't make sense to do 'def "x".foo()...end'
(regardless of the number of brackets around "x") and b) Ruby issues
the
warning / error message.

I'm sure I am missing something.

a = "x"
def a.foo; end
b = a
b.foo

Have I not defined a singleton method on a literal?

Have I not defined a singleton method on a literal?

You have not. You defined a singleton method on a string instance that
represents the sequence "x". If you like you can view it that way that
the literal "x" is not directly accessible. It just creates a string
instance with sequence "x" every time it is evaluated:

Have I not defined a singleton method on a literal?

You have not. You defined a singleton method on a string instance
that
represents the sequence "x". If you like you can view it that way
that
the literal "x" is not directly accessible. It just creates a string
instance with sequence "x" every time it is evaluated:

Ah. Subtle. Thanks (assuming I've got it!). Would this re-phrasing be
the
right idea?

A literal (I'll use the term 'value' object as a generalization) is a
virtual object that you cannot access or manipulate. Every conceivable
value
object already exists before the first line of your code is run. What
you
can create, access, and manipulate are instances that represent, by
various
encodings, references to a given value object.

For immediate objects, these referencing instances use encodings that
directly share the same object_id.
e.g.
:a # reference to unique virtual symbol :a
:a.object_id == :a.object_id #=> true
:a == :a #=> true, obviously

For all other value objects, those referencing instances have "=="
defined
so that references to the same value object compare as identical.
"x" # reference to unique virtual string "x"
"x".object_id == "x".object_id #=> false
"x" == "x" #=> true

I prefer to view a literal as a special kind of expression that yields an
instance on each execution. Whether this is always the same instance (as
for symbols, Fixnum and surprisingly also for Bignum and Regexp) or
whether it's a different instance (as for strings, arrays and hashes)
depends on the literal.

On Thu, 2 Dec 2004 19:12:43 +0900
"Robert Klemme" <bob.news@gmx.net> wrote:


I prefer to view a literal as a special kind of expression that yields
an
instance on each execution. Whether this is always the same instance
(as
for symbols, Fixnum and surprisingly also for Bignum and Regexp) or
whether it's a different instance (as for strings, arrays and hashes)
depends on the literal.

That regexps are always the same surprised me also, but it is nice. So
it is
not optimization to extract a regexp into a constant instead of writing
it in
the loop.

(Btw: Always when I'm trying to optimze something in ruby, it gets
slower. Ruby
follows exactly my mindset when programming, and when I try to change my
mind
on how the computer actually works it out, I'm running in the wrong
direction.

irb(main):005:0> 2.times do |i| puts /abc/.id end
538420744
538420744
=> 2

But it can't always be true

irb(main):006:0> 2.times do |i| puts /abc#{i}/.id end
538396754
538396704
=> 2

Or maybe one should clarify it such, that a regexp with interpolation is
no
longer a literal.

2.times do |i| puts /abc#{i}/o.id end
135012888

[snip]
But

2.times do |i| puts /abc#{i}/o.id end
135012888
135012888
=> 2

Note the usage of flag "o".

Kind regards

robert

3.times do | i | puts /#{i}/o =~ '1' end
nil

On Thu, 2 Dec 2004 21:27:43 +0900
"Robert Klemme" <bob.news@gmx.net> wrote:

[snip]
But

2.times do |i| puts /abc#{i}/o.id end
135012888
135012888
=> 2

Note the usage of flag "o".

Kind regards

robert


Interesting, but what is the use case for this? It seems to be quite
dangerous
because it makes code really difficult to understand.

E.g. The causual reader would expect this to yield nil, 0, nil.

3.times do | i | puts /#{i}/o =~ '1' end
nil
nil
nil
=> 3

I shall read my pickaxe again

I think Ruby inherited this flag [/o] from P**l.

Robert Klemme wrote:

I think Ruby inherited this flag [/o] from P**l.

Is Perl inheritance something to be ashamed of nowadays?