48

Do with and run have the same functionality with only different syntax, or is there any major differences between with and run?

Which is the proper way?

adapter.run {
    notifyDataSetChanged()
    if (activityDetails.isEmpty())
        emptyText.visibility = View.VISIBLE
    else 
       emptyText.visibility = View.GONE
}


with(adapter){
   notifyDataSetChanged()
   if (activityDetails.isEmpty())
       emptyText.visibility = View.VISIBLE
   else 
       emptyText.visibility = View.GONE
}
Improve this question
1
  • 1
    run{} can do the chain call which is good for null check; with{} cannot. That's it. Commented Mar 15, 2021 at 19:51

2 Answers 2

Reset to default
51

They have only syntactic difference, run is an extension function while with is not. Here are the definitions (in kotlin-sdlib:1.0.3):

public inline fun <T, R> T.run(block: T.() -> R): R = block() // equivalent to this.block()

public inline fun <T, R> with(receiver: T, block: T.() -> R): R = receiver.block()

Since run is an extension function, it has one more implicit argument of type T, so the argument types are the same. The bodies of the functions are also effectively the same.

Their performance should also be equivalent since both are inline functions: the resulting bytecode should only contain the inlined block body.

The differences in the functions usage are all caused by the fact that run is an extension.

First, run is suitable for calls chaining:

foo.run { bar }.run { baz }

Second, and more important, if a declared variable type has run function with the same signature, it will be called instead of the extension. And run can be shadowed by another extension. This is how extensions are resolved. Example:

class MyClass {
     fun <R> run(blockIgnored: MyClass.() -> R): Nothing = throw RuntimeException()
}

"abcdefg".run { println("x") } // prints "x"
MyClass().run { println("x") } // throws RuntimeException
(MyClass() as Any).run { println("x") } // prints "x"
Improve this answer
Sign up to request clarification or add additional context in comments.

3 Comments

So i can user either. Dose both have any influence on performance of the application ?
@SaiKiran, yes, they are completely interchangeable, and their performance should be the same since they are both inline functions.
"We recommend with for calling functions on the context object without providing the lambda result." kotlinlang.org/docs/reference/scope-functions.html#with
21

In normal case, they are pretty similar, but for a nullable variable, it's better to use T.run()

E.g. if webview.settings is nullable, below would show the distinct

with(webview.settings) {
    this?.javaScriptEnabled = true
    this?.databaseEnabled = true
}

// similarly
webview.settings?.run {
    javaScriptEnabled = true
    databaseEnabled = true
}
Improve this answer

4 Comments

I guess it is even better to use "apply" in this scenario
Ya, but this is to answer the question of with vs run. As of when to use which, perhaps this article would help. medium.com/@elye.project/…
the return from the scope function is not used. would you please explain why is it better using "apply" in this case?
@sean I would not use apply in this case because as you said nothing is being returned.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.