From: "rosenfeld (Rodrigo Rosenfeld Rosas)" Date: 2013-04-18T01:42:51+09:00 Subject: [ruby-core:54397] [ruby-trunk - Feature #8237] Logical method chaining via inferred receiver Issue #8237 has been updated by rosenfeld (Rodrigo Rosenfeld Rosas). Charles, I understand that you don't like this code style. But I'm pretty sure you consider bad several other code styles used on Ruby by people out there, right? This is what I like about Ruby. It doesn't try to provide you a single obvious way of doing something. It just give you the tools and let you decide what pattern to use. These are are some places I use such patterns in the Grails application I maintain: def jsonData = [ ... lawFirm: transaction.lawFirm?.name, // instead of transaction.lawFirm ? transaction.lawFirm.name : null ... ] if (grailsApplication.config.myappname?.logging?.enabled) ... Honestly I don't see any problems with code like this and I'd love to be able to use something like this in ruby. Using "??" seems like a good trade-off to me, specially because I'd never use triple question marks (???) as it doesn't make sense to check if a boolean value is null. And if your method ending with a question mark isn't returning a boolean value, this is another issue that I'd fix in the method instead of using a triple question mark. ---------------------------------------- Feature #8237: Logical method chaining via inferred receiver https://bugs.ruby-lang.org/issues/8237#change-38661 Author: wardrop (Tom Wardrop) Status: Open Priority: Normal Assignee: Category: Target version: =begin This is a feature suggestion that was raised while discussing issue #8191. The feature suggestion is to introduce some form of logical method chaining to address this reasonably common pattern: user && user.profile && user.profile.website && user.profile.website.thumbnail It would be reasonably trivial to shorten this to: user && .profile && .website && .thumbnail The implementation I propose would be for Ruby to allow an inferred receiver; the dot prefix would be the syntax for this. The inferred receiver would resolve to the result of the last expression in the current scope. For illustrative purposes, the following would work under this proposal: "some string" puts .upcase #=> SOME STRING Another example: puts .upcase if obj.success_message || obj.error_message # Instead of... message = (obj.success_message || obj.error_message) puts message.upcase if message This can also potentially provide an alternative option in syntactically awkward scenario's, such as dealing with the return value of an if statement or a catch block, avoiding the need for temporary variable assignment: catch :halt do # Do something end if .nil? log.info "Request was halted" response.body = "Sorry, but your request could not be completed" end The logical chaining scenario is the main use case however. I just wanted to demonstrate how the proposed implementation could also be used in other creative ways. =end -- http://bugs.ruby-lang.org/