A modern programming language that makes developers happier.

kotlinlang

what's the syntax for checking type and then using typed object?
kind of like a `.let&lt;Type&gt; { }`

```
val something: X
fun f() {
	if (something is Y) {
		(something as Y).g()
	}
}
```

I see two options:
```
val something: X
fun f() {
	val cacheOfSomething = something
	if (cacheOfSomething is Y) {
		(cacheOfSomething as Y).g()
	}
}
```
or
```
(something as? Y)?.g()
```
neither of which is pleasing, any other way to do this?

If you have `(something is Y)` you should be able to smartcast inside of that block, no?

you don't need to cast it with as if you are in the scope of the if x is y check

`if (thing is String) { println(thing.length) }`

oh, sorry, the val is outside the scope of the funciton, it could change value over time (custom getter)
the `as Y` is not showing as redundant

Well sometimes I'll do `(something as? MyClass)?.let { ... }` which would work in your example I believe

`something.takeIf { it is Y }?.let { it.g() }`

Robert, what about `(something as? Y)?.g()` wasn't preferable to you? 

I think it's the most idiomatic way to accomplish what you're trying to do.

or i guess drop the let block.
 `something.takeIf { it is Y }?.g()`

one bonus of using `is` is that the ide can tell you the check for instance is always true/false.

<@U4JFYKCCC> I like `takeIf`, but I'm trying to call `Y.g()`, not `X.g()` :disappointed: (`takeIf` is not aware of cast)
<@U3HLSKE8L> it introduces null to the mix, even though there's nothing nullable going on in the expression, it's just a simple non-null typecheck+cast.

perhaps this:
```
inline fun &lt;reified T, R: Any&gt; Any?.takeAs(crossinline block: (T) -&gt; R?): R? {
  return if (T::class.java.isInstance(this)) block(this as T) else null
}
```

yep, just got to a similar conclusion:
```
inline fun &lt;reified T&gt; Any.run(crossinline block: T.() -&gt; Unit) {
	if (this is T) { block(this) }
}
```
note: you can do `this is T` on reified no need for explicit reflection.

yea I just like the `isInstance` because I can hit F1 on it and get a spew of documentation