private method calls...why can't you use self.priv_method syntax?
 

Why is it that when you call a private method, you cannot use
self.the_priv_method?
Below is an example that works if you take out self before the method,
but fails with it in.
It is odd because using self should just a more explicit statement.
But either way the method is being sent to the same object.
WEIRD!!!!
Please let me know how you gurus wrap your heads around this
(apparent) inconsistency.
Thanks,
Tim


class TestPrivate
def giveValue
@value
end
def callPriv
self.priv #why can't you put the self in front of a private method?
end

private
def priv
@value = 100
end
end


i = TestPrivate.new
p i
i.callPriv
p i.giveValue
# ~> -:6:in `callPriv': private method `priv' called for #<TestPrivate:
0x33e1f4> (NoMethodError)
# ~> from -:18
# >> #<TestPrivate:0x33e1f4>

Re: private method calls...why can't you use self.priv_method syntax?
 

In Ruby, private means that the method cannot be called with an
*explicit* receiver (that includes "self"). This is a bit different
then languages like C++ and Java which use private/protected to
control calling in inheritance chains. Remember, Ruby is all about the
callers and receivers. If you leave off the "self." at the front, then
self is *implicit* (which is allowed for private methods. Try this:

class MyClass
def call_protected_on(obj)
obj.protected_method
end

def call_private_on(obj)
obj.private_method
end

protected
def protected_method
puts "Explicit callers are ok"
end

private
def private_method
puts "Implicit callers only!"
end
end

my_obj = MyClass.new
my_other_obj = MyClass.new
my_obj.call_protected_on(my_other_obj)
my_obj.call_private_on(my_other_obj)

Cheers,

Josh


On Jun 3, 2009, at 11:55 PM, timr wrote:

> Why is it that when you call a private method, you cannot use
> self.the_priv_method?
> Below is an example that works if you take out self before the method,
> but fails with it in.
> It is odd because using self should just a more explicit statement.
> But either way the method is being sent to the same object.
> WEIRD!!!!
> Please let me know how you gurus wrap your heads around this
> (apparent) inconsistency.
> Thanks,
> Tim
>
>
> class TestPrivate
> def giveValue
> @value
> end
> def callPriv
> self.priv #why can't you put the self in front of a private method?
> end
>
> private
> def priv
> @value = 100
> end
> end
>
>
> i = TestPrivate.new
> p i
> i.callPriv
> p i.giveValue
> # ~> -:6:in `callPriv': private method `priv' called for
> #<TestPrivate:
> 0x33e1f4> (NoMethodError)
> # ~> from -:18
> # >> #<TestPrivate:0x33e1f4>
>

Re: private method calls...why can't you use self.priv_method syntax?
 

Josh, thanks for the clarification. I guess I just have to accept the
syntax for the private method calls. But it is hard for me to
understand why calling a private method on its own--which has to look
up self to use as a receiver, is any different than me just giving it
the receiver of self. Either way the same object is being used as the
receiver. So there must be something strange about the way private is
implemented that makes it not ever take receivers, even if you give it
the receiver that it is going to lookup and use. Okay, I can tell I am
just grumbling about something that I should just accept. Sorry.
Thanks again,
Tim

On Jun 4, 12:35*am, Joshua Ballanco <jball...@gmail.com> wrote:
> In Ruby, private means that the method cannot be called with an *
> *explicit* receiver (that includes "self"). This is a bit different *
> then languages like C++ and Java which use private/protected to *
> control calling in inheritance chains. Remember, Ruby is all about the *
> callers and receivers. If you leave off the "self." at the front, then *
> self is *implicit* (which is allowed for private methods.