Keyword parameters

[Glenn]

[Note: parts of this message were removed to make it a legal post.]

Hi everyone,

I have a question about keyword parameters in Ruby. I know that v1.8.6 doesn't do this and v1.9 does, and that you can 'trick' v1.8.6 into doing it with hashes.

My question is whether you can do this code:

def aProc(options = {})
a = options[:a] || 5
b = options[:b] || 6
c = options[:c] || 7
print a, b, c
end

in such a way where you wouldn't have to explicitly say that the local variable a is equal to the value in the hash with symbol :a? In other words, to do something like iterate through the hash and turn all of the symbol keys into local variable with their respective values?

Thanks,

Glenn


----- Original Message ----
From: Jason Roelofs <[email protected]>
To: ruby-talk ML <[email protected]>
Sent: Monday, March 3, 2008 4:36:49 PM
Subject: Re: Why is this not implemented in Ruby

Show me a language that does allow you to do this, I've never seen it.
Even then, Ruby doesn't deal with method overloads via parameter
lists, so there's a fundamental reason why it won't work:

def foo(a)
end

def foo(a, b)
end

def foo(a, b, c)
end

foo(1) # => ArgumentError: wrong number of arguments (1 for 3)


Ruby 1.9 has keyword arguments, so you'll be able to get past that
easily then. You can fake it in 1.8 with a hash:

def aProc(options = {})
a = options[:a] || 5
b = options[:b] || 6
c = options[:c] || 7
print a, b, c
end

aProca => 1, :c => 3)

With Ruby 1.9 that will look like (I think, doing this from memory):

aProc(a: 1, c: 3)

Jason

 

[Mikael Høilund]

[T]o do something like iterate through the hash and turn all of the =20=

symbol keys into local variable with their respective values?

No.
What you *can* do, however, is to simply refer to each of these =20
options directly in the hash, making the hash values default instead. =20=

The na=EFve way:

options[:a] ||=3D 5
...

However, a more preferable way, however, is defining a hash with the =20
default, and then letting the options hash override these:

options =3D {:a =3D> 5, ...}.merge(options)

You can then access each option as option[:a] .... There are a few =20
caveat with this, but these aren't usually a problem.

--=20
Mikael H=F8ilund
http://hoilund.org/

 

[fedzor]

What makes an *actual* keyword argument, and why don't symbols suffice?


---------------------------------------------------------------|
~Ari
"I don't suffer from insanity. I enjoy every minute of it" --1337est
man alive