Types

The Types category holds functions for asking, at runtime, what kind of thing a value is, along with a small set of helpers that introspect functions and type descriptors. Each is callable in prefix form fn(x, …) or postfix/UFCS form x fn(…).

Most of these are reflection predicates named is…Type. They overlap with two other type-checking mechanisms documented in Types and Coercion, and it helps to keep the three straight:

• x is Type (operator) — the idiomatic way to test a value's type, written with a bare type name: 42 is Number → true.
• typeOf(x) (Core) — returns the value's type name as a String, one of the runtime type names ("String", "Number", … "Function" for lambdas).
• is…Type(x) (this category) — a predicate per type. Unlike the is operator, each is…Type function accepts either a runtime value or a type-name String: isStringType("hello") and isStringType("String") both return true. They also recognize a second tier of descriptor-only labels that aren't real runtime types (see below).

Descriptor-only labels. Six of the predicates — isBinaryType, isUriType, isNamespaceType, isRangeType, isTypeType, isLiteralType (and isFunctionType) — correspond to labels that exist only for reflection. There is no Binary or Uri value in TransformScript (binary data is just a String of bytes), so these predicates only ever return true when handed the matching label String, e.g. isBinaryType("Binary"). The remaining predicates correspond to the real runtime types and answer truthfully for actual values.

Type Predicates (is…Type)

Every predicate takes one argument (:any) and returns a Boolean. The argument may be a live value (isNumberType(42)) or a type-name/label String (isNumberType("Number")).

Used as a filter predicate with the $ shorthand:

[1, "a", 2, "b"] filter($ isNumberType())   // → [1, 2]

Examples with temporal values need |…| literals (which contain | and can't sit in a table cell):

isDateType(|2024-01-02|)                  // → true
isDateTimeType(|2020-10-01T23:57:59-07:00|)  // → true
isLocalDateTimeType(|2020-10-01T23:57:59|)   // → true
isLocalTimeType(|23:57:59|)               // → true
isTimeType(|23:57:59|)                     // → true (same underlying value as LocalTime)
isPeriodType(|P1D|)                        // → true

Time / LocalTime aliasing is one-way for labels. A live time value answers true to both isTimeType and isLocalTimeType. For label Strings, isTimeType accepts both "Time" and "LocalTime", but isLocalTimeType("Time") → false — it only matches "LocalTime". typeOf(|23:57:59|) is "LocalTime".

Function and Type Introspection

These read structure out of a function value or a function type descriptor. A descriptor is an Object carrying a type (or kind) of "Function" plus paramTypes and returnType keys. Because type is a reserved word in the TransformScript lexer, descriptor Objects must use a quoted key: { "type": "Function", … }.

With a descriptor Object (quoted "type" key required):

functionParamTypes({ "type": "Function", "paramTypes": ["String", "Number"], "returnType": "Boolean" })
// → ["String", "Number"]

functionReturnType({ "type": "Function", "paramTypes": ["String"], "returnType": "Boolean" })
// → "Boolean"

functionParamTypes on a lambda returns parameter names, not their types — lambdas are untyped, so the names are all that's known. Passing a non-function (e.g. functionParamTypes("hello")) raises Expected Function type, got String.

typePredicate is not callable on its own. It is the base for the is…Type predicates and has no type of its own to test. Use the concrete is…Type predicates instead.

Related

• Types and Coercion — the runtime types, the is operator, typeOf, and the coercion mechanisms.
• Coercions — toString, toNumber, toDate, and the rest of the toX conversion functions.
• Function Library — all categories.
• Functions and Lambdas — calling conventions, UFCS, lambdas, and the $ shorthand.