A is a type.
F[A] is also a type. Is there language that exists to differentiate the two?
Dunno about in Scala, but in Haskell, the Report does distinguish between two syntactic categories: "types" and "constructors". Constructors are just those types which are single atoms, beginning with an upper case letter, and created by
newtype declarations. e.g.
data Foo a = Bar
creates a new type constructor
Foo (and a new data constructor
Bar), and types can be formed by applying
Foo to another type. Of course, constructors need not be of higher kind;
data Baz = Quux also declares a type constructor named
Baz which is not permitted to be applied to any other types.
(But beware: it is common to use "type constructor" to mean "any type-level expression with an arrow kind", so if you are doing some technical writing, you should include some text in your introduction clarifying which of these two meanings you intend to use in the rest of the document.)
So, in your example, we could say
Map is a constructor,
Char is a constructor,
Int is a constructor,
Map Char is a type, and
Map Char Int is a type.
As far as I know, there is no common shorthand term for any of these categories: "a type which is definitely not a constructor", "a type of kind
*", "a type which is definitely not of kind
*". For types which are allowed to be applied to another type, there is the term "higher-kinded type" -- e.g.
Map Char are both higher-kinded types.