Passing keyword arguments

[transfire]

Lets say I have a method using the not-so-uncommon keyword options
pattern:

def foo(*args)
opts = (Hash === args.last ? args.pop : {})
...

Now I want to define another method, which is essentially a special
alias, that places a particular option as the first argument:

def bar(opt, *args)
foo(*args, :baz => opt) # doesn't work.
end

Is there no better way to do this than:

def bar(opt, *args)
opts = (Hash === args.last ? args.pop : {})
opts[:baz] = opt
args << opts
foo(*args)
end

Boy, it really makes you wish we had keyword arguments built-in to the
language!!! I forget, will we have those in 1.9? If so how the above
look then?

T.

 

[robert.dober]

Lets say I have a method using the not-so-uncommon keyword options
pattern:

def foo(*args)
opts = (Hash === args.last ? args.pop : {})

Hi Tom

irb(main):001:0> def foo *args
irb(main):002:1> opts, args = args.partition{|x| Hash === x }
irb(main):003:1> opts = opts.inject{ |s,x| s.update x }

seems this should do the trick

...

Now I want to define another method, which is essentially a special
alias, that places a particular option as the first argument:

def bar(opt, *args)
foo(*args, :baz => opt) # doesn't work.

now it does , almost
foo( :baz => opt, *args)

HTH
Robert

end

Is there no better way to do this than:

def bar(opt, *args)
opts = (Hash === args.last ? args.pop : {})
opts[:baz] = opt
args << opts
foo(*args)
end

Boy, it really makes you wish we had keyword arguments built-in to the
language!!! I forget, will we have those in 1.9? If so how the above
look then?

Yes indeed I wished for them for a long time
R.

 

[transfire]

Hi Tom

irb(main):001:0> def foo *args
irb(main):002:1> opts, args = args.partition{|x| Hash === x }
irb(main):003:1> opts = opts.inject{ |s,x| s.update x }

seems this should do the trick




now it does , almost
foo( :baz => opt, *args)

Interesting approach. Thanks.

T.

 

[bbxx789_05ss]

Hi Tom

irb(main):001:0> def foo *args
irb(main):002:1> opts, args = args.partition{|x| Hash === x }
irb(main):003:1> opts = opts.inject{ |s,x| s.update x }

seems this should do the trick

Why not simply:

def foo(*args)
opts = args[0]
args = args[1..-1]

p opts, args
end

def bar(opt, *args)
foobaz =>opt, *args)
puts
foobaz =>opt, ther => 'pie', *args)
end

bar(10, 20, 30)


--output:--
{:baz=>10}
[20, 30]

{:baz=>10, ther=>"pie"}
[20, 30]

 

[Brian Adkins]

Lets say I have a method using the not-so-uncommon keyword options
pattern:

def foo(*args)
opts = (Hash === args.last ? args.pop : {})
...

Now I want to define another method, which is essentially a special
alias, that places a particular option as the first argument:

def bar(opt, *args)
foo(*args, :baz => opt) # doesn't work.
end

Is there no better way to do this than:

def bar(opt, *args)
opts = (Hash === args.last ? args.pop : {})
opts[:baz] = opt
args << opts
foo(*args)
end

Boy, it really makes you wish we had keyword arguments built-in to the
language!!! I forget, will we have those in 1.9? If so how the above
look then?

How flexible do you need to be with the argument handling? Would
something like the following work?

def foo a, b='default', opts={}
puts "a is #{a}, b is #{b}"
opts.each {|k,v| puts "#{k} => #{v}"}
puts '-'*10
end

def bar opt, a, b='default2', opts={}
foo a, b, opts.merge!({:baz => opt})
end

foo 1
foo 2, 'foo'
foo 3, 'foo', pt1 => 'one', pt2 => 'two'
bar 'extra', 4
bar 'extra', 5, 'bar', pt1 => 'one', pt2 => 'two'

Brian Adkins

 

[robert.dober]

Hi Tom

irb(main):001:0> def foo *args
irb(main):002:1> opts, args = args.partition{|x| Hash === x }
irb(main):003:1> opts = opts.inject{ |s,x| s.update x }

seems this should do the trick

Why not simply:

def foo(*args)
opts = args[0]
args = args[1..-1]

p opts, args
end

def bar(opt, *args)
foobaz =>opt, *args)
puts
foobaz =>opt, ther => 'pie', *args)
end

bar(10, 20, 30)


--output:--
{:baz=>10}
[20, 30]

{:baz=>10, ther=>"pie"}
[20, 30]

because it does not work, try
bar( 1, 2, 3, :a=> 42)
And putting kw params before positionals is too unusual to be likely
to be used a lot
my solution is ugly because you have to exactly that but it is at
least hidden from the users of foo and bar.

R.

 

[transfire]

How flexible do you need to be with the argument handling? Would
something like the following work?

def foo a, b='default', opts={}
puts "a is #{a}, b is #{b}"
opts.each {|k,v| puts "#{k} => #{v}"}
puts '-'*10
end

def bar opt, a, b='default2', opts={}
foo a, b, opts.merge!({:baz => opt})
end

Problem is I need *args (an untold amount).

T.