I am confused about secondary constructors. Kotlin...

# getting-started

[Draget]

I am confused about secondary constructors. Kotlint avoid having an incomplete object constructed by forcing me to immediatly call the primary constructor. But I do not know how I can actually calculate the value for the primary constructor - I want to run code to calculate the value, that is the whole point of the second constructor.

I can do it by using a function:

private data class MyClass(val intVal: Int) {
    constructor(stringVal: String) : this(someFunction(stringVal))
}

fun someFunction(stringVal: String): Int {
    println("I can run some random code here")
    val foo = stringVal.reversed()
    return foo.toInt()
}

But how could I run code on the secondary constructor without using a function?

[ephemient]

note that Java has the same limitation, you cannot run any whole blocks of code before delegating to another constructor, only expressions

[ephemient]

but in Kotlin, expressions are very expressive, and include things like run { ... }

[ephemient]

so you could, in theory, write

private data class MyClass(val intVal: Int) {
    constructor(stringVal: String) : this(
        run {
            println("I can run some random code here")
            val foo = stringVal.reversed()
            return@run foo.toInt()
        }
    )
}

[ephemient]

I thnk it's poor style, though

[ephemient]

it would be more Kotlin-esque to have a constructor-like function,

fun MyClass(stringVal: String) : MyClass {
    println("I can run some random code here")
    val foo = stringVal.reversed()
    return MyClass(foo.toInt())
}

[Draget]

I see.

Would this function live inside the class? I guess I should treat it like a factory method then.

[ephemient]

no, outside

[ephemient]

there is an alternative placement

class MyClass private constructor(...) {
    companion object {
        operator fun invoke(...): MyClass {
            // arbitrary logic here
            return MyClass(...)
        }
    }
}

but I'd only use it in cases where the function outside doesn't work due to visibility

[Draget]

Funny, I never realized this 'issue' in Java, because it is common to have a constructor that copies the values to an internal variable.

Doing it like this allows multiple constructors initializing the Instance.

In Kotlin it is made just way more visible that in this case, I have an uninitalized object in that moment.

I guess I could do this in Kotlin:

private data class MyClass(var intVal: Int) {
    constructor(stringVal: String) : this(0) {
        this.intVal = stringVal.toInt()
    }
}

[Draget]

But why would you conside a factory-like Method inside the class, bad style?

private data class MyClass(var intVal: Int) {
    companion object {
        fun ofString(stringVal: String): MyClass = MyClass(stringVal.toInt())
    }
}

[ephemient]

that's fine, although (depending on the use case) it may be more natural as an extension function,

fun String.toMyClass(): MyClass

[Draget]

In cases where I need this as a kind of helper in my current class, I usually use extension functions.

But if I want the ability to be created from a String to be something of my class, it should be part of said class… at least that is what I would consider proper separation of concerns.

[Draget]

Thanks for the input. 🙂 I think I got a better feel for it now.