A modern programming language that makes developers happier.

kotlinlang

It's not about extending it, it's about the fact that anyone that has access to `Foo` has to have access to its generic types.

No it doesnt because generic param is not part of any public api, that is exactly what confuses me. Callsite cant see Quax in any form

Aren't there fields or functions that use the generic param? If not, why is there a generic?

basically its this

```
class FooFragment : BaseFragment&lt;FooViewMode&gt; {

	override fun onCreateViewModel() {
		return FooViewModel()
	}
}

class BaseFragment&lt;T&gt; {
	protected lateinit var viewModel: T

	override fun onCreateView(view: View) { &lt;-- framework
		viewModel = onCreateViewModel()
	}

	protected abstract fun onCreateViewModel() : T
}
```

i.e. FooViewModel is implementation detail of FooFragment, I see no reason to expose it publicly; viewModel reference is protected inside BaseFragment hierarchy..idk

Because I can call `FooFragment.onCreateViewModel()`

Yes, but that's kind of beside the point. There's no way the compiler can understand that.

isnt this some sort of javainterop bs? I think protected is also package private in java

They can't understand visibility of completely unrelated things. The fact that your function is private has nothing to do with the generic parameter. For example: if that class comes from an external library, and the function gets changed to public, anyone using your code somehow magically needs access to an object they can't see.

The generic type and the function visibility have nothing to do with each other.

I dont get it what you mean, if it gets change to public it wont compile, same how if private function returns a private class, and you change it to public it wont compile

But private only works withing the same class/file. Protected can jump between libraries.

im still not sure why does the param need to be public, im trying even simpler example

```
class Bar : Foo&lt;Quax&gt;() 

abstract class Foo&lt;T&gt;

internal class Quax
```
error is `public sublcass exposes internal supertype argument`

Btw it works in java with package private T_T

```
public class Rah extends Meh&lt;Ohe&gt; {
}

class Ohe {
}

abstract public class Meh&lt;T&gt; {
}
```

this is precisely what I want in kotlin (swap package private for internal)

it only complains if Ohe is private (nested)