Forum: Ruby Stupid question from a Ruby newb

Announcement (2017-05-07): www.ruby-forum.com is now read-only since I unfortunately do not have the time to support and maintain the forum any more. Please see rubyonrails.org/community and ruby-lang.org/en/community for other Rails- und Ruby-related community platforms.
9b7647d55df4584d7031130915556040?d=identicon&s=25 Will (Guest)
on 2006-01-11 05:33
(Received via mailing list)
Hi folks, I know that this is a really simple question, and there must
be many ways to do it in Ruby...  but what I'm looking for is an
elegant way to take a collection of objects and create a hash mapping
one attribute of the object as the key and the other as the value.  So
far what I am doing is this:

objects = some_method_to_return_collect( method_params )
myHash = Hash.new

@objects.each do |object|
  myHash[ object.key ] = object.value
end

I played around with doing something like:

@myHash = objects.map do |object| [ object.key => object.value ] end

But that returns an array of single-value hashes, which is not exactly
what I am trying to do.

I know this is a stupid question, and probably pointless because I do
know ways to do it, but I would really like the know the Ruby Way to do
this.  Ruby seems so given to elegant code that my code above really
bugs me for some reason.

Thanks all!

-Will
430ea1cba106cc65b7687d66e9df4f06?d=identicon&s=25 David Vallner (Guest)
on 2006-01-11 05:42
(Received via mailing list)
Will wrote:

>  myHash[ object.key ] = object.value
>know ways to do it, but I would really like the know the Ruby Way to do
>this.  Ruby seems so given to elegant code that my code above really
>bugs me for some reason.
>
>Thanks all!
>
>-Will
>
>
>
>
There are no stupid questions, only stupid people.

The solution you first wrote where you're iterating over the array is as
good as any, i would probably use that.

If you like Ever So Cool one-liners, this one might also work:

    myHash = objects.inject({}){|hash, item| hash[item.key] =
    item.value; hash}

It does pretty much completely the same, except were this Smalltalk, the
block wouldn't be a closure and therefore a horse's butthair more
memory-efficient solution.

David Vallner
1b62a85b59ccab03b84ee5ec378f75b4?d=identicon&s=25 Steve Litt (Guest)
on 2006-01-11 05:52
(Received via mailing list)
On Tuesday 10 January 2006 11:42 pm, David Vallner wrote:
[clip]
> There are no stupid questions, only stupid people.

I think what David means here is that failure to ask the question is
stupid :-)

SteveT

Steve Litt
http://www.troubleshooters.com
slitt@troubleshooters.com
430ea1cba106cc65b7687d66e9df4f06?d=identicon&s=25 David Vallner (Guest)
on 2006-01-11 05:58
(Received via mailing list)
Steve Litt wrote:

>
>SteveT
>
>Steve Litt
>http://www.troubleshooters.com
>slitt@troubleshooters.com
>
>
>
Oh, not quite, that was just a general random piece of Zen. (read: brain
fart).
But indeed -part- of the meaning was that you can't indeed ask stupid
questions. For given values of 'question' ;P

Green eggs and spam.

David Vallner
Shouldn't turn Thunderbird on when insomniac...
E7559e558ececa67c40f452483b9ac8c?d=identicon&s=25 unknown (Guest)
on 2006-01-11 06:04
(Received via mailing list)
On Jan 10, 2006, at 11:42 PM, David Vallner wrote:

> If you like Ever So Cool one-liners, this one might also work:
>
>    myHash = objects.inject({}){|hash, item| hash[item.key] =
>    item.value; hash}
>
> It does pretty much completely the same, except were this
> Smalltalk, the block wouldn't be a closure and therefore a horse's
> butthair more memory-efficient solution.
>

Is this because the Smalltalk compiler will notice that there are no
references to variables outside the block and Ruby's current
implementation
will not notice the same thing?


Gary Wright
Cb48ca5059faf7409a5ab3745a964696?d=identicon&s=25 unknown (Guest)
on 2006-01-11 06:34
(Received via mailing list)
On Wed, 11 Jan 2006, Will wrote:

>  myHash[ object.key ] = object.value
> know ways to do it, but I would really like the know the Ruby Way to do
> this.  Ruby seems so given to elegant code that my code above really
> bugs me for some reason.
>
> Thanks all!

   h = objects.inject({}){|h,o| h.update o.key => o.value}

-a
430ea1cba106cc65b7687d66e9df4f06?d=identicon&s=25 David Vallner (Guest)
on 2006-01-11 07:18
(Received via mailing list)
ara.t.howard@noaa.gov wrote:

>
>   h = objects.inject({}){|h,o| h.update o.key => o.value}
>
> -a

Oooh, Spiffy (tm) ;P Wish I thought of that. Possibly less efficient
though generating a lot of single-pair hashes that are instant garbage,
although it's all fun and games until someone runs a benchmark.

David Vallner
82e62c756d89bc6fa0a0a2d7f2b1e617?d=identicon&s=25 Ross Bamford (Guest)
on 2006-01-11 10:40
(Received via mailing list)
On Wed, 11 Jan 2006 04:31:52 -0000, Will <wrbriggs@gmail.com> wrote:

>   myHash[ object.key ] = object.value
> know ways to do it, but I would really like the know the Ruby Way to do
> this.  Ruby seems so given to elegant code that my code above really
> bugs me for some reason.
>

Stupid questions (i.e. the asking of) are my speciality these days ( :(
)
and this doesn't seem to be a particularly dumb  one to me :) You are
right though about a more elegant way to do it:

	h = Hash['blue', 34, 'red', 31, 'green', 32] 	# => {"green"=>32,
"blue"=>34, "red"=>31}

	a = [1, 'one', 2, 'two', 3, 'three']		# => [1, "one", 2, "two", 3,
"three"]
	h = Hash[*a]						# => {1=>"one", 2=>"two", 3=>"three"}

(Notice the * on the second form)

Cheers,
82e62c756d89bc6fa0a0a2d7f2b1e617?d=identicon&s=25 Ross Bamford (Guest)
on 2006-01-11 10:58
(Received via mailing list)
On Wed, 11 Jan 2006 09:23:04 -0000, Ross Bamford
<rosco@roscopeco.remove.co.uk> wrote:

>>
>>
>> I know this is a stupid question, and probably pointless because I do
>> know ways to do it, but I would really like the know the Ruby Way to do
>> this.  Ruby seems so given to elegant code that my code above really
>> bugs me for some reason.
>>
>
> Stupid questions (i.e. the asking of) are my speciality these days
> ( :( ) and this doesn't seem to be a particularly dumb  one to me :) You
> are right though about a more elegant way to do it:
>

Stupid answers, too. Seems I misread the question, sorry about that :(

(Sorry everyone for all this noise lately, I promise I'm going to start
enforcing a fifteen minute gap between writing and posting to try and
make
sure I'm not just spouting crap again).
430ea1cba106cc65b7687d66e9df4f06?d=identicon&s=25 David Vallner (Guest)
on 2006-01-11 16:31
(Received via mailing list)
gwtmp01@mac.com wrote:

>
> Is this because the Smalltalk compiler will notice that there are no
> references to variables outside the block and Ruby's current
> implementation
> will not notice the same thing?
>
>
> Gary Wright
>
Quite so, Smalltalk compilers could optimize blocks that obviously
didn't close upon the lexical environment by dropping part or all of the
lexical binding. There was a thread about procs being a potential memory
leak on the list that discussed this in Ruby, you might want to look at
the ML archives.

One of the arguments raised in the thread was that this optimization
isn't really in Ruby because of eval. When blocks are called, they have
to be (usually) executed in the lexical scope in which they were
defined. The same is true of eval. Unfortunately, it's harder to
determine what in the surrounding scope is referenced in an eval call
than in a block, since the code is parsed at runtime; also you can't
really determine when eval is called because of aliasing. Therefore
optimizing the blocks would very likely break the use of eval in them.

I don't know what conclusion the original discussion came to, I'd
personally like to see eval mildly deprecated in favor of the many
other, more explicit, and cleaner reflection capacities like #class_eval
and #define_method for code generation, discouraged for use in the
standard library, and optimizing the blocks as optional interpreter /
VM.

David Vallner
4b174722d1b1a4bbd9672e1ab50c30a9?d=identicon&s=25 Ryan Leavengood (Guest)
on 2006-01-11 20:44
(Received via mailing list)
On 1/10/06, Will <wrbriggs@gmail.com> wrote:
>
> @myHash = objects.map do |object| [ object.key => object.value ] end

You were on the right track with this one:

@myHash = Hash[*objects.map{|o| [o.key, o.value]}.flatten]

So we map the objects into array pairs of the key and value, flatten
the resulting array, and then use the "splat" operator (*) to turn
those into parameters to the Hash::[] method.

Ryan
This topic is locked and can not be replied to.