I don't understand why does the compiler think i a...

# announcements

[poohbar]

I don't understand why does the compiler think i am trying to pass a second lambda to run

run {
  // some code
}

{ /*my unrelated block here*/ } shouldNotThrow AnyException

[Jacques Smuts]

lint warning: “LonelyLambda. Your lambda is lonely. Bring it closer.”

[poohbar]

@Shawn val x = { my code } is valid

[streetsofboston]

🙂
It is not java. A statement that starts with a { and ends with a } is an expression that results in a lambda. This lambda is not run and just sits there. It is lonely 🙂

[poohbar]

so { my code } is valid too

[marstran]

Because { } is not a block. It's a lambda.

[marstran]

You could do run { ... }

[Shawn]

like I said, doesn’t do what it does in Java

[Shawn]

like sure you can have a bare lambda without assigning it to anything

[poohbar]

this compiles perfectly fine Shawn:

if (true) {
  // nothing
}

{ myMock.method(arg) } shouldNotThrow AnyException

[poohbar]

not sure why are we talking about Java here, this is valid Kotlin code

[Shawn]

1. does myMock.method() even run
2. the compiler knows not to treat a bare lambda as an argument to an `if`…

[streetsofboston]

It is valid, but it doesn’t do anything. In java, similar syntax will run the code in that block. In Kotlin, it won’t run that code.

[Shawn]

valid != useful

[poohbar]

yes it will run the code

[poohbar]

because shouldNotThrow has this.invoke() in it

[streetsofboston]

Ah… I didn’t know that was code.

[poohbar]

it is an infix function

[streetsofboston]

You didn’t say it was… it looked like some comment or something 🙂

[poohbar]

my complaint is that the compiler should not treat it as a second lambda when it knows the previous code can't accept another lambda

[poohbar]

i think there should be room in the grammar to handle this correctly

[streetsofboston]

What is the signature of shouldNotThrow?

[poohbar]

infix fun <T : Throwable> (() -> Any?).shouldNotThrow(expectedException: KClass<T>)

[poohbar]

from https://github.com/MarkusAmshove/Kluent

[streetsofboston]

I think you find an issue.
I can imagine that putting the lambda of your shouldNotThrow on the same line as the closing bracket of the `run`’s lambda generates a compiler error, but you put it on a new line. This should not give a compiler issue, I think.

[poohbar]

Exactly! Makes no sense to me.

[streetsofboston]

I would file an issue and see what JetBrains has to say 🙂

[poohbar]

a workaround:

run {
 // some code
}

val call = { myMock.method(arg) }
call shouldNotThrow AnyException

[Dias]

a workaround would also be putting semicolon at the end run block

[Dias]

now I see why kotlin still allows you to have semicolons 😛

[poohbar]

nice! that is concise!

[poohbar]

still annoying though 😄

[Dias]

tho I don't see any issue with your workaround, I wouldn't event call it a workaround, I just do it most of time

[poohbar]

if i have a lot of calls to verify, i prefer one line per each

[LeoColman]

perhaps you can invert this call?

[LeoColman]

In #kotlintest we do shouldThrow { call() }

[LeoColman]

Or shouldNotThrow { }