Why is there no “returnif ” that could replace (and optimize) the pattern “return if “

I often find myself typing this pattern for a variety of reasons:

return <expr> if <expr>

Not only does this seem wasteful, but if has any sort of evaluation time, then it makes more sense to do this:

tmpVar = <expr>
return tmpVar if tmpVar

But it seems silly to have to make a tmpVar just do this, and it’s even less readable. I’ve always wanted something like this:

returnif <expr>

That returns the expression if it ends up evaluating to a non-nil/false value.

Unfortunately this isn’t something that can be easily added to the language from inside of the language because it alters control flow.

Is this that unusual of a request or perhaps that unusual of a pattern for most people? I’m surprised that neither ruby nor perl seems to have a construct like this yet.

And for extra credit – are there any languages that have this kind of a construct?

How about using the lowly || with a begin/end block?

return <expr> || begin
  <continuation>
end

One way to implement such a thing in Perl, using the Macro::Simple module found on CPAN:

#!/usr/bin/env perl
use v5.36;
use Macro::Simple {
  'returnif($)' => '{ my $val = %s; return $val if $val; }'
};

sub demo($val) {
  returnif($val == 0); # The parenthesis are required
  return "not zero";
}

say demo(1);
say demo(0);

are there any languages that have this kind of a construct?

Maybe not built in, but it can be easy to write it using other features of a language, like macros. Some examples:

Tcl:

#!/usr/bin/env tclsh

proc returnif {exp} {
    # Evaluate in the caller's scope
    set val [uplevel 1 [list expr $exp]]
    if {$val} {
        # -level 2 makes the caller of this proc return $val
        return -level 2 $val
    }
}

proc demo {val} {
    returnif {$val == 0}
    return "not zero"
}

puts [demo 1]
puts [demo 0]

Common Lisp:

(defmacro returnif-from (name expr)
  "Return the result of evaluating expr from the named block if that value is true"
  (let ((gval (gensym)))
    `(let ((,gval ,expr)) (when ,gval (return-from ,name ,gval)))))
(defmacro returnif (expr)
  "Return the result of evaluating expr from the current nil block if that value is true"
  `(returnif-from nil ,expr))

(defun demo (val)
  (returnif-from demo (= val 0))
  "not zero")

(format t "~A~%" (demo 1))
(format t "~A~%" (demo 0))

Unfortunately this isn’t something that can be easily added to the language from inside of the language because it alters control flow.

This particular control flow can be done from blocks in Ruby, though:

def guard(x)
  yield x if x
end

guard(expensive.operation) { return _1 }
# or `return it` in 3.4+

Is this that unusual of a request or perhaps that unusual of a pattern for most people? I’m surprised that neither ruby nor perl seems to have a construct like this yet.

And for extra credit – are there any languages that have this kind of a construct?

Many languages have the potential for some kind of similar guard pattern, although it usually involves a variable. That’s because what you’re asking for just isn’t that common as a need, especially compared to the opposite (returning nil when a value is nil – see try/? operators). They include…

Rust

if let Some(x) = expensive_operation() {
    return x;
}

or functionally,

expensive_operation().or_else(continuation)

Go

if x := expensiveOperation(); x != nil {
    return x
}

Swift

if let x = expensiveOperation() {
    return x
}

Haskell

import Control.Applicative (Alternative (..))

expensive_operation <|> continuation

(and probably some do-notation option I’m not aware of)

Python

if (x := expensive_operation()):
    return x

C#

if (ExpensiveOperation() is Foo x) {
    return x;
}

JavaScript

expensiveOperation() ?? continuation()
// or || for falsy values

I can keep expanding this, but you get the point.

Ruby perspective.

Commentary

My initial concern in reading the question is that return if x or return unless y are typical idioms as guard clauses, which appears to be what you are expressing in your comment (a guard clause that is).

returnif x and return if x could be very confusing and would have precisely opposite effects, given that the first would return x if it is “truthy” and the second will return nil if x is “truthy”.

All that being said I could see a use case for this (although I think naming might be an issue as described above, I proposed return_if below but I still dislike it), so maybe open a feature request here: https://bugs.ruby-lang.org/ and see how others feel about it.

As you mentioned this could be better optimized if it was implemented at a lower level as a keyword similar to return.

Possible Solution

Unfortunately this isn’t something that can be easily added to the language from inside of the language because it alters control flow.

This is not entirely accurate and while I am not recommending this, we can use the throw/catch control flow along with some awful meta-programming to simulate the requested functionality.

This works because when calling Kernel#throw “…Ruby searches up its stack for a catch block..”, so it does not matter where in the call stack throw is called as long as somewhere above it there is a matching catch.

We can leverage this knowledge by wrapping every new method definition in a catch block and then use a defined method return_if to call the corresponding throw when the condition is true.

module ReturnIf 
  def self.extended(base)
    base.include(InstanceMethods)
  end 

  def method_added(method_name)
    return if @_adding 
    @_adding = true 
    original_method = instance_method(method_name)
    define_method(method_name) do |*args,**kwargs,&block|
      Kernel.catch(:__short_circuit__) {original_method.bind(self).call(*args,**kwargs,&block)}
    end
  ensure 
    @_adding = false
  end 

  def singleton_method_added(method_name)
    return if @_adding
    @_adding = true
    original_method = method(method_name) 
    define_singleton_method(method_name) do |*args,**kwargs,&block| 
      Kernel.catch(:__short_circuit__) {original_method.call(*args,**kwargs,&block)}
    end
  ensure 
    @_adding = false
  end 
  module InstanceMethods
    def return_if(x)
      return_now(x) if x
    end
    def return_unless(x) 
      return_now unless x
    end   
    def return_now(x=nil) 
      Kernel.throw(:__short_circuit__,x)
    end 
  end
end 

BasicObject.extend(ReturnIf)

Now every method added to an object will be wrapped in this control flow which allows you to use return_[if/unless/now] <expr> in any method body.

Example:

class A
  def self.testing(x)
    return_if x
    42
  end 
  def self.t_block(x)
    return_if yield x if block_given? 
    42 
  end 
  def testing(x)
    return_if x 
    42 
  end 
end
A.testing(2) 
#=> 2 
A.testing(nil)
#=> 42
A.t_block(nil) 
#=> 42 
A.t_block(nil) {|e| e.nil?} 
#=> true
A.new.testing(2) 
#=> 2 
A.new.testing(nil)
#=> 42

Filed under: Kiến thức lập trình - @ 08:58

Thẻ: rubyperlreturn

Thiết kế website giá rẻ

Danh mục

Why is there no “returnif ” that could replace (and optimize) the pattern “return if “

Rust

Go

Swift

Haskell

Python

C#

JavaScript