Passing keyword arguments

Discussion in 'Ruby' started by transfire@gmail.com, Nov 3, 2007.

  1. Guest

    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.
     
    , Nov 3, 2007
    #1
    1. Advertising

  2. Guest

    On Nov 3, 2007 1:27 AM, Trans <> 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)

    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.
    --
    what do I think about Ruby?
    http://ruby-smalltalk.blogspot.com/
     
    , Nov 3, 2007
    #2
    1. Advertising

  3. Guest

    On Nov 3, 4:47 am, "Robert Dober" <> wrote:
    > On Nov 3, 2007 1:27 AM, Trans <> 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)


    Interesting approach. Thanks.

    T.
     
    , Nov 3, 2007
    #3
  4. Guest

    Robert Dober wrote:
    > On Nov 3, 2007 1:27 AM, Trans <> 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, :eek:ther => 'pie', *args)
    end

    bar(10, 20, 30)


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

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

    --
    Posted via http://www.ruby-forum.com/.
     
    , Nov 4, 2007
    #4
  5. Brian Adkins Guest

    On Nov 2, 8:27 pm, 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?


    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', :eek:pt1 => 'one', :eek:pt2 => 'two'
    bar 'extra', 4
    bar 'extra', 5, 'bar', :eek:pt1 => 'one', :eek:pt2 => 'two'

    Brian Adkins
     
    Brian Adkins, Nov 4, 2007
    #5
  6. Guest

    On Nov 4, 2007 1:12 AM, 7stud -- <> wrote:
    > Robert Dober wrote:
    > > On Nov 3, 2007 1:27 AM, Trans <> 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, :eek:ther => 'pie', *args)
    > end
    >
    > bar(10, 20, 30)
    >
    >
    > --output:--
    > {:baz=>10}
    > [20, 30]
    >
    > {:baz=>10, :eek: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.


    --
    what do I think about Ruby?
    http://ruby-smalltalk.blogspot.com/
     
    , Nov 4, 2007
    #6
  7. Guest

    On Nov 3, 8:50 pm, Brian Adkins <> 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


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

    T.
     
    , Nov 4, 2007
    #7
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. Edward Diener
    Replies:
    14
    Views:
    5,126
    Josiah Carlson
    Apr 6, 2004
  2. Replies:
    6
    Views:
    491
    Peter Otten
    May 10, 2007
  3. Peter Motzfeldt
    Replies:
    1
    Views:
    176
  4. oldyork90
    Replies:
    10
    Views:
    373
    Jorge
    Sep 27, 2008
  5. Andrey Fedorov
    Replies:
    7
    Views:
    103
    Thomas 'PointedEars' Lahn
    Dec 11, 2008
Loading...

Share This Page