A modern programming language that makes developers happier.

kotlinlang

hi guys! just a question, does instantiating (ClassName()) act as an invoke, or can I add functionality to instantiating in some other way? currently have a function add that takes in a Component, though this looks rather bad. can I automatically call add on every instantiated object in my dsl? thanks!

You can put some logic in the `init` block:
```class Foo(arg: String) {
  init {
    println("Hello, $arg")
  }
}
```
Another way would be to make the constructor private and create a function instead:
```class Foo private constructor() {
  companion object {
    operator fun invoke(arg: String): Foo {
      println("Hello, $arg")
      return Foo()
    }
  }
}
```
Or, yet another way of doing it:
```private class Foo : IFoo

fun Foo(arg: String): IFoo {
  println("Hello, $arg")
  return Foo()
}```

the logic isnt handled by the class but by my dsl builder, so I want the builder’s add function to get called every time I make a new object, init/constructor wont work cuz that doesnt know who built it

<@U0GV75EMD> I already have functions for these, but I want to be able to create new ones without having to change the builder

Could you add samples of what you are trying to achieve?

```class MyUI : UI() {
    override fun build(): Component {
        root {
            add(VStack {
                add(Button(“click”))
            })
        }
    }
}```
this is my current setup, but I want to remove the `add` calls which looks redundant
edit: with VStack and Button both being classes extending Component, and root func creating a top level parent Component

Not quite sure how `add` is defined for you, but assuming it's a function like this:
```interface UiBuilder {
  fun add(...)
}
```
You could use extension functions:
```fun UiBuilder.VStack(builder: VStackUiBuilder.() -&gt; Unit) { add(...) }```