is it possible to make a class property that only the class itself can mutate, but is public to othe...

# getting-started

[y]

is it possible to make a class property that only the class itself can mutate, but is public to other classes? without making a getter?
I expected private set to do this, but it seems like I can still mutate the value from outside the class.

[Stephan Schroeder]

private set should indeed do this. can you provide the code?
I hope you mean outer mutability (/reassignability) x.list = otherList, not inner mutability x.list.clear()
Making the setter private will block the first one, but not the second one (since it only invokes the getter)

[y]

something like:

class Foo() {
    private var bar: Bar = Bar()
    
    class Bar() {
        var items: MutableList<Int> = mutableListOf()
            private set
    }

    fun doTheThing() {
        bar.items.clear() //compiles and works
    }
}

[Sam]

https://youtrack.jetbrains.com/issue/KT-14663/Support-having-a-public-and-a-private-type-for-the-same-property

[y]

so private set is just for the binding, the value itself is still mutable

[Nuru Nabiyev]

You have to use "val items:List<Int> = mutable"

[Sam]

As @Stephan Schroeder was alluding to, “mutable” kind of means two different things. Mutating a property is different from mutating the contents of an array/collection.

[Stephan Schroeder]

private set makes the setter private, but bar.items.clear() doesn't invoke the setter.

[y]

yeah.

[Stephan Schroeder]

additionally Bar is an inner class, so I'm not even sure that this restricts the access by the containing class.

[Landry Norris]

You can create an interface that exposes items: List<Int>, and implement it in a class as override items: MutableList<Int>. Anything that references your interface will have access to the immutable list, but inside your class, it’s mutable

[y]

seems like it does restrict access.

[Landry Norris]

I do this with StateFlow/MutableStateFlow for UI view models all the time.

[Stephan Schroeder]

what you can do is

class Bar() {
   private var _items: MutableList<Int> = mutableListOf()
   val items: List<Int> get() = _items // is typesafe but could run into ConcurrentModificationExcaption in multithreaded code, if the read-only copy is iterated on while the mutable version is changed
}

or harden this approach (the former approach still allows casting the reference back to MutableList ) like this

class Bar() {
   private var _items: MutableList<Int> = mutableListOf()
   val items: List<Int> get() = _items.toImmuatableList() //return only a static snapshot
}

with toImmuatableList coming from this lib https://github.com/Kotlin/kotlinx.collections.immutable

[y]

that’s an accpetable solution in my opinion, since it’s essentially a desugaring of the solution referenced in the issue tracker.

[y]

@Landry Norris can you clarify? I’m struggling to implement this

[y]

(also, thanks everyone for being helpful as always!)

[Stephan Schroeder]

wait, i made a mistake

[Landry Norris]

interface Bar {
    val items: List<Int
}

class Foo: Bar {
    override val items: MutableList<Int> = mutableListOf(0)
}

Any usage of Bar#items will be immutable.

[Stephan Schroeder]

it shouldn't be var but val
I updated the code.

[y]

@Landry Norris oh, I understand. nice. too much boilerplate for my throwaway class, but it’s something to keep in mind.