you mean internally?

# getting-started

[Ray Rahke]

you mean internally?

[Shawn]

wherever it makes the most sense

[Shawn]

components.asSequence()
    .filterIsInstance<SubA>()
    .first()

[Shawn]

(assuming you want the component list evaluated lazily)

[Ray Rahke]

i am not sure how to o that insie of the method

[Ray Rahke]

Untitled.kt

Untitled.kt

[Ray Rahke]

like this?

[Shawn]

you would need to make findFirstInstance() an inline fun and make the type parameter reified T : Base

[Ray Rahke]

will that work if I need to overload this function

[Ray Rahke]

later

[Shawn]

it depends on what you're gonna overload the function with

[Ray Rahke]

first signature returns a T

[Ray Rahke]

second returns a T[]

[Ray Rahke]

based on if the component you look for is stackable

[Ray Rahke]

you cant have multiple rigidbodies

[Shawn]

that just sounds like you want a different method name

[Ray Rahke]

nah I want to be able to have
get(RigidBody::class) -> a single result
get(SpellEffect::class) -> list result

[Ray Rahke]

the logic to determine is like
if ComponentType is Stackable

[Ray Rahke]

with Stackable being a marker interface i define

[Shawn]

why would a method named findFirstInstance return multiple instances lol

[Ray Rahke]

yeah lol sorry I had done that for the toy example on this server

[Ray Rahke]

its real name is just get

[Shawn]

I still don't think that's especially ergonomic

[Ray Rahke]

users of the game engine will specify whether their custom component conceptually should be stackable

[Ray Rahke]

like a spell effect, you expect to be able to have multiple at once

[Ray Rahke]

but not multiple 3DPositions

[Ray Rahke]

so they already define that

[Ray Rahke]

class SpellEffect : Stackable

[Ray Rahke]

using interface inheritance

[Ray Rahke]

it seems like a waste to not use that

[Ray Rahke]

having getSingleComponent() and getAllComponent()

[Ray Rahke]

seems worse than just having 1 get(Component), and having our codebase be intelligent enough to know whether or not the result will be a list

[Ray Rahke]

cause you already said so with Stackable

[Shawn]

being implicit isn't necessarily more intelligent but w/e it's not my API

[Ray Rahke]

yeah but i would think "everyone in my codebase already knows that 3DPosition is definitionally not stackable. why can't the get() function be smart enough to know that the result necessarily will only be 1 thigng?"

[Ray Rahke]

i do this pretty easily in typescript

[Shawn]

well, it looks you can overload the method with different `KClass`s without worrying about erasure

[Ray Rahke]

in unity c# you just have 1 get() function, but it always returns a list...
So you end up doing

3dposition = Get<3DPosition>()[0]

[Ray Rahke]

that [0] is so gross

[Ray Rahke]

well, it looks you can overload the method with different `KClass`s without worrying about erasure

i actually dont think i need to overload at all

[Ray Rahke]

because this is just a runtime check

[Ray Rahke]

get(type: KClass<Base>) {
if type is Stackable {
return filterall
else
return filterfirst
}

[Ray Rahke]

but the issue here is the return will just be seen as Base to the compiler

[Ray Rahke]

i need as T and as T[]

[Ray Rahke]

for each return

[Shawn]

that won't exactly work, you would need type == Stackable::class because you're not working with a class instance

[Ray Rahke]

right

[Ray Rahke]

thanks

[Shawn]

but also, why not just use the overload?

[Ray Rahke]

im not sure how the overload would work

[Ray Rahke]

oh let me see

[Ray Rahke]

i think ig ot it

[Ray Rahke]

@Shawn the overload still doesnt solve the as cat

[Ray Rahke]

cast

[Shawn]

I mean, an unchecked cast is _probably_(?) going to be necessary no matter what unless you can get creative with the generics

[Shawn]

how do you envision the method being used? like what do you want the callsite to look like?

[Ray Rahke]

@Shawn

an example use case would be like

PhysicsSystem {
apply() {
position = entity.get(Position::class)
forces = entity.get(PhysicalForce::class)
for force in forces:
position.move(force)

[Ray Rahke]

so sometimes get returns a single thing, sometimes an iterable array of things

[Ray Rahke]

Untitled.kt

Untitled.kt

[Ray Rahke]

i don't understand why this doesn't work...

[Ray Rahke]

is Kotlin compiler not intelligent enough to see that
any code inside of an if x is Blah condition, then x definitely is Blah?

[Ray Rahke]

so the as Blah should be trivially trustworthy

[Ray Rahke]

oh sorry my code is wrong

[Ray Rahke]

i never make it be a single elemet

[Shawn]

well also, you're returning T

[Ray Rahke]

return found.first() as T

[Shawn]

that's another reason to overload

[Shawn]

you can only return one type from a method lol

[Ray Rahke]

oh right

[Ray Rahke]

yeah TS lets me say : T | T[]

[Ray Rahke]

K but how will kotlin infer which overload I am using

[Ray Rahke]

both functions just take in a class type...

[Ray Rahke]

and you always pass Component classes

[Ray Rahke]

Untitled

Untitled

[Shawn]

I think you'd need a Stackable and an Unstackable type (or named whatever you'd like) in order to differentiate

[Ray Rahke]

yeah but Stackable is just an interface

[Ray Rahke]

technically it has no link to the Component base class

[Ray Rahke]

you could make anything Stackable.

[Ray Rahke]

is there a way for me to say that an interface can only be extended by certain children

[Shawn]

you can prevent consumers from extending an interface by making it sealed

[Ray Rahke]

consumers need to be able to extend an interface with their custom component classes

[Ray Rahke]

class MyCustomComponent : Component(), Stackable

[Ray Rahke]

but this should only make sense if its a component

[Ray Rahke]

not some random class

[Ray Rahke]

I guess I could do class inheritance and have a hierarchy of two classes

[Ray Rahke]

that works

[Ray Rahke]

but still the as T is a problem

[Ray Rahke]

Untitled.kt

Untitled.kt

[Ray Rahke]

Cannot check for instance of erased type: T

[Ray Rahke]

how is this erased?

[Shawn]

generics are erased on the JVM after compilation

[Ray Rahke]

then this ??

[Ray Rahke]

Untitled.kt

Untitled.kt

[Ray Rahke]

feel like this is just beyond the ability of kotlin type analysis

[Ray Rahke]

is there a way I can just force the casting

[Ray Rahke]

without a warning

[Ray Rahke]

wait does as do a literal runtime cast?

[Ray Rahke]

i don't need that. it already is that type guaranteed

[Ray Rahke]

I just need the language server to know that it is

[Ray Rahke]

think the overload just avoids this actually.

[Shawn]

It depends on how you write the methods—if you use reified, you can smart-cast but you can't use the same name (the overload will be ambiguous and won't resolve). if you accept two different KClass types, you will have to manually cast but you can use the same name