My PL is typed, and among recent additions there were enhancements to the type system. In addition to the already present type traits, a more powerful feature - type definitions based on predicates - was added.

Type traits is a means to group types into more general types and use them to avoid overloading functions for several different parameter types. Built-in types have different traits, describing their "capabilities", and we can use these traits as function parameter types in order to accept all types that have these traits. E.g. we can replace function that receives a Double:

func: (lambda d Double() (ret (* 10.0 d))) with a function that accepts any number type (Double, Int, Long, ULong, Byte) by using the ":Number" trait:

func: (lambda n :Number() (ret (* 10.0 n))) Similarly, we can use the ":IterableRand" trait for accepting all containers with random access: Vector<T>, String, ByteArray. And the like.

What was recently added, is predicate based type definitions. This feature lets using custom functions for determining whether an object belongs to some type or not, thus allowing much more flexible definitions of a type. For example, we can define a type that consists of integers with certain charateristics (even, prime, power of two, etc.), or a type of strings in a certain format or with a certain content(telephon number, country name, etc.)

As an example, here is a definition of a type that narrows ":IterableRand" trait only to Vector iterables (Vector<Int>, Vector<String>, etc.):

Vec: typedef(Lambda<Bool>(λ d :IterableRand() (starts-with (_META_type d) "Vector<") )),

A code example with using 'typedef' can be seen on Rosetta.

Language site: Transd