Passing keyword arguments

ruby-talk
1

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.

2

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 :wink:
R.

···

On Nov 3, 2007 1:27 AM, Trans <transfire@gmail.com> wrote:
--
what do I think about Ruby?
http://ruby-smalltalk.blogspot.com/

3

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', :opt1 => 'one', :opt2 => 'two'
bar 'extra', 4
bar 'extra', 5, 'bar', :opt1 => 'one', :opt2 => 'two'

Brian Adkins

···

On Nov 2, 8:27 pm, transf...@gmail.com wrote:

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?

4

Interesting approach. Thanks.

T.

···

On Nov 3, 4:47 am, "Robert Dober" <robert.do...@gmail.com> wrote:

On Nov 3, 2007 1:27 AM, Trans <transf...@gmail.com> wrote:

> 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)

5

Robert Dober wrote:

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

    ...

Why not simply:

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

  p opts, args
end

def bar(opt, *args)
  foo(:baz =>opt, *args)
  puts
  foo(:baz =>opt, :other => 'pie', *args)
end

bar(10, 20, 30)

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

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

···

On Nov 3, 2007 1:27 AM, Trans <transfire@gmail.com> wrote:

--
Posted via http://www.ruby-forum.com/.

6

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

T.

···

On Nov 3, 8:50 pm, Brian Adkins <lojicdot...@gmail.com> wrote:

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

7

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 :frowning:
my solution is ugly because you have to exactly that but it is at
least hidden from the users of foo and bar.

R.

···

On Nov 4, 2007 1:12 AM, 7stud -- <bbxx789_05ss@yahoo.com> wrote:

Robert Dober wrote:
> On Nov 3, 2007 1:27 AM, Trans <transfire@gmail.com> wrote:
>> 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
>> ...

Why not simply:

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

  p opts, args
end

def bar(opt, *args)
  foo(:baz =>opt, *args)
  puts
  foo(:baz =>opt, :other => 'pie', *args)
end

bar(10, 20, 30)

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

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

--
what do I think about Ruby?
http://ruby-smalltalk.blogspot.com/