I mean, I understand why this interaction works this way, but it still makes me sad :white_frowning_...

# announcements

[Hullaballoonatic]

I mean, I understand why this interaction works this way, but it still makes me sad ☹️
https://pl.kotl.in/_g7Nag0rP
in my particular use case, it'd be nice if the Bar1 was also added to foos, but I imagine in other cases, that would be horrendous

[Ruckus]

What about that makes you sad?

[Hullaballoonatic]

i updated the message

[Ruckus]

Hm, why does the constructor of Bar1 not throw? You can't do '+= on null

[Hullaballoonatic]

oh, because foos hasn't been instantiated yet?

[Ruckus]

It looks like Bar1 isn't actually instantiated till it's used:

class EffectBuffer<P : Any>(val key: String, type: PaintType<P>) {
    val blend = ShaderProperty.dynamic(
        type.blendType,
        "Blend",
        "Blending Mode",
        type.defaultBlend
    )

    val shaders = mutableListOf<Shader<P>>()
}

abstract class Foo(val name: String = "Foo") {
    init {
        println("Instantiating $name")
        foos += this
        println(foos)
    }

    override fun toString() = name
}

object Bar1 : Foo("Bar1")

val foos = mutableListOf<Foo>()

fun main() {
    val bar2 = object : Foo("Bar2") {}
    foos.forEach(::println)
    println(Bar1.name)
}

[streetsofboston]

foos is not null. You can have forward declarations. Circular declarations may have some weird behavior, though.

[Hullaballoonatic]

hmm, that's actually really interesting

[Hullaballoonatic]

learning experience!

[Ruckus]

Indeed, that could be useful information.

[streetsofboston]

If the ‘dependency’ tree is a-cyclical, Kotlin can figure out when to instantiate what vals/vars

[streetsofboston]

abstract class Base(val base: Base?, val id: Int) {
    init {
        println("Initing $base with id $id")
    }
}

object A: Base(B, 1)
object B: Base(A, 2)

fun main() {
    println("{$A.base} and ${B.base}")
}

Cyclical ; not sure if behavior is defined or undefined, but I guess you shouldn’t count on it 🙂

[Hullaballoonatic]

ah, good to know

[Ruckus]

Interesting, because this seems to work fine (neither val is null):

object A {
    val b = B
}

object B {
    val a = A
}

fun main() {
    println(A.b)
    println(B.a)
}

[streetsofboston]

But to your point, initialization is somewhat lazy:
try

abstract class Base(val base: Base?, val id: Int) {
    init {
        println("Initing $base with id $id")
    }
}

object A: Base(B, 1)
object B: Base(A, 2)

fun main() {
    println("Main")
    println("{$A.base} and ${B.base}")
}

You’ll see that Main is printed before the Initing .. ones

Main
Initing null with id 2
Initing cycle.B@2c7b84de with id 1
{[e-mail]} and null

[louis993546]

all you need to do is to use Bar1
https://pl.kotl.in/z0dp394Jk

[Hullaballoonatic]

@Ruckus I think because when you call println(A.b) it instantiates A, which then calls B to set A.b, so now B is being instantiated, which then calls A to set B.a, which is already instantiated

[streetsofboston]

More evidence object initialization is a bit lazy.

[Hullaballoonatic]

@louis993546 I guess this is a case for ping!
fun Any.ping() = this