A modern programming language that makes developers happier.

kotlinlang

Can someone explain why this code doesn't compile, but it _does_ when I change `thing` to a `val`?
```interface A
interface B {
    var thing: A
}

class Foo : A

class Bar(
	override var thing: Foo
) : B```
When `thing` is a `var`, I get this error:
```Type of 'thing' doesn't match the type of the overridden 'var' property 'var thing: A' defined in '/B'.```

Return types of overriden functions can be subclasses of overridable function return type.
But for input parameters it is not true.
Val - is getter with return type of its type.
Var - is setter with input parameter of its type.

```override var thing: Foo
  // fun get() : Foo 
  // fun set(f: Foo)```

I see. It sort of reminds me of the concept of variance.

The reason this isn't allowed is that you could have the following:

```class Baz: A
val bar = Bar(Foo())
(bar as B).thing = Baz()
```
And now you've assigned a Baz to a Foo, despite them not being compatible