In the latter two cases, the variable can stand for any type, not necessarily a type variable as in these examples, i.e. the variable is existentially quantified.
In future versions of GHC, type variables will be rigid (universally quantified).
Hugs supports only pattern type signatures, with rigid type variables.

Tickets

Pros

Allows better documentation (without them, some expressions cannot be annotated with their types).

Extensions such as RankNTypes and GADTs require such annotations, so even more important in conjunction with them.

Cons

Many different forms of scoped type variables in GHC makes them hard to reason about.
For example:

f :: a -> a
f = \x -> (x :: a)

is rejected but

g = let f :: a -> a = \x -> (x :: a) in f

is allowed.

With pattern and result signatures, one must examine outer bindings to determine whether an occurrence of a type variable is a binding.
This creates a potential trap.
A rule like ExplicitQuantification might be needed if these were put into the standard.

Proposal 1

Both let-bound and lambda-bound type variables are in scope in the
body of a function, and can be used in expression signatures. However,
just as a let-binding can shadow other values of the same name, let-bound type variables
may shadow other type variables. Thus no type variables are ever already in scope in a let-bound signature.
Lambda-bound type variables (e.g. in a pattern) do not shadow but rather refer to
the same type. ExplicitQuantification is required for all expression type signatures
but not let-bound signatures.

This proposal tries to strike a balance between backwards compatibility,
avoiding accidental type errors, and simplicity. Let-bound type signatures always
create a new scope, lambda-bound ones are always in the same scope, and
it is clear from expression type signatures which are the scoped type vars.

(perhaps this text can be cleaned up further? what is a better term for expression type signature?)

Proposal 2

Restrict the above extensions to:

for function bindings, optional explicit foralls in type signatures.

for pattern bindings, result type signatures.
Explicit universal quantification might be made mandatory.