You can access a reference to a function using `::...

# getting-started

[Ray Rahke]

You can access a reference to a function using ::fn . Is there a reason why this wasn't chosen as the notation for referencing a class itself rather than an instance, as opposed to having to do Foo::class?

[Youssef Shoaib [MOD]]

Pretty sure ::Foo references `Foo`'s constructor

[Youssef Shoaib [MOD]]

Which is good to keep consistency between constructors and factory function; constructors don't need to be special on the caller side (e.g. no new keyword)

[Ray Rahke]

Can I perform a runtime check on that to see if an instance was built with that constructor

[Ray Rahke]

val thing = Foo()
fun<T: Foo> isInstance(ctor: () => T) {
  return thing is ctor
}

isInstance(::Foo)

[Ray Rahke]

i prefer ::Foo much more than Foo::class

[Ray Rahke]

maybe I could do

return thing::class.constructor is ctor

[Ray Rahke]

something like that

[Youssef Shoaib [MOD]]

I'd say just use reified type params instead of ::class then:

inline fun <reified T> Any?.isInstance() = this is T

val thing = Foo()
thing.isInstance<Foo>()

[Ray Rahke]

Does that do anything in the runtime though? or is it just a type assertion

[Ray Rahke]

my real use case filters through a list and returns all who are instances

[Ray Rahke]

also, it is a vararg function. I would like to be able to ask if an object is multiple instances at once. possible?

[Joffrey]

my real use case filters through a list and returns all who are instances

Then there is already filterIsInstance<T>(). If your use case slightly different, you can look at its implementation

[Ray Rahke]

Yeah but this needs to be a helper method that delegates to taht

[Ray Rahke]

entity.get(::Foo) should internally call filterIsInstance

[Ray Rahke]

so I don't have to do entity.components.filterIsInstance<T>() - that is verbose

[Ray Rahke]

it should work... ill try

[Joffrey]

Then use a reified type argument in your helper function, and you can achieve the same effect as Youssef mentioned

[Joffrey]

The usual approach is to have a function taking parameters of type KClass and write an inline reified wrapper on top

[Joffrey]

It can be a vararg of KClass and then a few inline reified wrappers taking 1, 2, 3, 4 type parameters.

[Joffrey]

But your use case with multiple type checks is a bit strange. If you need to type check multiple things, it should be for a reason, and this reason is probably sufficient to make a supertype for those. Otherwise the check doesn't bring any extra type safety on the results