JavaScript allows writing properties that were not part of it's class originally throughout the runt...

# getting-started

[Ray Rahke]

JavaScript allows writing properties that were not part of it's class originally throughout the runtime

Object.defineProperty(object1, 'property1', {
  value: 42
});

Is there any way for me to achieve something similar in Kotlin, regardless of how hacky or unadvised?

[Joffrey]

Using a Map<String, Any>?

[Ray Rahke]

class Foo {
  val x = 5
}

fun main() {
  val foo = Foo()
  defineProperty(foo, 'y', 7)
  println(foo.y) // 7!
}

[Joffrey]

This might be an XY problem. What are you trying to do?

[Ray Rahke]

create the appearance of removing or adding individual interfaces on an object

[Ray Rahke]

without losing all of the other interfaces that the object might have inherited

[Ray Rahke]

i want to create a function that takes in an interface and manually assign's the fields to the object

[Ray Rahke]

and when you remove an interface, it create a brand new object without that interface and go through every other interface and re-add them

[Joffrey]

But what are you trying to do in terms of business with this? It seems this is your solution to a problem

[Ray Rahke]

entity component system

[Ray Rahke]

here is examples pseudo code for what I want as a langauge feature

fun fn(entity: Physics) {
  entity.position // OK!
}

fun main() {
  object entity : Health, Skills, Magical
  fn(entity) // error, lacks Physics component
  entity = entity with Physics
  fn(entity) // allowed! entity has Physics
  entity = entity without Physics // will still keep Health, Skills, Magical
  fn(entity) // error! lacks Physics component
}

[Ray Rahke]

the with and without is fake syntax i would imagine for adding or stripping interfaces from instaces

[Ray Rahke]

so at this point I am just trying to hack Kotlin to give the illusion of this as a syntax feature

[Ray Rahke]

i am fine reconstructing entire deep copies of the objects behind the scenes. just want type system to work.

[Youssef Shoaib [MOD]]

You could mess around with intersection types to make this sorta work. I had a demo somewhere I wrote long ago for a database query DSL using this idea. Lemme find it one second

[Youssef Shoaib [MOD]]

https://kotlinlang.slack.com/archives/C7L3JB43G/p1680065960980769?thread_ts=1679260580.903859&cid=C7L3JB43G
This was originally about code-generation, compiler plugins, and database queries, but I believe it can apply to your situation here too if you squint enough

[Youssef Shoaib [MOD]]

Not sure if writing without would be possible here, but it's worth a try!

[CLOVIS]

What you want is an object that contains arbitrary data and can be controlled. You can take inspiration from CoroutineContext to achieve this.

class Entity {
    private val attributes = HashMap<EntityData.Key<*>, *>()
 
    override fun contains(key: EntityData.Key<*>): Boolean =
        attributes.containsKey(key)

    override fun <T : EntityData> get(key: EntityData.Key<T>): T =
        attributes[key]!! as T

    override fun <T : EntityData> set(key: EntityData.Key<T>, value: T) =
        attributes[key] = value
}

interface EntityData {
    interface Key<E : EntityData>
}

class Physics(
    …
) : EntityData {
    companion object : EntityData.Key<Physics>
}

class Health(
    …
) : EntityData {
    companion object : EntityData.Key<Health>
}

class Skills(
    …
) : EntityData {
    companion object : EntityData.Key<Skills>
}

Then, usage:

fun main() {
  val entity = Entity()
  entity[Health] = Health(…)
  entity[Skills] = Skills(…)
  entity[Magical] = Magical(…)

  if (Physics in entity) fn(entity[Physics])
  entity[Physics] = Physics(…)  
  fn(entity[Physics])
}

[CLOVIS]

Of course, this version isn't typesafe.

You could make a typesafe version using phantom type parameters, but you would need one more type parameter for each property you want to test against.