How to denote existential higher kinded type?

Type definitions are like functions on type level type L[T <: W] = ??? means that L accepts W subtypes as argument and return some stuff. How should I denote any type function like L, i.e. that accepts exactly one argument of W subtype? I’d like to make TList out of such L and apply the same argument to them all.

It should be simple and frequently used expression, but some block inside my head prevents me from expressing it. Could anyone hint me with example?

Here’s a whole example. HKL1 and HKL2 have a parameter kind that L's kind conforms to.

abstract class Example {
  type W

  type Wide[T]
  type L[T <: W]

  type Lower <: W
  type NL[T >: Lower <: W]

  // These two mean exactly the same thing
  type HKL1[L[T <: W]]
  type HKL2[_[_ <: W]]

  type Ex1 = HKL1[L]
  // This makes sense, and is very important; you have to check the
  // rules about higher-kinded conformance in the spec to understand
  // how this works, though.
  type Ex2 = HKL1[Wide]

   The next line gives an error, and *rightly so*:

   KBounds.scala:19: kinds of the type arguments (Example.this.NL)
        do not conform to the expected kinds of the type parameters (type L).
   Example.this.NL's type parameters
        do not match type L's expected parameters:
   type T's bounds >: Example.this.Lower <: Example.this.W
        are stricter than type T's declared bounds <: Example.this.W
  type Ex3 = HKL1[NL]