Re: How to assign an element to a hash only if its value is not nil?

On Fri, Mar 4, 2011 at 3:20 PM, Mike Moore <[e-mail]> wrote:
> On Fri, Mar 4, 2011 at 3:05 AM, Robert Klemme
> <[e-mail]> wrote:
>> If you want to clearly communicate the intent you can add a comment or
>> an assert statement to that effect. =A0First inserting something that is
>> removed later is totally backwards.
>
> I'm sure there are cases where removing values from a hash is appropriate=
.
Yes, but I think one of Robert Klemme's points was why put values into
a hash only to remove them immediately.

>> Plus, you might remove more than intended,
>> e.g. if there are nil values inserted previously and you
>> only want to avoid inserting nils during _this_ method call.
>
> In that case where you don't want to remove all nil values from a hash
> you shouldn't call `delete_if { |k, v| v.nil? }`
Which rather proves Robert Klemme's point?

>> So, you proposed solution is less efficient and error prone.
>> Now how is that beautiful?
> Ouch. So its ugly *AND* buggy...
I'll avoid the beautiful/ugly debate. (I have some sympathy with
Dirac's views on the necessity of "beauty" in theories, but at the end
of the day I'll usually go with whatever overall works best, even if
it looks "ugly".)

> =A0# Check for nil values on hash assignment
> =A0# Assuming false is a valid value
> =A0h =A0 =A0 =A0 =A0 =3D {}
> =A0h[:one] =A0 =3D one if !one.nil? # local method
> =A0h[:two] =A0 =3D some_obj.two_method if !some_obj.two_method.nil?
> =A0tmp =A0 =A0 =A0 =3D expensive_format_three(some_obj, some_other_obj)
> =A0h[:three] =3D tmp if !tmp.nil?
> =A0h
>
> =A0# Delete nil values after hash assignment
> =A0h =3D {
> =A0 =A0 =A0 =A0:one =A0 =3D> one, # local method
> =A0 =A0 =A0 =A0:two =A0 =3D> some_obj.two_method,
> =A0 =A0 =A0 =A0:three =3D> expensive_format_three(some_obj, some_other_ob=
j)
> =A0 =A0 =A0}.delete_if { |k, v| v.nil? }

I'm not sure what that code does, but taking what the OP wanted to do
as the starting point.
> hash =3D {}
>    hash[:key] =3D myvalue
> How to assign hash[:key] only if myvalue is not nil?
> Current solution is:
>    hash[:key] =3D myvalue unless myvalue.nil?
> Is there something more beautiful?

Again avoiding the "beauty question" (beauty is in the eye of the
beholder), that seems to me to do what the OP wants, and concisely
says what it's doing.

I can see four problems with first assigning to the hash even if the
value is nil, and then deleting nil values from the hash. Robert
Klemme pointed out that it was inefficient, and that it might remove
previous wanted nil values in the hash.

Also, the code is longer, and you might override (and then delete) an
existing value if it has the same key as a new key & value pair in
which the value is nil: see what happens to :two in the following:

#ruby 1.9.1p430 (2010-08-16 revision 28998) [i386-mingw32]

hhh =3D { :zero =3D> 0, :one =3D> 1, :two =3D> 2, :three =3D> nil, :four =
=3D> nil }
kv =3D [ [:one,   11], [:two,  nil],
       [:three, 33], [:four, nil],
       [:five,   5], [:six,  nil] ]

h =3D hhh.dup
puts; puts h.inspect
kv.each { |k, v| h[k] =3D v unless v.nil? }
puts "#=3D> #{h.inspect}"

# {:zero=3D>0, :one=3D>1, :two=3D>2, :three=3D>nil, :four=3D>nil}
#=3D> {:zero=3D>0, :one=3D>11, :two=3D>2, :three=3D>33, :four=3D>nil, :five=
=3D>5}

h =3D hhh.dup
puts; puts h.inspect
kv.each { |k, v| h[k] =3D v }
h.delete_if { |k, v| v.nil? }
puts "#=3D> #{h.inspect}"

# {:zero=3D>0, :one=3D>1, :two=3D>2, :three=3D>nil, :four=3D>nil}
#=3D> {:zero=3D>0, :one=3D>11, :three=3D>33, :five=3D>5}