Variable argument number and behaviour [Newbie]

[Ryan Allan]

Hello Everyone,

I'm trying to make a function take arguments in a particular way.

This is what I want to create:

#Variable argument testing
def function(*sometimes)

if sometimes.nil?
print "Not given!"
else
print "Here!"
end

end

function
[EOF]

As I understand it, the * operator bundles the argument into an array,
so that if test returns true. I know that I can use "if
sometimes.length==0" to get the same behaviour, but that is rather
obscure compared to the first version.

Is there some other way to set up the argument list? (Alas, I have found
nothing in the documentation or the Forum.)

Thank you,
-Ryan

 

[Stefano Crocco]

Alle domenica 1 luglio 2007, Ryan Allan ha scritto:

Hello Everyone,

I'm trying to make a function take arguments in a particular way.

This is what I want to create:

#Variable argument testing
def function(*sometimes)

if sometimes.nil?
print "Not given!"
else
print "Here!"
end

end

function
[EOF]

As I understand it, the * operator bundles the argument into an array,
so that if test returns true. I know that I can use "if
sometimes.length==0" to get the same behaviour, but that is rather
obscure compared to the first version.

Is there some other way to set up the argument list? (Alas, I have found
nothing in the documentation or the Forum.)

Thank you,
-Ryan

I can't think of any other way to make a method take any number of arguments,
but remember that there's a shorter way to tell whether an array is empty:
the empty? method:

def function(*sometimes)
if sometimes.empty?
print "Not given!"
else
print "Here!"
end
end

This way, it's as clear as what you wanted to use. Besides, even if it had
been possible, your approach would have had a problem: you wouldn't have been
able to distinguish the case of a single nil argument from the case of no
arguments:

function(nil)

function()

The correct approach solves this problem: if no arguments are passed,
sometimes is empty (empty? returns true); otherwise it's not empty, even if
all arguments are nil.

I hope this helps

Stefano

 

[yermej]

Hello Everyone,

I'm trying to make a function take arguments in a particular way.

This is what I want to create:

#Variable argument testing
def function(*sometimes)

if sometimes.nil?
print "Not given!"
else
print "Here!"
end

end

function
[EOF]

As I understand it, the * operator bundles the argument into an array,
so that if test returns true. I know that I can use "if
sometimes.length==0" to get the same behaviour, but that is rather
obscure compared to the first version.

Is there some other way to set up the argument list? (Alas, I have found
nothing in the documentation or the Forum.)

Thank you,
-Ryan

I think you are looking for default arguments:

def function(arg = nil)
# do stuff
end

If no argument is passed to function, arg will be nil, else it will
have the value passed in. Note you don't have to use nil for the
default, you could use any other value as well (even an expression).

However, if you still want to allow an arbitrary number of arguments,
I think you'll have to use the *arg syntax and check the array length
as Ruby doesn't allow:

def f(*arg = nil)
end

Jeremy

 

[Ryan Allan]

Thank you Stefano.
You're right; the empty? method is nicely obvious.
I do have a further question, however. You've highlighted a problem
with my original idea, but I don't understand it.

Besides, even if it
had been possible, your approach would have had a problem: you wouldn't have
been able to distinguish the case of a single nil argument from the case of
no arguments:

function(nil)

function()

The correct approach solves this problem: if no arguments are passed,
sometimes is empty (empty? returns true); otherwise it's not empty, even
if all arguments are nil.

What is the difference between no arguments and a single nil argument?
It seems to me that the cases are logically equivalent. Ruby treats them
separately?

Thanks again,
-Ryan

 

[dblack]

Hi --

Thank you Stefano.
You're right; the empty? method is nicely obvious.
I do have a further question, however. You've highlighted a problem
with my original idea, but I don't understand it.


What is the difference between no arguments and a single nil argument?
It seems to me that the cases are logically equivalent. Ruby treats them
separately?

Yes, because nil is an object.

def meth(x)
p x
end

meth(1) # 1
meth(nil) # nil
meth # ArgumentError: wrong number of arguments


David

--
* Books:
RAILS ROUTING (new! http://www.awprofessional.com/title/0321509242)
RUBY FOR RAILS (http://www.manning.com/black)
* Ruby/Rails training
& consulting: Ruby Power and Light, LLC (http://www.rubypal.com)

 

[Ryan Allan]

Thank you David. That makes much more sense now.

 

[Vu Nang Luc]

Yes, because nil is an object.

Right, and if you use Array.nil? passing no argument still return
false as following:

a = []
a.nil?

=>false