[lnkForumImage]
TotalShareware - Download Free Software

Confronta i prezzi di migliaia di prodotti.
Asp Forum
 Home | Login | Register | Search 


 

Forums >

comp.lang.ruby

Functional Equivalency

tom.mancino

10/25/2006 12:47:00 PM

This works for multiple keywords:

res = adwords.estimateKeywordList([AdWords::KeywordRequest.new(nil,
1000000, false, 'test', 'Broad'), AdWords::KeywordRequest.new(nil,
1000000, false, 'student', 'Broad')])

This doesn't:

keywords = ['test','student']
res = adwords.estimateKeywordList([keywords.map! {|x|
AdWords::KeywordRequest.new(nil, 1000000, false, x, 'Broad')} ])

Aren't these statements functionaly equivilant, or have I missed
something (probably!).....this may be an api problem as well.

7 Answers

dblack

10/25/2006 12:53:00 PM

0

Rick DeNatale

10/25/2006 2:04:00 PM

0

On 10/25/06, dblack@wobblini.net <dblack@wobblini.net> wrote:
> Hi --
>
> On Wed, 25 Oct 2006, tom.mancino wrote:
>
> > This works for multiple keywords:
> >
> > res = adwords.estimateKeywordList([AdWords::KeywordRequest.new(nil,
> > 1000000, false, 'test', 'Broad'), AdWords::KeywordRequest.new(nil,
> > 1000000, false, 'student', 'Broad')])
> >
> > This doesn't:
> >
> > keywords = ['test','student']
> > res = adwords.estimateKeywordList([keywords.map! {|x|
> > AdWords::KeywordRequest.new(nil, 1000000, false, x, 'Broad')} ])
> >
> > Aren't these statements functionaly equivilant, or have I missed
> > something (probably!).....this may be an api problem as well.
>
> map! returns an array -- so in the second example, you've got an array
> inside an array.

I don't think so. They should be equivalent. Here's a simplification
of the OPs use case, with a dummy KeywordRequest class and JUST the
expression for the argument:

rick@frodo:/public/rubyscripts$ cat kwl.rb
class KeywordRequest
def initialize(kwd)
@kwd = kwd
end

def inspect
"KWR(#{@kwd})"
end

end

puts "With array literal"
p [KeywordRequest.new('test'), KeywordRequest.new('student')]

keywords = ['test', 'student']
puts "With map"
puts "result=#{keywords.map {|x| KeywordRequest.new(x)}.inspect}"
puts "keywords=#{keywords.inspect}"
puts "with map!"
puts "result=#{keywords.map! {|x| KeywordRequest.new(x)}.inspect}"
puts "keywords=#{keywords.inspect}"


rick@frodo:/public/rubyscripts$ ruby kwl.rb
With array literal
[KWR(test), KWR(student)]
With map
result=[KWR(test), KWR(student)]
keywords=["test", "student"]
with map!
result=[KWR(test), KWR(student)]
keywords=[KWR(test), KWR(student)]

Both forms return a single level array of KeywordRequests.

It is probably better to use :map instead of :map! unless he WANTS to
clobber the array of keywords.


--
Rick DeNatale

My blog on Ruby
http://talklikeaduck.denh...

Justin Collins

10/25/2006 5:51:00 PM

0

Rick DeNatale wrote:

> On 10/25/06, dblack@wobblini.net <dblack@wobblini.net> wrote:
>
>> Hi --
>>
>> On Wed, 25 Oct 2006, tom.mancino wrote:
>>
>> > This works for multiple keywords:
>> >
>> > res = adwords.estimateKeywordList([AdWords::KeywordRequest.new(nil,
>> > 1000000, false, 'test', 'Broad'), AdWords::KeywordRequest.new(nil,
>> > 1000000, false, 'student', 'Broad')])
>> >
>> > This doesn't:
>> >
>> > keywords = ['test','student']
>> > res = adwords.estimateKeywordList([keywords.map! {|x|
>> > AdWords::KeywordRequest.new(nil, 1000000, false, x, 'Broad')} ])
>> >
>> > Aren't these statements functionaly equivilant, or have I missed
>> > something (probably!).....this may be an api problem as well.
>>
>> map! returns an array -- so in the second example, you've got an array
>> inside an array.
>
>
> I don't think so. They should be equivalent. Here's a simplification
> of the OPs use case, with a dummy KeywordRequest class and JUST the
> expression for the argument:
>
> rick@frodo:/public/rubyscripts$ cat kwl.rb
> class KeywordRequest
> def initialize(kwd)
> @kwd = kwd
> end
>
> def inspect
> "KWR(#{@kwd})"
> end
>
> end
>
> puts "With array literal"
> p [KeywordRequest.new('test'), KeywordRequest.new('student')]
>
> keywords = ['test', 'student']
> puts "With map"
> puts "result=#{keywords.map {|x| KeywordRequest.new(x)}.inspect}"
> puts "keywords=#{keywords.inspect}"
> puts "with map!"
> puts "result=#{keywords.map! {|x| KeywordRequest.new(x)}.inspect}"
> puts "keywords=#{keywords.inspect}"
>
>
> rick@frodo:/public/rubyscripts$ ruby kwl.rb
> With array literal
> [KWR(test), KWR(student)]
> With map
> result=[KWR(test), KWR(student)]
> keywords=["test", "student"]
> with map!
> result=[KWR(test), KWR(student)]
> keywords=[KWR(test), KWR(student)]
>
> Both forms return a single level array of KeywordRequests.
>
> It is probably better to use :map instead of :map! unless he WANTS to
> clobber the array of keywords.
>
>

The point wasn't that map and map! are different - it's that the OP
takes the result from map! and puts it inside an array (note the square
brackets):

res = adwords.estimateKeywordList([keywords.map! {|x| AdWords::KeywordRequest.new(nil, 1000000, false, x, 'Broad')} ])

Which makes it an array within an array.

With the first form, it's a flat array:

res = adwords.estimateKeywordList([AdWords::KeywordRequest.new(nil, 1000000, false, 'test', 'Broad'), AdWords::KeywordRequest.new(nil, 1000000, false, 'student', 'Broad')])

The difference is probably why the second form is failing.


-Justin


tom.mancino

10/25/2006 10:03:00 PM

0

Justin,

I believe you must be correct, as it does produce different results.
Any idea on how you would build a flat array that can take a variable
in this situation?


Rick and David, thanks for any help as well.

Tommy
Ruby Noob

On Oct 25, 12:50 pm, Justin Collins <colli...@seattleu.edu> wrote:
> Rick DeNatale wrote:
> > On 10/25/06, dbl...@wobblini.net <dbl...@wobblini.net> wrote:
>
> >> Hi --
>
> >> On Wed, 25 Oct 2006, tom.mancinowrote:
>
> >> > This works for multiple keywords:
>
> >> > res = adwords.estimateKeywordList([AdWords::KeywordRequest.new(nil,
> >> > 1000000, false, 'test', 'Broad'), AdWords::KeywordRequest.new(nil,
> >> > 1000000, false, 'student', 'Broad')])
>
> >> > This doesn't:
>
> >> > keywords = ['test','student']
> >> > res = adwords.estimateKeywordList([keywords.map! {|x|
> >> > AdWords::KeywordRequest.new(nil, 1000000, false, x, 'Broad')} ])
>
> >> > Aren't these statements functionaly equivilant, or have I missed
> >> > something (probably!).....this may be an api problem as well.
>
> >> map! returns an array -- so in the second example, you've got an array
> >> inside an array.
>
> > I don't think so. They should be equivalent. Here's a simplification
> > of the OPs use case, with a dummy KeywordRequest class and JUST the
> > expression for the argument:
>
> > rick@frodo:/public/rubyscripts$ cat kwl.rb
> > class KeywordRequest
> > def initialize(kwd)
> > @kwd = kwd
> > end
>
> > def inspect
> > "KWR(#{@kwd})"
> > end
>
> > end
>
> > puts "With array literal"
> > p [KeywordRequest.new('test'), KeywordRequest.new('student')]
>
> > keywords = ['test', 'student']
> > puts "With map"
> > puts "result=#{keywords.map {|x| KeywordRequest.new(x)}.inspect}"
> > puts "keywords=#{keywords.inspect}"
> > puts "with map!"
> > puts "result=#{keywords.map! {|x| KeywordRequest.new(x)}.inspect}"
> > puts "keywords=#{keywords.inspect}"
>
> > rick@frodo:/public/rubyscripts$ ruby kwl.rb
> > With array literal
> > [KWR(test), KWR(student)]
> > With map
> > result=[KWR(test), KWR(student)]
> > keywords=["test", "student"]
> > with map!
> > result=[KWR(test), KWR(student)]
> > keywords=[KWR(test), KWR(student)]
>
> > Both forms return a single level array of KeywordRequests.
>
> > It is probably better to use :map instead of :map! unless he WANTS to
> > clobber the array of keywords.The point wasn't that map and map! are different - it's that the OP
> takes the result from map! and puts it inside an array (note the square
> brackets):
>
> res = adwords.estimateKeywordList([keywords.map! {|x| AdWords::KeywordRequest.new(nil, 1000000, false, x, 'Broad')} ])
>
> Which makes it an array within an array.
>
> With the first form, it's a flat array:
>
> res = adwords.estimateKeywordList([AdWords::KeywordRequest.new(nil, 1000000, false, 'test', 'Broad'), AdWords::KeywordRequest.new(nil, 1000000, false, 'student', 'Broad')])
>
> The difference is probably why the second form is failing.
>
> -Justin

dblack

10/25/2006 10:09:00 PM

0

tom.mancino

10/25/2006 10:22:00 PM

0

Worked like a champ, thanks. I really like this language!

On Oct 25, 5:09 pm, dbl...@wobblini.net wrote:
> Hi --
>
>
>
> On Thu, 26 Oct 2006, tom.mancino wrote:
>
> > On Oct 25, 12:50 pm, Justin Collins <colli...@seattleu.edu> wrote:
> >> Rick DeNatale wrote:
> >>> On 10/25/06, dbl...@wobblini.net <dbl...@wobblini.net> wrote:
>
> >>>> Hi --
>
> >>>> On Wed, 25 Oct 2006, tom.mancinowrote:
>
> >>>>> This works for multiple keywords:
>
> >>>>> res = adwords.estimateKeywordList([AdWords::KeywordRequest.new(nil,
> >>>>> 1000000, false, 'test', 'Broad'), AdWords::KeywordRequest.new(nil,
> >>>>> 1000000, false, 'student', 'Broad')])
>
> >>>>> This doesn't:
>
> >>>>> keywords = ['test','student']
> >>>>> res = adwords.estimateKeywordList([keywords.map! {|x|
> >>>>> AdWords::KeywordRequest.new(nil, 1000000, false, x, 'Broad')} ])
>
> >>>>> Aren't these statements functionaly equivilant, or have I missed
> >>>>> something (probably!).....this may be an api problem as well.
>
> >>>> map! returns an array -- so in the second example, you've got an array
> >>>> inside an array.
>
> >>> I don't think so. They should be equivalent. Here's a simplification
> >>> of the OPs use case, with a dummy KeywordRequest class and JUST the
> >>> expression for the argument:
>
> >>> rick@frodo:/public/rubyscripts$ cat kwl.rb
> >>> class KeywordRequest
> >>> def initialize(kwd)
> >>> @kwd = kwd
> >>> end
>
> >>> def inspect
> >>> "KWR(#{@kwd})"
> >>> end
>
> >>> end
>
> >>> puts "With array literal"
> >>> p [KeywordRequest.new('test'), KeywordRequest.new('student')]
>
> >>> keywords = ['test', 'student']
> >>> puts "With map"
> >>> puts "result=#{keywords.map {|x| KeywordRequest.new(x)}.inspect}"
> >>> puts "keywords=#{keywords.inspect}"
> >>> puts "with map!"
> >>> puts "result=#{keywords.map! {|x| KeywordRequest.new(x)}.inspect}"
> >>> puts "keywords=#{keywords.inspect}"
>
> >>> rick@frodo:/public/rubyscripts$ ruby kwl.rb
> >>> With array literal
> >>> [KWR(test), KWR(student)]
> >>> With map
> >>> result=[KWR(test), KWR(student)]
> >>> keywords=["test", "student"]
> >>> with map!
> >>> result=[KWR(test), KWR(student)]
> >>> keywords=[KWR(test), KWR(student)]
>
> >>> Both forms return a single level array of KeywordRequests.
>
> >>> It is probably better to use :map instead of :map! unless he WANTS to
> >>> clobber the array of keywords.The point wasn't that map and map! are different - it's that the OP
> >> takes the result from map! and puts it inside an array (note the square
> >> brackets):
>
> >> res = adwords.estimateKeywordList([keywords.map! {|x| AdWords::KeywordRequest.new(nil, 1000000, false, x, 'Broad')} ])
>
> >> Which makes it an array within an array.
>
> >> With the first form, it's a flat array:
>
> >> res = adwords.estimateKeywordList([AdWords::KeywordRequest.new(nil, 1000000, false, 'test', 'Broad'), AdWords::KeywordRequest.new(nil, 1000000, false, 'student', 'Broad')])
>
> >> The difference is probably why the second form is failing.
>
> >> -Justin
> > Justin,
>
> > I believe you must be correct, as it does produce different results.
> > Any idea on how you would build a flat array that can take a variable
> > in this situation?I'm not sure what you mean by 'take a variable', but try just using
> map (or map!) without wrapping it in ann array:
>
> res = adwords.estimateKeywordList(keywords.map! {|x| AdWords::KeywordRequest.new(nil, 1000000, false, x, 'Broad')})
>
> (Note lack of square brackets.)
>
> David
>
> --
> David A. Black | dbl...@wobblini.net
> Author of "Ruby for Rails" [1] | Ruby/Rails training & consultancy [3]
> DABlog (DAB's Weblog) [2] | Co-director, Ruby Central, Inc. [4]
> [1]http://www.manning...| [3]http://www.rubypoweran...
> [2]http://dablog.r... | [4]http://www.rubyc...

Rick DeNatale

10/25/2006 11:32:00 PM

0

On 10/25/06, Justin Collins <collinsj@seattleu.edu> wrote:
> Rick DeNatale wrote:
>
> > On 10/25/06, dblack@wobblini.net <dblack@wobblini.net> wrote:
> >
> >> Hi --
> >>
> >> On Wed, 25 Oct 2006, tom.mancino wrote:
> >>
> >> > This works for multiple keywords:
> >> >
> >> > res = adwords.estimateKeywordList([AdWords::KeywordRequest.new(nil,
> >> > 1000000, false, 'test', 'Broad'), AdWords::KeywordRequest.new(nil,
> >> > 1000000, false, 'student', 'Broad')])
> >> >
> >> > This doesn't:
> >> >
> >> > keywords = ['test','student']
> >> > res = adwords.estimateKeywordList([keywords.map! {|x|
> >> > AdWords::KeywordRequest.new(nil, 1000000, false, x, 'Broad')} ])
> >> >
> >> > Aren't these statements functionaly equivilant, or have I missed
> >> > something (probably!).....this may be an api problem as well.
> >>
> >> map! returns an array -- so in the second example, you've got an array
> >> inside an array.
> >
> >
> > I don't think so. They should be equivalent. Here's a simplification
> > of the OPs use case, with a dummy KeywordRequest class and JUST the
> > expression for the argument:
> >
> > rick@frodo:/public/rubyscripts$ cat kwl.rb
> > class KeywordRequest
> > def initialize(kwd)
> > @kwd = kwd
> > end
> >
> > def inspect
> > "KWR(#{@kwd})"
> > end
> >
> > end
> >
> > puts "With array literal"
> > p [KeywordRequest.new('test'), KeywordRequest.new('student')]
> >
> > keywords = ['test', 'student']
> > puts "With map"
> > puts "result=#{keywords.map {|x| KeywordRequest.new(x)}.inspect}"
> > puts "keywords=#{keywords.inspect}"
> > puts "with map!"
> > puts "result=#{keywords.map! {|x| KeywordRequest.new(x)}.inspect}"
> > puts "keywords=#{keywords.inspect}"
> >
> >
> > rick@frodo:/public/rubyscripts$ ruby kwl.rb
> > With array literal
> > [KWR(test), KWR(student)]
> > With map
> > result=[KWR(test), KWR(student)]
> > keywords=["test", "student"]
> > with map!
> > result=[KWR(test), KWR(student)]
> > keywords=[KWR(test), KWR(student)]
> >
> > Both forms return a single level array of KeywordRequests.
> >
> > It is probably better to use :map instead of :map! unless he WANTS to
> > clobber the array of keywords.
> >
> >
>
> The point wasn't that map and map! are different - it's that the OP
> takes the result from map! and puts it inside an array (note the square
> brackets):
>
> res = adwords.estimateKeywordList([keywords.map! {|x| AdWords::KeywordRequest.new(nil, 1000000, false, x, 'Broad')} ])

Darn, I KNEW it was time to get these glasses checked! <G>

--
Rick