A constraint that is always/unconditionally fulfilled. This behaves the same way as (), when appearing in a constraint-tuple, i.e. it does not change anything about the constraints. It is thus the identity of the (,) monoid in the constraint kind.

A constraint that never is fulfilled, in other words it is guaranteed that something whose context contains this constraint will never actually be invoked in a program.

A parametric non-constraint. This can be used, for instance, when you have an existential that contains endo-functions of any type of some specified constraint.

data GenEndo c where
  GenEndo :: c a => (a -> a) -> GenEndo c

Then, you can have values like GenEndo abs :: GenEndo Num. It is also possible to have GenEndo id :: GenEndo Num, but here the num constraint is not actually required. So what to use as the c argument? It should be a constraint on a type which does not actually constrain the type.

idEndo :: GenEndo Unconstrained
idEndo = GenEndo id

This constraint can never be fulfilled. One application in which this can be useful is as a default for a class-associated constraint; this basically disables any method with that constraint: so it can safely be left undefined. We provide the nope method as a special form of undefined, which actually guarantees it is safe through the type system. For instance, the old monad class with its controversial fail method could be changed to

class Applicative m => Monad m where
  (return,(>>=)) :: ...
  type FailableResult m :: * -> Constraint
  type FailableResult m = Impossible  -- fail disabled by default
  fail :: FailableResult m a => String -> m a
  fail = nope

This would turn any use of fail in a “pure” monad (which does not actually define fail) into a type error. Meanwhile, “safe” uses of fail, such as in the IO monad, could be kept as-is, by making the instance

instance Monad IO where
  (return,(>>=)) = ...
  type FailableResult m = Unconstrained
  fail = throwErrow

Other instances could support the fail method only selectively for particular result types, again by picking a suitable FailableResult constraint (e.g. Monoid).

Like Unconstrained, but with kind signature k -> k -> Constraint (two unconstrained types).

A term-level witness that the context contains a Disallowed constraint, i.e. one of the Impossible0, Impossible ... constraints. In such a context, because you are guaranteed that it can under no circumstances actually be invoked, you are allowed to to anything whatsoever, even create a value of an uninhabited unlifted type.