DZone
Thanks for visiting DZone today,
Edit Profile
  • Manage Email Subscriptions
  • How to Post to DZone
  • Article Submission Guidelines
Sign Out View Profile
  • Post an Article
  • Manage My Drafts
Newsletter
Log In / Join
Refcards Trend Reports
Events Video Library
Refcards
Trend Reports

Events

View Events Video Library

Related

  • How to Become a Software Engineer Without a CS Degree: Essential Strategies for Success
  • How To Create a Homescreen Widget in Android
  • How to Evaluate Coding Agents With Harbor Framework, Python, Docker
  • The Window Closes: Why I Switched to Kotlin Before the Codebase Got Too Big

Trending

  • Using the Anthropic Evaluation Tool to Check the Claude Code Plugin Efficiency
  • Building a Feature Store With Neo4j and Feast
  • Microsoft Foundry Agent Debugging Dashboard with Microsoft Fabric Eventhouse, KQL, Docker and Grafana
  • Two AI Agents, One Database: Solving Concurrent Updates With Optimistic Locking

Draft This article hasn't been published, so readers can't see it.

In moderation This article is waiting for review, so readers can't see it yet.

Deleted This article has been deleted, so readers can't see it.

  1. DZone
  2. Coding
  3. Languages
  4. The Pitfall of Implicit Returns

The Pitfall of Implicit Returns

Implicit returns are a feature in some languages, but beware, concise code doesn't necessarily imply being better code. Learn more!

By 
Nicolas Fränkel
·
Mar. 26, 24 · Analysis
Post on X (opens in a new tab) Share on LinkedIn (opens in a new tab)
1.6K Views

Join the DZone community Save articles, join the discussion, and download Refcards and Trend Reports with a free account.

Join for free Already a member? Log in

Implicit returns are a feature in some languages. They have recently bitten me, so here's my opinion.

Statements, Expressions, and Returns

Before diving into implicit returns, we must explain two programming concepts influencing them. A lot of literature is available on the subject, so I'll paraphrase one of the existing definitions:

An expression usually refers to a piece of code that can be evaluated to a value. In most programming languages, there are typically three different types of expressions: arithmetic, character, and logical.

A statement refers to a piece of code that executes a specific instruction or tells the computer to complete a task.

— Expression vs. Statement

Here's a Kotlin snippet:

Kotlin
 
val y = 10                //1
val x = 2                 //1

x + y                     //2

println(x)                //1


  1. Statement, executes the assignment "task"
  2. Expression, evaluates to a value, e.g., 12

Functions may or may not return a value. When they do, they use the return keyword in most programming languages. It's a statement that needs an expression.

In Kotlin, it translates to the following:

Kotlin
 
fun hello(who: String): String {
    return "Hello $who"
}


In this regard, Kotlin is similar to other programming languages with C-like syntax.

Implicit Returns

A couple of programming languages add the idea of implicit returns: Kotlin, Rust, Scala, and Ruby are the ones I know about; each has different quirks.

I'm most familiar with Kotlin: you can omit the return keyword when you switch the syntax from a block body to an expression body. With the latter, you can rewrite the above code as the following:

Kotlin
 
fun hello(who: String): String = "Hello $who"


Rust also allows implicit returns with a slightly different syntax.

Rust
 
fn hello(who: &str) -> String {
    return "Hello ".to_owned() + who;          //1
}

fn hello_implicit(who: &str) -> String {
    "Hello ".to_owned() + who                  //2
}


  1. Explicit return
  2. Transform the statement in expression by removing the trailing semicolon — implicit return

Let's continue with Kotlin. The expression doesn't need to be a one-liner. You can use more complex expressions:

Kotlin
 
fun hello(who: String?): String =
    if (who == null) "Hello world"
    else "Hello $who"


The Pitfall

I was writing code lately, and I produced something akin to this snippet:

Kotlin
 
enum class Constant {
    Foo, Bar, Baz
}


fun oops(constant: Constant): String = when (constant) {
    Constant.Foo -> "Foo"
    else -> {
        if (constant == Constant.Bar) "Bar"
        "Baz"
    }
}


Can you spot the bug?

Let's use the function to make it clear:

Kotlin
 
fun main() {
    println(oops(Constant.Foo))
    println(oops(Constant.Bar))
    println(oops(Constant.Baz))
}


The results are:

Foo
Baz
Baz


The explanation is relatively straightforward. if (constant == Constant.Bar) "Bar" does nothing. The following line evaluates to "Bar"; it implicitly returns the expression. To fix the bug, we need to add an else to transform the block into an expression:

Kotlin
 
if (constant == Constant.Bar) "Bar"
else "Baz"


Note that for simpler expressions, the compiler is smart enough to abort with an error:

Kotlin
 
fun oops(constant: Constant): String =
    if (constant == Constant.Bar) "Bar"      //1
    "Baz"


  1. 'if' must have both main and 'else' branches if used as an expression

Conclusion

Implicit return is a powerful syntactic sugar that allows for more concise code. However, concise code doesn't necessarily imply being better code. I firmly believe that explicit code is more maintainable in most situations.

In this case, I was tricked by my code!

Beware of implicit returns.

Go Further

  • Expression vs. Statement
  • Rust, Ruby, and the Art of Implicit Returns
  • To be clear, Rust does not have "implicit returns"
  • On the merits of verbosity and the flaws of expressiveness
Kotlin (programming language) Syntax (programming languages) Coding (social sciences)

Published at DZone with permission of Nicolas Fränkel. See the original article here.

Opinions expressed by DZone contributors are their own.

Related

  • How to Become a Software Engineer Without a CS Degree: Essential Strategies for Success
  • How To Create a Homescreen Widget in Android
  • How to Evaluate Coding Agents With Harbor Framework, Python, Docker
  • The Window Closes: Why I Switched to Kotlin Before the Codebase Got Too Big

Partner Resources

×

Comments

Loading comments

The comments didn't load

Please try again in a moment.

Likes

Loading

The next likes didn't load. Please try again.

The likes didn't load

Please try again in a moment.

See who liked this

Log in or join DZone for free to see who liked this article.

Log in Join for free
  • RSS
  • X
  • Facebook

ABOUT US

  • About DZone
  • Support and feedback
  • Community research

ADVERTISE

  • Advertise with DZone

CONTRIBUTE ON DZONE

  • Article Submission Guidelines
  • Become a Contributor
  • Core Program
  • Visit the Writers' Zone

LEGAL

  • Terms of Service
  • Privacy Policy

CONTACT US

  • 3343 Perimeter Hill Drive
  • Suite 215
  • Nashville, TN 37211
  • [email protected]

Let's be friends:

  • RSS
  • X
  • Facebook