experchange > ruby

dreamer (07-08-19, 05:24 PM)
Hi all,
I'm new to ruby and trying to understand this bit of code:

hash.update(hash) { |key, value| value * 2}

In particular what is the meaning of the value * 2?

When I tried using IRB to multiply values in a hash, either
I received an error or it multiplied the values and gave me
the product.

Any insights would be greatly appreciated. Thank you.

--
Doc O'Leary (07-14-19, 05:44 PM)
For your reference, records indicate that
dreamer <dreamer> wrote:

> hash.update(hash) { |key, value| value * 2}
> In particular what is the meaning of the value * 2?


It means the same thing it would mean anywhere else: multiply the contents
of the “value” variable by 2. Is it really blocks that have you confused,
or the use of the update method? For newer versions of Ruby, the other
choice to do the same operation would be the transform_values! method.

> When I tried using IRB to multiply values in a hash, either
> I received an error or it multiplied the values and gave me
> the product.


You show no examples, errors or otherwise. The line you posted should do
what I *think* you want, but you many need to explain your intent more
completely.
dreamer (07-16-19, 05:27 PM)
Doc O'Leary <droleary> wrote:
> For your reference, records indicate that
> dreamer <dreamer> wrote:
> It means the same thing it would mean anywhere else: multiply the contents
> of the “value” variable by 2. Is it really blocks that have you confused,
> or the use of the update method? For newer versions of Ruby, the other
> choice to do the same operation would be the transform_values! method.
> You show no examples, errors or otherwise. The line you posted should do
> what I *think* you want, but you many need to explain your intent more
> completely.


Sorry, that was bad netiquette on my part. I sometimes get focused on my
own thoughts and understanding and don't speak (or write) in a way that fully
explains the situation to an outside observer.

Here is an example I found on stackoverflow ()

h = { 1 => 10, 2 => 20, 5 => 70, 8 =>90, 4 => 34 }

which the writer would like to change to:

h = { 1 => foo(10), 2 => foo(20), 5 => foo(70), 8 => foo(90), 4 => foo(34) }

and the "best" answer was the line above:

hash.update(hash) { |key, value| value * 2 }

My confusion was really about the "value * 2", the answer's author wrote:

"Note that we're effectively merging hash with itself. This is
needed because Ruby will call the block to resolve the merge
for any keys that collide, setting the value with the return
value of the block."

I was wondering why this would be better/different than just doing an
update to the hash and key. And what is meant by 'resolving the merge
for any keys that collide'.

I was confused about blocks AND how to use the update method, but
this bit had me doubly confused.

Now that I've had time to step and back and think about it, I may just
be overthinking and this bit of code could be meaningless, in a sense.

--
Doc O'Leary (07-16-19, 09:44 PM)
For your reference, records indicate that
dreamer <dreamer> wrote:

> Here is an example I found on stackoverflow ()
> h = { 1 => 10, 2 => 20, 5 => 70, 8 =>90, 4 => 34 }
> which the writer would like to change to:
> h = { 1 => foo(10), 2 => foo(20), 5 => foo(70), 8 => foo(90), 4 => foo(34) }
> and the "best" answer was the line above:
> hash.update(hash) { |key, value| value * 2 }
> My confusion was really about the "value * 2"


Well, in that case the answer did confuse the issue a bit by giving that
instead of “foo(value)” to correspond with the question.

> "Note that we're effectively merging hash with itself. This is
> needed because Ruby will call the block to resolve the merge
> for any keys that collide, setting the value with the return
> value of the block."
> I was wondering why this would be better/different than just doing an
> update to the hash and key.


By doing what instead? You certain *could* just iterate through using an
enumerator, making assignments explicitly. But using a block with the
update method is a much more convenient way to accomplish the task (and
generally why so many generic Enumerable methods accept blocks).

> And what is meant by 'resolving the merge
> for any keys that collide'.


That’s just the way the update method works. Its “normal” use is to merge
two different hashes, and the block is only run to resolve the case where
there are keys that exist in both. But used against itself, *all* entries
will match, and thus be changed by the code in the given block.
dreamer (07-18-19, 01:21 AM)
Doc O'Leary <droleary> wrote:
> For your reference, records indicate that
> dreamer <dreamer> wrote:
> That’s just the way the update method works. Its “normal” use is to merge
> two different hashes, and the block is only run to resolve the case where
> there are keys that exist in both. But used against itself, *all* entries
> will match, and thus be changed by the code in the given block.


Thank you for the clarification. I appreciate you taking the time to
respond and give me a better understanding of this. I'm finding Ruby
intuitive and, may I say, "fun" :)

..------------------( Danny Lee <dreamer> )------------------.
I have been impressed with the urgency of doing. Knowing is not enough;
we must apply. Being willing is not enough; we must do.
~ Leonardo da Vinci