Unstandard

Bitbucket Page

Unstandard

Additions to std.traits.

License
Boost License 1.0.
Authors
Denis Shelomovskij

template  ArrayElementType(T : T[])

Returns the element type of an array.

For ranges, see also std.range.ElementEncodingType.

Examples
static assert( is(ArrayElementType!(int[]) == int));
static assert(is(ArrayElementType!(int[7][8]) == int[7]));
static assert(is(ArrayElementType!string == immutable(char)));

template  staticArrayDims(T)

Gets the rank (number of dimensions) of a static array type.

If T isn't a static array assumes it to be a zero-dimensional static array with single element and returns zero.

Examples
static assert(staticArrayDims!int == 0);
static assert(staticArrayDims!(int[]) == 0);
static assert(staticArrayDims!(int[0]) == 1);
static assert(staticArrayDims!(int[7][8]) == 2);
static assert(staticArrayDims!(int[0][]) == 0);
static assert(staticArrayDims!(int[][0]) == 1);

template  MultidimStaticArrayElementType(T, size_t n = staticArrayDims!T)

Gets the element type of the innermost array in a multidimensional static array type. Considers T to be an n-dimensional static array type.

If T isn't a static array assumes it to be a zero-dimensional static array with single element and returns T.

Examples
static assert(is(MultidimStaticArrayElementType!int == int));
static assert(is(MultidimStaticArrayElementType!(int[]) == int[]));
static assert(is(MultidimStaticArrayElementType!(int[0]) == int));
static assert(!__traits(compiles, MultidimStaticArrayElementType!(int[7][8], 3)));
static assert(is(MultidimStaticArrayElementType!(int[7][8]) == int));
static assert(is(MultidimStaticArrayElementType!(int[7][8], 1) == int[7]));
static assert(is(MultidimStaticArrayElementType!(int[7][8], 0) == int[7][8]));
static assert(is(MultidimStaticArrayElementType!(int[0][]) == int[0][]));
static assert(is(MultidimStaticArrayElementType!(int[][0]) == int[]));

template  multidimStaticArrayElementCount(T, size_t n = staticArrayDims!T)

Calculates the total element count of a multidimensional static array. Considers T to be an n-dimensional static array type.

If T isn't a static array assumes it to be a zero-dimensional static array with single element and returns 1.

Examples
static assert(multidimStaticArrayElementCount!int == 1);
static assert(multidimStaticArrayElementCount!(int[]) == 1);
static assert(multidimStaticArrayElementCount!(int[0]) == 0);
static assert(!__traits(compiles, multidimStaticArrayElementCount!(int[7][8], 3)));
static assert(multidimStaticArrayElementCount!(int[7][8]) == 7 * 8);
static assert(multidimStaticArrayElementCount!(int[7][8], 1) == 8);
static assert(multidimStaticArrayElementCount!(int[7][8], 0) == 1);
static assert(multidimStaticArrayElementCount!(int[0][]) == 1);
static assert(multidimStaticArrayElementCount!(int[][0]) == 0);

template  multidimStaticArrayLengths(T, size_t n = staticArrayDims!T)

Get, as an expression tuple, multidimensional static array lengths considering T to be n-dimensioanl static array.

Examples
alias e1 = multidimStaticArrayLengths!(int[7][8]);
static assert(e1.length == 2 && e1[0] == 8 && e1[1] == 7);

alias e2 = multidimStaticArrayLengths!(int[7][8], 1);
static assert(e2.length == 1 && e2[0] == 8);
static assert(multidimStaticArrayLengths!(int[7][8], 0).length == 0);

template  isPackedTuple(alias A)
template  isPackedTuple(A)

Detect whether tuple A is PackedGenericTuple.

template  ExtractTypes(T, Extracted...) if (isTypeTuple!Extracted)

Get all types T include except Extracted without duplicates in such order that every compound type precedes types it includes.

Examples
static assert(is(ExtractTypes!int == TypeTuple!int));
static assert(is(ExtractTypes!(int*) == TypeTuple!(int*, int)));
static assert(is(ExtractTypes!(int*, int) == TypeTuple!(int*)));

static struct S1 { int i; real r; }
static assert(is(ExtractTypes!S1 == TypeTuple!(S1, int, real)));
static assert(is(ExtractTypes!(S1, int) == TypeTuple!(S1, real)));

static struct S2
{
	int* iptr;
	S1* s1ptr1, s1ptr2;
	S2[] s2darr;
	S2[3]* s2sarr;
}
static assert(is(ExtractTypes!S2 == TypeTuple!(
	S2,                // for `S2` itself
	int*, int,         // for `int*`
	S1*, S1, real,     // for `S1*`
	S2[],              // for `S2[]`
	S2[3]*, S2[3]      // for `S2[3]*`
)));

template  isType(T)
template  isType(alias T)

true iff T is a type. Usable for analysing generic tuples.

Examples
static assert(isType!int && isType!string);
static assert(!isType!0 && !isType!"str");
static assert(!isType!isType);