As for using partially-applied type constructor arguments, I do it several times a day on a commercial project without blinking an eye.

I guess it depends on what you see as a kind declaration. To me, a kind declaration has to be something of the following form:

Bifunctor :: * => * => *

(shamelessly borrowing from Haskell and formal kind notation)

I would see this as an *explicit* kind annotation, where as Bifunctor[F[_, _]] is perhaps more of an *implicit* notational form. I suppose that technically, they’re both a way of declaring kind, at some level. The difference would be that the explicit notation is actually defining the kind, whereas Scala’s implicit notation is implying a kind by being extremely explicit about the type.

I was aware of the partially-applied type constructors idea — I read Mitch’s blog whenever I need convincing that I know a lot less than I think I do. It is definitely a neat trick, though I can’t see myself ever using it for any real-world application. One possible exception would be a DSL which type-checks some advanced concept. Thus, a DSL which is correct (or rather, *runnable*) by construction. However, given how horribly explicit Scala’s type system can be, I doubt the syntax would ever be accepted.

There is one

// this contains a kind declaration
Bifunctor[F[_, _]]

Consider Haskell:

-- no kind declaration though with GHC extensions it is possible
class Bifunctor f

Nevertheless, this is not what I meant. Rather, type constructors of a higher-kind are never inferred.

While Scala’s type constructors are uncurried, this is not too bothersome in this example, however, it certainly can be. There is a neat trick that allows you to partially apply type variables.

For example

trait PartialType[T[_, _], A] {
  type Apply[B] = T[A, B]
 
  type Flip[B] = T[B, A]
}

This allows you to declared type constructors such as:

Bifunctor#Apply[Int]
// or
Bifunctor#Flip[String]

trait Bifunctor[F[+_, +_]] {

I don’t see any kind declaration here. Scala *infers* that F is of kind * => * => * (or perhaps more correctly, (*, *) => *). In fact, there is no way (in Scala) to ever declare that a type is of one kind or another, you have to trust the compiler to figure it out every time.

Therein lies the problem, as it means that you have to be painfully explicit about some declarations (such as Bifunctor). A language with a more universal type inference/reconstruction would be able to see that we’re instantiating the F type constructor within the declaration for the bimap method, thus it must be of a certain kind.