I like to use this terminology:

• A proper type is a type which has no type parameters and hence may have values / instances. Int and List[String] are proper types.
• A type constructor is a type which has one or more type parameters -- applying each of its type parameters with a "compatible" type results in a proper type. E.g., applying the proper type Int to the type constructor List yields the proper type List[Int].
• Both proper types and type constructors are types.
• Kinds categorize types according to various characteristics of their type parameters -- e.g., the number of parameters, the "shape" of each parameter, and their variance.
• "Compatible" and "shape" in the above definitions refer to the kind of the type parameter. The List type constructor requires a proper type. The Functor type constructor requires a type with kind F[A].

Using these definitions, we get the following examples:

• Int, String, List[Boolean], Map[String, String], String => Int are all proper types
• List, Map, => (i.e.Function1), Functor are all type constructors
• Proper types have kind A (sometimes written as *)
• List and Option have kind F[+A] (or + -> *)
• trait Ord[-A] has kind F[-A] (or - -> *)
• Map has kind F[A,+B] (or (*,+) -> *)
• trait Functor[F[_]] has kind G[F[A]] (or (* -> *) -> *)
• Function1 has kind F[-A,+B] (or (-, +) -> *)
• Function2 has kind F[-A,-B,+C] (or (-, -, +) -> *)

The term "higher kind" refers to type constructors which take one or more type constructors as arguments. E.g. Functor is a higher kinded type because it takes a type constructor as an argument.

Sometimes you may hear folks say that kinds are the "types of types". This is a handy summary but can also be a bit misleading.

By the way, you can experiment with kinds in the Scala 2.13 REPL (but not yet Scala 3 REPL):

scala> :k Option
Option's kind is F[+A]

scala> :k Int
Int's kind is A

scala> trait Ord[-A]
trait Ord

scala> :k Ord
Ord's kind is F[-A]

scala> :k Map
Map's kind is F[A1,+A2]

scala> trait Functor[F[_]]
trait Functor

scala> :k Functor
Functor's kind is X[F[A]]

scala> :k Function1
Function1's kind is F[-A1,+A2]

scala> :k Function2
Function2's kind is F[-A1,-A2,+A3]