So (expr).andand.foo says “do foo if the expression is not nil) and (expr).please.foo says “do foo if you handle foo.” I need to look and see what else people are doing along those lines. In a general sense, I worry about two things:

1. if you use #respond_to? you break when people do method_missing magic. I try to avoid method_missing magic for that reason, it’s hard to use reflection. But you have to write for the code people actuallyt use, and;
2. if you handle NoMethodError, you catch your receiver’s NoMethodErrors, but also any errors raised if your receiver is trying to handle something and THAT raises an error. That is definitely not the semantics I have in mind!

So… It’s all dancing with bears. It’s lovely circus-stuff, but you’re in a heap of trouble if your partner steps on your toes :-)

Thanks again for your post.

Here’s something to think about: the code you are quoting doesn’t handle parameters or blocks. So the obvious fix is to capture an optional block and optional parameters. This will allow:

@some_value.try(:a_method, 42) { |foo| … }

Have a look at #send_with_default for an example of someone thinking along those lines:

http://rhnh.net/2007/10/2/object-send_with_default

There are links to a bunch of other approaches to this problem at the bottom of my own post explaining #andand:

http://weblog.raganwald.com/2008/01/objectandand-objectme-in-ruby.html

I am adding your post to the list. Thanks for taking the time to share!

def foo
puts “foo”
end
Object.new.send(:foo)

But in my opinion, you are right to call the method on the object if it’s not nil and does not respond to the method:

@some_value = “Hello World
….
@some_value.try(:uniq) # uniq being the method for an Array and not a String

If someone calls the wrong method on an object they’re expecting to be an array, they have a bug and they should be notified of it via an exception, not a silent fail.