Yup the problem is that those fields are vars so it s ambigu

Question

Yup the problem is that those fields are vars so it s ambiguous whether to add to the existing collection or create a new one and put it in `x`

benleggiero · Answer

Okay but I don t care Either way the next line will have the collection I want Also there s no way to disambiguate it Really

karelpeeters · Answer

Well the same collection might be used elsewhere and maybe you can t just mutate it

karelpeeters · Answer

You can do ` allAll ` if you want to mutate or `y = y + x` to make a new one

benleggiero · Answer

Hopefully Valhalla will simplify this confused

karelpeeters · Answer

Huh Isn t Valhalla about value types This is just an unfortunate ambiguity

benleggiero · Answer

Swift takes advantage of value types to solve this ambiguity Instead of having a separate `Set` vs `MutableSet` Swift just has `Set` and whether it s mutable is decided by how it s declared Mutable sets can be fields declared with `var` or function parameters declared with `inout` When you mutate a Swift value type its copy on write system actually creates a complete memcopy of the original value with your mutations applied If the original is no longer accessible its variable name was mutated or reassigned it s immediately deallocated so there s no memory bloat from this behavior So bringing it back to Kotlin if there was just `Set` and no `MutableSet` we could do this no problem ``` var x = setOf lt Foo gt val y = setOf lt Foo gt Foo instance x += y OK y += x Impossible ``` Here `x` would be a mutable `Set` and `y` is an immutable `Set` Because `x` is a mutable value with copy on write semantics its contents is copied to a new location in memory mutated such that the contents of `y` are appended to the end and reassigned to the variable `x` The old contents are deallocated garbage collected whatever On the next line we have nonsense Not only is `y` an immutable set but its pointer is also immutable traditional `val` behavior So there is no `=` nor `+=` operator that would apply No more ambiguity much more expressive and intuitive I really hope Valhalla allows for this pray skin tone 3

karelpeeters · Answer

Is there no distinction between instance and reference mutability in Swift

araqnid · Answer

copy on write system this sounds like it s not a mutable map in the sense that Kotlin mutable maps are persistent is a widespread but confusing term for them

benleggiero · Answer

< karelpeeters> there is `struct`s and `enum`s are passed by value and the values themselves are never mutated but instead copied as described above when required This is similar to how JVM primitives are handled `class`es are passed by reference and act as one would expect This is similar to how JVM classes are handled This gives peace of mind that if you have an instance of a `struct` its value won t change from another thread or by passing it to a function unless you use the `inout` keyword

benleggiero · Answer

< araqnid> correct in Swift things that are passed by value aren t mutable in the common use of the term

karelpeeters · Answer

Is it possible to have a variable that has an immutable reference to a mutable list Or the other way around a mutable reference to an immutable list

benleggiero · Answer

Yes in Swift if you really care about passing a struct by reference you can wrap it in a class Since Swift classes don t have to inherit from anything this is very lightweight Then when you pass the wrapper class s instance by reference all its contents come with it by reference Also again using `inout` on a function parameter allows the function to mutate the contents in a way very similar to how one usually passes things by reference so there is rarely ever a reason to use the wrapper workaround

benleggiero · Answer

For example in Swift ``` let first = foo bar baz var second = first runtime takes note but does not yet copy anything print second foo bar baz var third = second same situation print third foo bar baz third 1 = qux the contents of `first` are copied into `third` and then mutated var fourth = third print first foo bar baz print second foo bar baz print third foo qux baz print fourth foo qux baz second remove at 2 contents of `first` are copied and mutated print first foo bar baz print second foo bar print third foo qux baz print fourth foo qux baz fourth append hoge print first foo bar baz print second foo bar print third foo qux baz print fourth foo qux baz hoge func mutate array inout String array append hello mutate amp second mutate amp fourth print first foo bar baz print second foo bar hello print third foo qux baz print fourth foo qux baz hoge hello ```