Is there any way to simplify ```val x = 7 fn(object { val x = x })``` to ```val x = 7 fn(object { x ...

# getting-started

[Ray Rahke]

Is there any way to simplify

val x = 7
fn(object { val x = x })

to

val x = 7
fn(object { x })

[hfhbd]

What’s the point of the object at all? The parameter type will be Any (in almost all cases).

[Ray Rahke]

for an event system i am building

[Ray Rahke]

in this case, it would be like publish("some label", { x, y })

[Ray Rahke]

so you can later see an event with event.x, event.y

[Szymon Jeziorski]

Instead of creating anonymous objects I would suggest creating data classes specific for domain context (for example data class per event type) - it would make the code and its context more readable and type safe

[hfhbd]

Please take a look at the documentation: Kotlin is a static typed language, so you need to use an interface/class to access a property (without using reflection/precompilers etc.). If you pass an (non-local) object without any super class/interface, the function receives Any.

[Ray Rahke]

@Szymon Jeziorski I don't think that is feasible for my use case. I am building out a PubSub event system architecture, oriented as a library for people to extend and use easily for any purposes.

Different types of data are attached to events based on different types of labels.

somewhere:...
publisher.publish("update", { fps: 60, entities: List<Entity> } )
publisher.publish("input", { mousex: 0, mousey: 0 })

then later...

if (event.label == "update) {
  fps = event.content.fps
} else if (event.label == "input") {
  mousex = event.content.mousex
}

[Ray Rahke]

i dont think I can use sealed classes here because the Event interface needs to be super general

[Ray Rahke]

using liskov substitution, programming to interface rather than implementation

[hfhbd]

You can use generics

[Ray Rahke]

I'm not clear on how that would work

[Ray Rahke]

subscribers should be able to subscribe or stop subscribing to any channels throughout the runtime

[Ray Rahke]

it can't be staticly determined at runtime

[hfhbd]

sealed interface Event<Context> {
    data class Update<Context>(val context: Context): Event<Context>
    data class Input<Context>(val context: Context): Event<Context>
}
data class FPS(val fps: Int, val entities: List<Entity>)
data class Mouse(val x: Int, val y: Int)
publisher.publish(Event.Update(context = FPS(fps = 60, entities = listOf<Entity>()))
publisher.publish(Event.Input(Mouse(x = 0, y = 0))

then later...

when (val event: Event<*>) {
    is Event.Update -> {
        val context = event.context
        if (context is FPS) {
            val fps = context.fps
        }
    }

    is Event.Input -> {
        val context = event.context
        if (context is Mouse) {
            val mouseX = context.x
        }
    }
}

[Ray Rahke]

so the generic is being implicitly determined?

[Ray Rahke]

by the function argument pass?

[Ray Rahke]

Also, will this allow for consumers of my library to add their own event types?

[Ray Rahke]

extending it

[Ray Rahke]

users of my library need to be able to create their own publishers that have their own event formats

[hfhbd]

Yes, but you need to cast it/check the type of the context during runtime

[Ray Rahke]

with an if statement should work right

[hfhbd]

yes, I updated the code

[Ray Rahke]

could you show an example of how to extend it

[Ray Rahke]

the sealed class

[Ray Rahke]

if some consumer later added a new event type

[Ray Rahke]

is it just Event.newwhatever =

[hfhbd]

open class Custom<Context>(val context: Context): Event<Context>

[Ray Rahke]

but then people who expect that will have to annotate the type as Custom rigth?

[Ray Rahke]

like

class SomeSubscriber : Subscriber {
  fun foo() {
     for (event in this.events) {
         if (event.update)
}

[Ray Rahke]

will they have to make the type of Event no longer Event

[Ray Rahke]

but be Custom

[hfhbd]

Custom inherits from Event

[Ray Rahke]

so if they have the type as Event, then if Event.Custom -> will be red error

[Ray Rahke]

because the ven diagram is the other direction

[Ray Rahke]

if I have two publishers - PhysicsEngine and RendererEngine, I assume they will both need to implement their own open class PhysicsEvent open class RenderEvent

[Ray Rahke]

now imagine i have a subscriber somewhere who needs to listen to both of those

[Ray Rahke]

and whatever other events he might care about.

[Ray Rahke]

am I going to have to do some super gross class inheritance merging?

[hfhbd]

It depends on your actual code, but if you only need one event publisher, then yes you can either create a super class/interface or just use Any and you need to cast it during runtime. This is how static typed languages work.

[Ray Rahke]

I don't think this is a static typed language thing. I implemented this same system in typescript with 100% coverage (no use of Any)

[Ray Rahke]

consumers could implement their own publishers/subscribers with a simple mixin

[Ray Rahke]

and then everywhere else in the codebase could infer the type perfectly

[Ray Rahke]

since this is a library for an ECS game engine, it needs to allow for anyone creating an arbitrary number of subscribers and publishers

[Ray Rahke]

not relying on one big monolithic enum

[hfhbd]

TypeScript converts to JS at runtime, so there are no types at all during runtime. Kotlin type system based mostly on Java.

[Ray Rahke]

TS will not convert if there are any violations of the static type systsem

[Ray Rahke]

it shouldn't be compared to javascript. It has a more sophisticated type system than most langauges

[Ray Rahke]

my point was that in the ts codebase, the language server was able to perfectly infer the shape of events everywhere from any publisher

[Ray Rahke]

never any unknowns or any

[Ray Rahke]

maybe i misunderstand

[hfhbd]

Okay, so what's the signature of publisher.publish? And did you enable noPropertyAccessFromIndexSignature?

[Ray Rahke]

i dont know what that second thing is but the signature of publish is publish(label: string, data: any)

[Ray Rahke]

internally it creates an event `Event(from=this, label=label, data=dat)``

[hfhbd]

So it's any, untyped and checks the properties during runtime.

[Ray Rahke]

currently yeah, I started Kotlin this month so I haven't learned if theres a better way

[hfhbd]

Wait, I mean your (existing?) TS code.

[Ray Rahke]

Oh yeah no, it's not using any

[Ray Rahke]

I am actually doing some super arcane ts magic to get it to infer

[Ray Rahke]

forgot its been a few months and it took me like 82 hours to get working so I forget

[Ray Rahke]

but something i remeber is like

[Ray Rahke]

if you do

class Whatever extends Publisher {
  events = { "update": () => ({fps: this.getFPS()}) }
}

you could then do anywhere else in the code

typeof Whatever['events']

[Ray Rahke]

and instantly know the event API of that publisher

[Ray Rahke]

since TS is able to infer literal anonymous objects

[Ray Rahke]

and then Event was like

[Ray Rahke]

class Event {
  from: Publisher
  label: keyof typeof Publisher['events']
  data: ReturnType<typeof Publisher[this['label']]>
}

[Ray Rahke]

I am guessing TS is the only language existing currently that can pull this off