A modern programming language that makes developers happier.

kotlinlang

I currently have code like this:
```
    override fun onReject(token: String) {
        if (savedConnectionState is ConnectionState.Authenticating) {
          // do something
        } else {
           // complain
        }
    }
    
    override fun onSend(message: String) {
        if (savedConnectionState is ConnectionState.ReadyToSend) {
            // do something
        } else {
            // complain
        }
    }```

Is there a way to create a `check()` method that takes a type (e.g., `ConnectionState.Authenticating`) as an argument and tests whether the instance variable `savedConnectionState` is that type?

Something like this maybe <https://pl.kotl.in/4eS7G-xbb> ?

(first-place medal for first-class types)

I modified your code to return the instance variable as the desired type. <https://pl.kotl.in/cDt1J3zpr>

Instead of
```if (savedState is T) (savedState as T) else null```
you can just write
```savedState as? T```
:slightly_smiling_face:

Thank you. As you can tell from the long variable names, I come from Java.

I’ll be adding some sort of error reporting in the else branch so I think I’ll leave it as an `else` (unless you have a better idea).

I hope you don’t mind I looked you up on the interwebz. My grandfather went to college in Kharkiv about 100 years ago. I don’t think they taught functional programming then.

Actually, I should probably use the Elvis operator, not `if`.

&gt; My grandfather went to college in Kharkiv about 100 years ago.
Nice :slightly_smiling_face:

&gt; Actually, I should probably use the Elvis operator, not `if`.
Sure, whatever is easier in your case.

This is pretty ugly:
```    inline fun &lt;reified T : ConnectionState&gt; check() =
        savedConnectionState as? T ?: {
            Logger.error("savedConnectionState was $savedConnectionState, expected $T")
            null
        }()```

Is there a way to include `T` in my error message or does the type get erased?

You can write
```= (savedConnectionState as? T).also {
    it ?: Logger.error("savedConnectionState was ${savedConnectionState::class}, expected ${T::class}")
}```
Or if check
```= (savedConnectionState as? T).also {
    if (it == null) Logger.error("...")
}```

I really appreciate the Kotlin lesson. I’ve never used `also` before. That’s much more elegant.

`let`, `apply`, `also` and `run` are amazing :slightly_smiling_face:

Would you like to be credited in the commit message? I’m coding for Mozilla.

Let me know if you ever want a referral to Mozilla (or to Google, where my husband works).