Why does += for MutableList behave differently from = with +? It's a bit weird and also against with liskov substitution because for List += works exactly like = with +

What's the difference in behavour? No new list is created?

+=

doesn't work on

val list:List<T>

, but does work with

val mutableList:MutableList<T>

. It also works on

var list:List<T>

but IIRC on

var mutableList<T>

it doesn't work because it is ambiguous. AFAIK liskov substitution principle isn't violated.

It still is a bit strange that

val mutableList += a

adds a, while

var mutableList = mutableList + a

creates a copy. It feels like

+

and

+=

do 2 different things (and they do). In this special case

+=

is not implemented as

a = a + b

whcih I think is what is meant by @yawkat. But as you pointed out

+=

is not vallid on mutable lists that are assigned to a

var

so this is not really a problem.

liskov substitution also applies to static type changes

a += b

is always equivalent with

a = a+b

. but if both assignPlus and

plus

have been defined on a, there is ambiguity.

why? if i replace the static type of the variable with a subtype, the behavior changes

No, in this case it's 2 different functions that happen to have the same name. It's like saying this violates liskov cause

hi(String)

returns a

String

which doesn't extend

Pair<String,Any>

fun hi(name:Any) = "hi" to name
fun hi(name:String) = "hi, $name!"

i know that, but this is an item in effective java

no, liskov is about subtypes following the method contract of the supertype

It's a bit unfortunate, yes. I can't imagine ever wanting

+=

to mean "create a new list with an extra element".

eh, that's the sane behavior, because thats exactly what + does