std.traits

Alternate name for Parameters, kept for legacy compatibility.

Get a tuple of the storage classes of a function's parameters.

Alternate name for ParameterDefaults, kept for legacy compatibility.

Returns the FunctionAttribute mask for function func.

Determines what kind of variadic parameters function has.

Alternate name for Fields, kept for legacy compatibility.

Get a AliasSeq of all base classes of T, in decreasing order, followed by T's interfaces. TransitiveBaseTypeTuple!Object yields the empty type tuple.

Returns an alias to the template that T is an instance of. It will return void if a symbol without a template is given.

ditto

Returns a AliasSeq of the template arguments used to instantiate T.

ditto

Returns the target type of a pointer.

Alternate name for isExpressions, kept for legacy compatibility.

Get the Key type of an Associative Array.

Get the Value type of an Associative Array.

The parameter type deduced by IFTI when an expression of type T is passed as an argument to a template function.

For all types other than pointer and slice types, DeducedParameterType!T is the same as T. For pointer and slice types, it is T with the outer-most layer of qualifiers dropped.

ditto

Is From implicitly convertible to To?

Is From spec/const3 to To?

Detect whether T is a built-in boolean type or enum of boolean base type.

Detect whether T is a built-in floating point type.

See also: spec/traits

Detect whether T is a scalar type (a built-in numeric, character or boolean type).

See also: spec/traits

Detect whether T is a basic type (scalar type or void).

Detect whether T is a built-in signed numeric type.

Detect whether T is one of the built-in string types.

The built-in string types are Char[], where Char is any of char, wchar or dchar, with or without qualifiers.

Static arrays of characters (like char[80]) are not considered built-in string types.

Detect whether type T is a narrow string.

All arrays that use char, wchar, and their qualified versions are narrow strings. (Those include string and wstring).

Detects whether T is a comparable type. Basic types and structs and classes that implement opCmp are ordering comparable.

ditto

Detect whether type T is a static array.

See also: spec/traits

Detect whether type T is an array (static or dynamic; for associative arrays see isAssociativeArray).

Detect whether T is an associative array type

See also: spec/traits

Detect whether type T is a builtin type.

Detect whether type T is a SIMD vector type.

Detect whether type T is a pointer.

Returns true if T can be iterated over using a foreach loop with a single loop variable of automatically inferred type, regardless of how the foreach loop is implemented. This includes ranges, structs/classes that define opApply with a single loop variable, and builtin dynamic, static and associative arrays.

Returns true if T is not const or immutable. Note that isMutable is true for string, or immutable(char)[], because the 'head' is mutable.

Returns true if T is an instance of the template S.

Detect whether symbol or type T is a function pointer.

Detect whether symbol or type T is a delegate.

Detect whether symbol or type T is a function, a function pointer or a delegate.

Gives a template that can be used to apply the same attributes that are on the given type T. E.g. passing inout shared int will return SharedInoutOf.

Get the full package name for the given symbol.

Get the module name (including package) for the given symbol.

Get the type of the return value from a function, a pointer to function, a delegate, a struct with an opCall, a pointer to a struct with an opCall, or a class with an opCall. Please note that ref is not part of a type, but the attribute of the function (see template functionAttributes).

Get, as a tuple, the types of the parameters to a function, a pointer to function, a delegate, a struct with an opCall, a pointer to a struct with an opCall, or a class with an opCall.

Returns the number of arguments of function func. arity is undefined for variadic functions.

ditto

Convert the result of spec/traits to ParameterStorageClass enums.

Get, as a tuple, the identifiers of the parameters to a function symbol.

Get, as a tuple, the default values of the parameters to a function symbol. If a parameter doesn't have the default value, void is returned instead.

ditto

Checks whether a function has the given attributes attached.

true if func is @safe or @trusted.

true if func is @system.

Determine the linkage attribute of the function.

ditto

Get the function type from a callable object func, or from a function pointer/delegate type.

Using builtin typeof on a property function yields the types of the property value, not of the property function itself. Still, FunctionTypeOf is able to obtain function types of properties.

Constructs a new function or delegate type with the same basic signature as the given one, but different attributes (including linkage).

This is especially useful for adding/removing attributes to/from types in generic code, where the actual type name cannot be spelt out.

Ditto

Determines whether T is a class nested inside another class and that T.outer is the implicit reference to the outer class (i.e. outer has not been used as a field or method name)

Determines whether T has its own context pointer. T must be either class, struct, or union.

See also: spec/traits

Determines whether T or any of its representation types have a context pointer.

Get as a tuple the types of the fields of a struct, class, or union. This consists of the fields that take up memory space, excluding the hidden fields like the virtual function table pointer or a context pointer for nested types. If T isn't a struct, class, interface or union returns a tuple with one element T.

Get as an expression tuple the names of the fields of a struct, class, or union. This consists of the fields that take up memory space, excluding the hidden fields like the virtual function table pointer or a context pointer for nested types. Inherited fields (for classes) are not included. If T isn't a struct, class, interface or union, an expression tuple with an empty string is returned.

Get the primitive types of the fields of a struct or class, in topological order.

Returns true if and only if T's representation includes at least one of the following:

1. a raw pointer U* and U is not immutable;
2. an array U[] and U is not immutable;
3. a reference to a class or interface type C and C is not immutable.
4. an associative array that is not immutable.
5. a delegate.

Returns true if and only if T's representation includes at least one of the following:

1. a raw pointer U*;
2. an array U[];
3. a reference to a class type C;
4. an associative array;
5. a delegate;
6. a [context pointer][isNested].

Returns true if and only if T's representation includes at least one of the following:

1. a raw pointer U* and U is not immutable or shared;
2. an array U[] and U is not immutable or shared;
3. a reference to a class type C and C is not immutable or shared.
4. an associative array that is not immutable or shared.
5. a delegate that is not shared.

True if S or any type directly embedded in the representation of S defines an elaborate assignment. Elaborate assignments are introduced by defining opAssign(typeof(this)) or opAssign(ref typeof(this)) for a struct or when there is a compiler-generated opAssign.

A type S gets compiler-generated opAssign if it has an elaborate destructor.

Classes and unions never have elaborate assignments.

Whether the symbol represented by the string, member, exists and is a static member of T.

Retrieves the members of an enumerated type enum E.

Note: Returned values are strictly typed with E. Thus, the following code does not work without the explicit cast: -------------------- enum E : int { a, b, c } int[] abc = cast(int[]) [ EnumMembers!E ]; -------------------- Cast is not necessary if the type of the variable is inferred. See the example below.

Get a AliasSeq of the base class and base interfaces of this class or interface. BaseTypeTuple!Object returns the empty type tuple.

Get a AliasSeq of all base classes of this class, in decreasing order. Interfaces are not included. BaseClassesTuple!Object yields the empty type tuple.

Returns a tuple of non-static functions with the name name declared in the class or interface C. Covariant duplicates are shrunk into the most derived one.

Returns class instance alignment.

See also: spec/traits

Get the type that all types can be implicitly converted to. Useful e.g. in figuring out an array type from a bunch of initializing values. Returns void if passed an empty list, or if the types have no common type.

Determines whether the function type F is covariant with G, i.e., functions of the type F can override ones of the type G.

Detect whether T is a built-in integral type. Integral types are byte, ubyte, short, ushort, int, uint, long, ulong, cent, ucent, and enums with an integral type as its base type.

Detect whether T is a built-in numeric type (integral or floating point).

Detect whether T is a built-in unsigned numeric type.

Detect whether T is one of the built-in character types.

The built-in char types are any of char, wchar or dchar, with or without qualifiers.

Detect whether type T is a string that will be autodecoded.

Given a type S that is one of:

1. const(char)[]
2. const(wchar)[]

Type T can be one of:

1. S
2. implicitly convertible to T
3. an enum with a base type T
4. an aggregate with a base type T

with the proviso that T cannot be a static array.

Detect whether type T is a dynamic array.

Detect whether type T is an aggregate type.

ditto

Check whether the tuple T is an expression tuple. An expression tuple only contains expressions.

Detect whether T is a callable object, which can be called with the function call operator (...).

Determines if f is a function that requires a context pointer.

Removes shared qualifier, if any, from type T.

Note that while immutable is implicitly shared, it is unaffected by Unshared. Only explict shared is removed.

Copies type qualifiers from FromType to ToType.

Supported type qualifiers:

• const
• inout
• immutable
• shared

Returns the type of ToType with the "constness" of FromType. A type's constness refers to whether it is const, immutable, or inout. If FromType has no constness, the returned type will be the same as ToType.

Returns the inferred type of the loop variable when a variable of type T is iterated over using a foreach loop with a single loop variable and automatically inferred return type. Note that this may not be the same as std.range.ElementType!Range in the case of narrow strings, or if T has both opApply and a range interface.

Strips off all enums from type T.

Returns the largest type, i.e. T such that T.sizeof is the largest. If more than one type is of the same size, the leftmost argument of these in will be returned.

Returns the corresponding signed type for T. T must be a numeric integral type, otherwise a compile-time error occurs.

Returns the most negative value of the numeric type T.

Get the type that a scalar type T will promote to in multi-term arithmetic expressions.

Aliases itself to T[0] if the boolean condition is true and to T[1] otherwise.

Gets the matching spec/attribute from the given symbol.

If the UDA is a type, then any UDAs of the same type on the symbol will match. If the UDA is a template for a type, then any UDA which is an instantiation of that template will match. And if the UDA is a value, then any UDAs on the symbol which are equal to that value will match.

Detect whether symbol or type X is a function. This is different that finding if a symbol is callable or satisfying is(X == function), it finds specifically if the symbol represents a normal function declaration, i.e. not a delegate or a function pointer.

Detect whether X is a final method or class.