I've been looking at functions with multiple conditional statements, like this example:
```python
if do_some_test():
metadata1 = self.get_some_metadata_related_to_what_just_happened()
metadata2 = self.get_more_metadata(metadata1)
self.log(metadata2)
bla_bla_bla()
return False
```
Sometimes I wish there was a way to simplify this into a single function call, like `return_if(do_some_test(), False)`. The idea is to have a conditional return that only executes if `do_some_test()` is `True`, thereby returning a specific value (in this case, `False`). I haven't encountered any programming language that has this feature, and I'm curious if others would find this helpful. What are your thoughts on this idea? Would you want to see something like this in a programming language?
8 Answers
Ruby also has the `return x if y` or `return x unless y`, which feels similar to what you’re suggesting. Nice to see that such flexibility exists in some languages!
I'm not totally sure why you need this extra syntax. If the code becomes overwhelming, why not just refactor that block into a separate function? It’ll help manage complexity without changing the language’s syntax.
I can see how this could be really useful. It would make some methods look cleaner, especially when dealing with a lot of checks. I'm all for syntactic sugar if it makes our lives easier in coding!
This pattern is actually pretty common in Perl, where you can do something like `return 0 if do_some_test();`. Ruby also has similar syntax. However, I'm not really sure how it's any different from the standard `if` condition in languages, which most already support. For instance, you can write `if do_some_test(): return False`, which is pretty straightforward.
Yeah! Ruby allows `return x if y` which is concise and neat.
Seems like a niche problem to me. While I wouldn't mind this feature if it existed, I don't often find myself needing it. I can think of simpler alternatives, like combining it into a single line: `if do_some_test(): return False` which most languages support already.
It sounds like you’re mixing up function execution and return statements. These are fundamentally different. You can achieve similar results without needing a new construct. Just use existing control structures to make your logic clearer.
What you’re describing is effectively a guard clause. Most programming languages already handle this pretty neatly. You just use something like `if condition: return False`. If you want to create a `return_if()` function, it might need to be integrated into the language as a syntax feature or a macro, but the standard guard clause is often clearer and easier to debug.
You might want to consider creating a module for it! Just imagine how useful that could be, but also give it some time and see if it sticks.
Exactly! I think it’s more about readability. With multiple checks, it can feel like clutter. A syntax like you suggested would clean things up a bit.