Getter for mutable collections

Language Design
1

Last default encapsulation for mutables was something like:

private val _foo: MutableList<Int> = mutableListOf()
val foo: List<Int> = _foo

Here could be a simpler way with a single naming:

private val foo: MutableList<Int> = mutableListOf()
    public get () = field.toImmutableList()

Is it fine?

2

There is experimental compiler feature:

val foo: List<Int>
    field = mutableListOf()

See Explicit Backing Fields

2 Likes
3

Looks nice. Currently I’m trying to overpass it with

protected val foo: MutableList<Int> = mutableListOf()
fun getFoo(): List<Int> = foo

it works with a private but not with a protected foo because of same JVM signature error. Looks ok with internal visibility, there’s something wrong with Kotlin’s protected implementation.

4

There’s nothing wrong with it. Compiler can’t use automatic name mangling for items that could be accessed from outside of the module. You have to rename manually with @JvmName.

1 Like
5 
val foo: List<Int>
    field = mutableListOf()

what if we need something like this? Is it included in proposed getter?

class A(){
  protected var foo: MutableList<Int>? = null
    val getFoo(): List<Int>? = foo
  }

class B: A() {
  init {
      foo = mutableListOf(if (true) 1 else 3) 
    // There we don't need to check if list was created or make it empty
  }
}

And is it even will be possible to add such getter on a constructor parameter?

6

Looking a little larger use case than a single variable, if this is part of a class where that variable is exposed via an interface you can simply do this:

interface A {
    val foo: List<Int>
}

class AImpl : A {
   override val foo = mutableListOf()
}
7

Tried interface but I also need something like encapsulation and setter here. So, I did it this way:

class Foo(private var type: Int): Bar(someParams = something), MyInterface {
  fun setType(value: Int) {
  //update dependencies
  //send reactive event to update UI
  }
}