Lets say I have: ```interface Foo class Foo1 : Foo interface Bar { fun <T : Foo> baz(foo: T...

# getting-started

[dave08]

Lets say I have:

interface Foo
class Foo1 : Foo
interface Bar {
   fun <T : Foo> baz(foo: T)
}
// This doesn't work, why? It IS derived from Foo... is there any way to do such a thing w/o taking in a Foo and casting it to Foo1?
class Bar2 {
   override fun baz(foo: Foo1) = TODO()
}

[dave08]

I guess I had to move the type param to the class and it worked... still a bit cryptic why that works and not this...

[ephemient]

val bar: Bar
bar.baz(FooNotFoo1()) // legal according to signature, but not according to the Bar2 you wanted to write

[dave08]

But I had T: Foo there on the function...?

[Adam Powell]

T : Foo is not a Foo1

[dave08]

Oops, I corrected the example... I forgot the inheritence...

[dave08]

The override still doesn't work

[Adam Powell]

Because T : Foo is still not a Foo1

[dave08]

I thought T : Foo indicates "a class derived from `Foo`"...?

[Jacob]

to be an override it needs to be able to accept anything the parent can

[Jacob]

this method can only accept Foo1

[Jacob]

can't accept any other Foo

[dave08]

Oh... why should it be that way?

[dave08]

That particular implementation is only limiting things not expanding them... you can use override to limit a return type to not be nullable for example...?

[dave08]

So why not this too?

[ephemient]

limiting output is a subset of super's behavior

[dave08]

And limiting input not?

[ephemient]

limiting input is rejecting some of super's behavior

[ephemient]

if Bar2 implements Bar, Bar2 must be usable everywhere a Bar is

[Adam Powell]

you can use override to limit a return type to not be nullable for example...?

no, you cannot oh, return type, never mind.

[dave08]

Oh... I guess someone that tries using Bar won't succeed if the input is limited, whereas output not...

[Adam Powell]

right

[dave08]

Ok, that's much clearer now... thanks guys 👍🏼! Generics tends to be a bit confusing at times...