A modern programming language that makes developers happier.

kotlinlang

:one:
```fun foo(bar: Bar) {
  if (!bar.canFoo) {
    <http://logger.info|logger.info>("No foo for this bar")
    return
  }
  // Make foo with bar
}```
:two:
```fun foo(bar: Bar) {
  if (!bar.canFoo) {
    return <http://logger.info|logger.info>("No foo for this bar")
  }
  // Make foo with bar
}```

I know you really want to save a line, but it would be a line that doesn't make sense to me. The intention is unclear

another thing to consider is that if you find yourself writing `!bar.canFoo` a lot, consider adding (or extending) a complementary `bar.cannotFoo` or whatever the appropriate name would be

actually this `canFoo` was completely contrived, the question is purely about the `return`

I was wondering about how Kotlin has `Unit` as a return type to model void functions

and if it makes sense to use `return somethingThatReturnsUnit()` because of that

I have yet to find an example that makes sense, but yes: if it makes sense then please propagate the Unit. I don't think it makes sense here. It might be arguable if you also return a log in the "else" part