Conditionally execute block in Ruby if value is not nil? (aka Smalltalk's ifNotNilDo:)

Question

In Smalltalk there is the method ifNotNilDo: It is used like this:

database getUser ifNotNilDo: [:user | Mail sendTo: user ]

On objects that are not nil the block is executed, passing the object itself as a parameter. The implementation in class UndefinedObject (Smalltalk's equivalent of Ruby's NilClass) simply does nothing. That way, if getting the user resulted in a nil object, nothing would happen.

I am not aware of something similar for Ruby, so I rolled out my own solution. It goes like this:

class Object
  def not_nil
    yield(self)
  end
end

class NilClass
  def not_nil
    # do nothing
  end
end

It could be used like this:

users = {:peter => "peter@peter.com", :roger => "roger@roger.com" }
users[:roger].not_nil {|u| Mail.send(u) }

This saves us from accessing the hash twice

Mail.send(users[:roger]) if users[:roger]

... or using a temp-variable:

u = users[:roger]
Mail.send(u) if u

Update:

People are starting to suggest solutions based on hash-operations, and also accessing the hash twice. My question is not directly hash-related.

Imagine instead that the first operation is not a hash-access and also expensive. Like:

RemoteUserRepo.find_user(:roger).not_nil {|u| Mail.send(u) }

(end-of-update)

My questions are:

• Am I wrong to re-invent this idiom?
• Is there something like this (or better) supported in Ruby out-of-the-box?
• Or is there another, shorter, more elegant way to do it?

Answer 1

In Ruby 2.3.0+, you can use the safe navigation operator (&.) in combination with Object#tap:

users[:roger]&.tap { |u| Mail.send(u) }

Answer 2

In ActiveSupport there is try method. https://github.com/rails/rails/blob/master/activesupport/lib/active_support/core_ext/object/try.rb

data = { a: [1,2,3] }
data[:a].try(:first)
#=> 1
data[:b].try(:first)
#=> nil
data[:b].first
#=> Exception

Under the hood it is implemented close to yours solution. For any object but nil it will "send a message" (in terms of Smalltalk) with attributes.

# object.rb
def try(*a, &b)
  if a.empty? && block_given?
    yield self
  else
    public_send(*a, &b) if respond_to?(a.first)
  end
end

# nilclass
def try(*args)
  nil
end

About your questions

Am I wrong to re-invent this idiom?

Rails guys have made something similar

Is there something like this (or better) supported in Ruby out-of-the-box?

No, Ruby doesn't support it out-of-the-box

Or is there another, shorter, more elegant way to do it?

In my opinion it has a problem: programmer should control data. One should know what kind of data he has and handle each type and each case, or raise an error. In your case it is valid for all data types but NilClass. What can lead to bugs that will very hard to debug.

I prefer to use old-fashioned

Mail.send(users[:roger]) if users[:roger]
# or
users[:roger] && Mail.send(users[:roger])
# or use caching if needed

Answer 3

You could use tap to avoid two Hash accesses:

users[:roger].tap { |u| Mail.send(u) if u }

I might use something like this:

[ users[:roger] ].reject(&:nil?).each { |u| Mail.send u }

Answer 4

In functional languages like Ruby there's an idiomatic solution that takes advantage of the fact that assignment statements return values that can be tested:

unless (u = users[:roger]).nil?
  Mail.send(u)
end

You thus avoid the extra hash lookup, as desired. (Some functional purists disapprove of this sort of thing, however, as it tests the return value of a side-effecting statement.)

Answer 5

No, you are not wrong to re-invent this idiom. You might still do better to give it a more accurate name, perhaps if_not_nil.

Yes, there is a core Ruby way to do this, though it's not exactly oozing with elegance:

[RemoteUserRepo.find_user(:roger)].compact.each {|u| Mail.send(u)}

Recall that compact returns an array's copy with the nil elements removed.

Answer 6

users.delete_if { |_, email| email.nil? }.each { |_, email| Mail.send email }

or

users.values.compact.each { |email| Mail.send email }