[lnkForumImage]
TotalShareware - Download Free Software
Confronta i prezzi di migliaia di prodotti.
Asp Forum
 Home | Login | Register | Search 


 

Forums >

comp.lang.ruby

Default values for method arguments

paul

12/6/2006 2:01:00 PM

Hi all,

Probably I'm trying something impossible, but when giving default
values for arguments to a method call, do I have to give default-values
for *all* arguments?

irb(main):001:0> class A
irb(main):002:1> def a(b = 0, c, d = '', e)
irb(main):003:2> puts b, c, d, e
irb(main):004:2> end
irb(main):005:1> end
SyntaxError: compile error
(irb):2: syntax error
def a(b = 0, c, d = '', e)
^
(irb):2: syntax error
(irb):5: syntax error
from (irb):5

And also when giving default-values to all arguments, omitting
arguments when calling the method doesn't seem to be a succes:

irb(main):001:0> class B
irb(main):002:1> def b(c = 0, d = 1, e = 2)
irb(main):003:2> puts c, d, e
irb(main):004:2> end
irb(main):005:1> end
=> nil
irb(main):006:0> B.new.b(1,2,3)
1
2
3
=> nil
irb(main):007:0> B.new.b(1,,3)
SyntaxError: compile error
(irb):7: syntax error
B.new.b(1,,3)
^
from (irb):7

Is it impossible or I'm I just coding it wrong?

Cheers,
Paul
6 Answers

James Gray

12/6/2006 2:18:00 PM

0

On Dec 6, 2006, at 8:05 AM, paul wrote:

> Probably I'm trying something impossible, but when giving default
> values for arguments to a method call, do I have to give default-
> values
> for *all* arguments?

No, but all the arguments that don't have defaults must come before
(to the left of) those that do.

> And also when giving default-values to all arguments, omitting
> arguments when calling the method doesn't seem to be a succes:
>
> irb(main):001:0> class B
> irb(main):002:1> def b(c = 0, d = 1, e = 2)
> irb(main):003:2> puts c, d, e
> irb(main):004:2> end
> irb(main):005:1> end
> => nil
> irb(main):006:0> B.new.b(1,2,3)
> 1
> 2
> 3
> => nil
> irb(main):007:0> B.new.b(1,,3)
> SyntaxError: compile error
> (irb):7: syntax error
> B.new.b(1,,3)
> ^
> from (irb):7

Again, you can only leave out arguments that come after (to the right
of) those you provide.

> Is it impossible or I'm I just coding it wrong?

You just need to switch strategies. Use Ruby's simulated keyword
arguments for something like this:

>> def test(args)
>> puts args.values_at(:a, :b, :c)
>> end
=> nil
>> test :a => 1, :c => 2
1
nil
2
=> nil

Hope that helps.

James Edward Gray II

paul

12/6/2006 3:27:00 PM

0

> You just need to switch strategies. Use Ruby's simulated keyword
> arguments for something like this:
>
> >> def test(args)
> >> puts args.values_at(:a, :b, :c)
> >> end
> => nil
> >> test :a => 1, :c => 2
> 1
> nil
> 2
> => nil

Hi James,

The Simulated Keyword Arguments you talk about are a little abstract to
me, but I think I get the idea. I suppose in the example above I would
have to add a couple of lines to define the default values...
This way, the general idea is the same as the following?

irb(main):001:0> def test(args)
irb(main):002:1> args['a'] = 'defaultA' unless args.has_key?('a')
irb(main):003:1> args['b'] = 'defaultB' unless args.has_key?('b')
irb(main):004:1> args['c'] = 'defaultC' unless args.has_key?('c')
irb(main):005:1> puts args.indexes('a', 'b', 'c')
irb(main):006:1> end
=> nil
irb(main):007:0> test({'a' => 'someA', 'c' => 'someC'})
(irb):5: warning: Hash#indexes is deprecated; use Hash#values_at
someA
defaultB
someC
=> nil

An additional question: do you know a link where I can find more on
those Simulated Keyword Arguments? I did some googling, but it turned
up with nothing on:
ruby "Simulated Keyword Arguments"

Those colons you use before the variable-names are a little like magic
to me. (though I checked, without those colons, you're example above
wouldn't have worked...) :)

Cheers,
Paul

James Gray

12/6/2006 3:47:00 PM

0

On Dec 6, 2006, at 9:30 AM, paul wrote:

> The Simulated Keyword Arguments you talk about are a little
> abstract to
> me, but I think I get the idea.

My fault, I did not describe them very well. Here are the critical
bits of information:

If a method call ends with some arguments that look like a Hash
definition (using the fat arrows =>), Ruby collects those and passes
a single Hash to the method in their place. You can then work with
the Hash normally.

> irb(main):001:0> def test(args)
> irb(main):002:1> args['a'] = 'defaultA' unless args.has_key?('a')
> irb(main):003:1> args['b'] = 'defaultB' unless args.has_key?('b')
> irb(main):004:1> args['c'] = 'defaultC' unless args.has_key?('c')
> irb(main):005:1> puts args.indexes('a', 'b', 'c')
> irb(main):006:1> end
> => nil
> irb(main):007:0> test({'a' => 'someA', 'c' => 'someC'})
> (irb):5: warning: Hash#indexes is deprecated; use Hash#values_at
> someA
> defaultB
> someC
> => nil

Another way to set defaults:

>> def test(args)
>> args = { "a" => "default a",
?> "b" => "default b",
?> "c" => "default c" }.merge(args)
>> puts args.values_at("a", "b", "c")
>> end
=> nil
>> test "a" => "some a", "c" => "some c"
some a
default b
some c
=> nil

> An additional question: do you know a link where I can find more on
> those Simulated Keyword Arguments?

See Collecting Hash Arguments at the bottom of:

http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_me...

> Those colons you use before the variable-names are a little like magic
> to me. (though I checked, without those colons, you're example above
> wouldn't have worked...) :)

Those are just Symbol objects. Don't lose too much sleep over them
yet, as you can see from the new example Strings work fine too.

James Edward Gray II

Ken Bloom

12/6/2006 3:53:00 PM

0

On Wed, 06 Dec 2006 07:27:00 -0800, paul wrote:

>> You just need to switch strategies. Use Ruby's simulated keyword
>> arguments for something like this:
>>
>> >> def test(args)
>> >> puts args.values_at(:a, :b, :c)
>> >> end
>> => nil
>> >> test :a => 1, :c => 2
>> 1
>> nil
>> 2
>> => nil
> Hi James,
>
> The Simulated Keyword Arguments you talk about are a little abstract to
> me, but I think I get the idea. I suppose in the example above I would
> have to add a couple of lines to define the default values...
> This way, the general idea is the same as the following?
>
> irb(main):001:0> def test(args)
> irb(main):002:1> args['a'] = 'defaultA' unless args.has_key?('a')
> irb(main):003:1> args['b'] = 'defaultB' unless args.has_key?('b')
> irb(main):004:1> args['c'] = 'defaultC' unless args.has_key?('c')
> irb(main):005:1> puts args.indexes('a', 'b', 'c')
> irb(main):006:1> end
> => nil
> irb(main):007:0> test({'a' => 'someA', 'c' => 'someC'})
> (irb):5: warning: Hash#indexes is deprecated; use Hash#values_at
> someA
> defaultB
> someC
> => nil

Try this-- it's more concise, and you probably won't feel the need
for more syntactic magic after that.

def test(args)
args[:a] ||= 'defaultA'
args[:b] ||= 'defaultB'
args[:c] ||= 'defaultC'
puts args.indexes(:a, :b, :c)
end

>
> An additional question: do you know a link where I can find more on
> those Simulated Keyword Arguments? I did some googling, but it turned
> up with nothing on:
> ruby "Simulated Keyword Arguments"
>
> Those colons you use before the variable-names are a little like magic
> to me. (though I checked, without those colons, you're example above
> wouldn't have worked...) :)

The colons make them into symbol objects.

> Cheers,
> Paul




--
Ken Bloom. PhD candidate. Linguistic Cognition Laboratory.
Department of Computer Science. Illinois Institute of Technology.
http://www.iit.edu...

Ara.T.Howard

12/6/2006 5:12:00 PM

0

David Vallner

12/8/2006 8:22:00 AM

0

Ken Bloom wrote:
> Try this-- it's more concise, and you probably won't feel the need
> for more syntactic magic after that.
>
> def test(args)
> args[:a] ||= 'defaultA'
> args[:b] ||= 'defaultB'
> args[:c] ||= 'defaultC'
> puts args.indexes(:a, :b, :c)
> end
>

I find:

def test(args)
realargs = {:a => 'defaultA',
:b => 'defaultB',
:c => 'defaultC'}.update(args)

puts args.indexes(:a, :b, :c)
end

more readable. Preferrably extracting the default values into constants
before the method definition and (deep?)cloning the hash.

Also, your code clobbers the hash put into args by putting in values.
This might not cause bugs most of the case, but might in case someone
passes in an actual hash, so I'd just stay on the safe side.

David Vallner