Yes, there is very good support for type functions in Clay. In
addition to regular arguments, any Clay procedure can have 'static'
arguments. Static arguments are directly pattern matched with the
value specified at the call site and can result in one or more pattern
variables being bound. Static arguments are useful for writing type
functions.

Here is an example. Note: overloadable procedures are declared using
the 'overloadable' keyword. Each overload case is separately specified
using the 'overload' keyword.

overloadable SequenceElementType;

overload SequenceElementType(static String) {
    return Char;
}

[T,n]
overload SequenceElementType(static Array[T,n]) {
    return T;
}

[T]
overload SequenceElementType(static Vector[T]) {
    return T;
}

To call this procedure, simply pass a type as the first argument
"SequenceElementType(Vector[Int])". 'SequenceElementType' can now be
used as part of predicate expressions.

As can be seen in this example, types can be returned from a
procedure. This is possible because every type, T, is a first class
value of a unique singleton type. Because the type of a type is a
unique singleton type no runtime representation is required.

Being able to use arbitrary user defined code as part of type
requirement specifications is a big advantage in Clay. This gives a
lot of power and simplicity not available with Haskell type classes or
C++ concepts. This is made possible because an interpreter for the
full Clay language is available as part of the compiler.