A modern programming language that makes developers happier.

kotlinlang

&gt;  I wonder if there’s a way to prevent `isA` if the generic type of the function has its own generic type
I don't think there is a way to prevent it compile time, but you can always just half-botch it by having the assert always fail when `T::class.typeParameters` is non-empty (eg, the reified class has some generic parameters on it's own)

maybe you could even trigger the collection type checking automatically that way

I don't think you can get what's actually in the type parameter, unless I'm missing something

Like, you get list of KTypeParameter, which is a _sibling_ of KClass
(Both inherit from <https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.reflect/-k-classifier.html>)

And the stuff like "name" is what's declared in class. For example:

```inline fun &lt;reified T&gt; test() = T::class.typeParameters.map { it.name }

test&lt;Collection&lt;String&gt;&gt;()```
gives you `["E"]`

yeah, having the assertion always fail if the subject has another level of generic parameters would be nice

though, you would want stuff like `isA&lt;List&lt;*&gt;&gt;()` to work tho :thinking_face:
can you distinguish between those two? I don't think you do even that...

if it’s reified I think you should be able to tell it’s using a wildcard

doesn’t look like it. that map function up there ^ returns `[E]` for `*` as well

sorry, I’m neck deep in SQL explain plans at work

it looks like `variance` is always `out`, `name` is always `[E]` and `upperBounds` is always `kotlin.Any?`

the E comes from the declaration (Collection&lt;E&gt;)

maybe we need some kind of `isAWildcard` that allows wildcards

its really an exception and catching the isA&lt;X&lt;Y&gt;&gt; case is more important imo

unrelated, but why do kotlin scratches just suddenly stop working w/ no sort of message?

i end up scrapping the scratch and just putting it in a test most of the time

I always write tests, its a habit from before scratch files existed

`isA` could have a `ignoreGenerics: Boolean = false` parameter for when you want `isA&lt;List&lt;*&gt;&gt;(ignoreGenerics = true)` to pass, although that feels a little clunky

isA just does not work like expected and people write asserts that don’t check what they think they do. the other case can just be documented

there’s also precedent on breaking tests on bad assertions, like the relatively recent changes on the map stuff, where it detected there wasn’t a proper assertion. we had to refactor a few tests when we upgraded to that version. we also realized that in several tests we really hadn’t been testing anything at all. this is similar

the nested isA is something that we talked about at work some weeks ago. everybody was very suprised

its also not at all strikt specific, we had the problem in tests with strikt matchers but also in older tests that use kotest matchers