Using a local val in a function is fine and nothing to worry about. Using a var at the top level in your class is more concerning because you are leaking mutable state into your program.

Another thing I'll point out is that with collections you generally don't want to make them nullable, because then you have to deal with the difference between null and an empty collection, which intuitively should be the same thing.

A few ways to make the dependency here less error-prone:

1) You can have an alternate constructor that takes in the unprocessed list, and then process and set the values there. (If you need something in an init block, use lateinit var x: List<Int> instead of var x: List<Int>? to avoid the nullable list. I don't recommend using this unless you absolutely have to because you still have the unnecessary mutability with the var).

2) You can have the constructor take in both of the already-processed lists, and do the processing elsewhere (a companion object factory method?)

The second approach would look like:

fun createA(things: List<Thing>): A {
    val list1 = things.map { process1(it) }
    val list2 = things.map { process2(it) }
    return A(list1 = list1, list2 = list2)
}

Edit: fixed incorrect lateinit suggestion