Skip to content

fix issue 17085 - Documentation for all traits under SomethingTypeOf missing #5747

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Closed
ghost wants to merge 5 commits into from
Closed

fix issue 17085 - Documentation for all traits under SomethingTypeOf missing #5747

Changes from all commits
Commits
Show all changes
5 commits
Select commit Hold shift + click to select a range
46973d3
fix issue 17085 - Documentation for all traits under SomethingTypeOf …
Sep 27, 2017
86f6210
deprecate instead
Sep 29, 2017
129a703
handle deps in uni
Sep 29, 2017
ea1e29b
Revert "handle deps in uni"
Sep 29, 2017
ff9d071
Revert "deprecate instead"
Sep 29, 2017
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
172 changes: 158 additions & 14 deletions std/traits.d
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -75,6 +75,19 @@
* $(LREF SharedConstOf)
* $(LREF ImmutableOf)
* $(LREF QualifierOf)
* $(LREF BooleanTypeOf)
* $(LREF IntegralTypeOf)
* $(LREF FloatingPointTypeOf)
* $(LREF NumericTypeOf)
* $(LREF UnsignedTypeOf)
* $(LREF SignedTypeOf)
* $(LREF CharTypeOf)
* $(LREF StaticArrayTypeOf)
* $(LREF DynamicArrayTypeOf)
* $(LREF ArrayTypeOf)
* $(LREF StringTypeOf)
* $(LREF AssocArrayTypeOf)
* $(LREF BuiltinTypeOf)
* ))
* $(TR $(TD Categories of types) $(TD
* $(LREF allSameType)
Expand Down Expand Up @@ -5125,7 +5138,8 @@ private template AliasThisTypeOf(T) if (isAggregateType!T)
static assert(0, T.stringof~" does not have alias this type");
}

/*
/**
* Create an alias of `T` either if `T` is or if it subtypes `bool`.
*/
template BooleanTypeOf(T)
{
Expand All @@ -5141,6 +5155,14 @@ template BooleanTypeOf(T)
else
static assert(0, T.stringof~" is not boolean type");
}
///
@safe unittest
{
struct SubTyped{bool b; alias b this;}
static assert(is(BooleanTypeOf!bool == bool));
static assert(is(BooleanTypeOf!SubTyped == bool));
static assert(!is(BooleanTypeOf!float));
}

@safe unittest
{
Expand Down Expand Up @@ -5176,7 +5198,9 @@ template BooleanTypeOf(T)
static assert(is(BooleanTypeOf!S == bool));
}

/*
/**
* Create an alias of `T` either if `T` is or if it subtypes a built-in
* integral type.
*/
template IntegralTypeOf(T)
{
Expand All @@ -5193,6 +5217,15 @@ template IntegralTypeOf(T)
else
static assert(0, T.stringof~" is not an integral type");
}
///
@safe unittest
{
struct SubTyped{int i; alias i this;}
static assert(is(IntegralTypeOf!int == int));
static assert(is(IntegralTypeOf!ulong == ulong));
static assert(is(IntegralTypeOf!SubTyped == int));
static assert(!is(IntegralTypeOf!float));
}

@safe unittest
{
Expand All @@ -5211,7 +5244,9 @@ template IntegralTypeOf(T)
}
}

/*
/**
* Create an alias of `T` either if `T` is or if it subtypes a built-in
* floating point type.
*/
template FloatingPointTypeOf(T)
{
Expand All @@ -5228,6 +5263,15 @@ template FloatingPointTypeOf(T)
else
static assert(0, T.stringof~" is not a floating point type");
}
///
@safe unittest
{
struct SubTyped{float f; alias f this;}
static assert(is(FloatingPointTypeOf!float == float));
static assert(is(FloatingPointTypeOf!real == real));
static assert(is(FloatingPointTypeOf!SubTyped == float));
static assert(!is(FloatingPointTypeOf!char));
}

@safe unittest
{
Expand All @@ -5246,7 +5290,9 @@ template FloatingPointTypeOf(T)
}
}

/*
/**
* Create an alias of `T` either if `T` is or if it subtypes a built-in
* numeric type.
*/
template NumericTypeOf(T)
{
Expand All @@ -5257,6 +5303,15 @@ template NumericTypeOf(T)
else
static assert(0, T.stringof~" is not a numeric type");
}
///
@safe unittest
{
struct SubTyped{int i; alias i this;}
static assert(is(NumericTypeOf!int == int));
static assert(is(NumericTypeOf!float == float));
static assert(is(NumericTypeOf!SubTyped == int));
static assert(!is(NumericTypeOf!char));
}

@safe unittest
{
Expand All @@ -5275,7 +5330,9 @@ template NumericTypeOf(T)
}
}

/*
/**
* Create an alias of `T` either if `T` is or if it subtypes a built-in
* unsigned integral type.
*/
template UnsignedTypeOf(T)
{
Expand All @@ -5286,8 +5343,19 @@ template UnsignedTypeOf(T)
else
static assert(0, T.stringof~" is not an unsigned type.");
}
///
@safe unittest
{
struct SubTyped{uint u; alias u this;}
static assert(is(UnsignedTypeOf!uint == uint));
static assert(is(UnsignedTypeOf!ubyte == ubyte));
static assert(is(UnsignedTypeOf!SubTyped == uint));
static assert(!is(UnsignedTypeOf!char));
}

/*
/**
* Create an alias of `T` either if `T` is or if it subtypes a built-in
* signed type.
*/
template SignedTypeOf(T)
{
Expand All @@ -5300,8 +5368,19 @@ template SignedTypeOf(T)
else
static assert(0, T.stringof~" is not an signed type.");
}
///
@safe unittest
{
struct SubTyped{int i; alias i this;}
static assert(is(SignedTypeOf!int == int));
static assert(is(SignedTypeOf!float == float));
static assert(is(SignedTypeOf!SubTyped == int));
static assert(!is(SignedTypeOf!ubyte));
}

/*
/**
* Create an alias of `T` either if `T` is or if it subtypes a built-in
* character type.
*/
template CharTypeOf(T)
{
Expand All @@ -5318,6 +5397,15 @@ template CharTypeOf(T)
else
static assert(0, T.stringof~" is not a character type");
}
///
@safe unittest
{
struct SubTyped{char c; alias c this;}
static assert(is(CharTypeOf!char == char));
static assert(is(CharTypeOf!wchar == wchar));
static assert(is(CharTypeOf!SubTyped == char));
static assert(!is(CharTypeOf!ubyte));
}

@safe unittest
{
Expand All @@ -5343,7 +5431,8 @@ template CharTypeOf(T)
}
}

/*
/**
* Create an alias of `T` either if `T` is or if it subtypes a static array.
*/
template StaticArrayTypeOf(T)
{
Expand All @@ -5357,6 +5446,14 @@ template StaticArrayTypeOf(T)
else
static assert(0, T.stringof~" is not a static array type");
}
///
@safe unittest
{
struct SubTyped{ubyte[4] u; alias u this;}
static assert(is(StaticArrayTypeOf!(int[8]) == int[8]));
static assert(is(StaticArrayTypeOf!SubTyped == ubyte[4]));
static assert(!is(StaticArrayTypeOf!ubyte));
}

@safe unittest
{
Expand All @@ -5378,7 +5475,8 @@ template StaticArrayTypeOf(T)
}
}

/*
/**
* Create an alias of `T` either if `T` is or if it subtypes a dynamic array.
*/
template DynamicArrayTypeOf(T)
{
Expand All @@ -5394,6 +5492,14 @@ template DynamicArrayTypeOf(T)
else
static assert(0, T.stringof~" is not a dynamic array");
}
///
@safe unittest
{
struct SubTyped{ubyte[] u; alias u this;}
static assert(is(DynamicArrayTypeOf!(int[]) == int[]));
static assert(is(DynamicArrayTypeOf!SubTyped == ubyte[]));
static assert(!is(DynamicArrayTypeOf!ubyte));
}

@safe unittest
{
Expand All @@ -5415,7 +5521,8 @@ template DynamicArrayTypeOf(T)
static assert(!is(DynamicArrayTypeOf!(typeof(null))));
}

/*
/**
* Create an alias of `T` either if `T` is or if it subtypes an array.
*/
template ArrayTypeOf(T)
{
Expand All @@ -5426,9 +5533,18 @@ template ArrayTypeOf(T)
else
static assert(0, T.stringof~" is not an array type");
}
///
@safe unittest
{
struct SubTyped{ubyte[] u; alias u this;}
static assert(is(ArrayTypeOf!(int[5]) == int[5]));
static assert(is(ArrayTypeOf!SubTyped == ubyte[]));
static assert(!is(ArrayTypeOf!ubyte));
}

/*
Always returns the Dynamic Array version.
/**
* Create an alias of `T` either if `T` is or if it subtypes a string type.
* Note that fixed size string types are converted to their dynamic counterpart.
*/
template StringTypeOf(T)
{
Expand All @@ -5449,6 +5565,14 @@ template StringTypeOf(T)
else
static assert(0, T.stringof~" is not a string type");
}
///
@safe unittest
{
struct SubTyped{char[] c; alias c this;}
static assert(is(StringTypeOf!(const(wchar)[5]) == const(wchar)[]));
static assert(is(StringTypeOf!SubTyped == char[]));
static assert(!is(StringTypeOf!ubyte));
}

@safe unittest
{
Expand Down Expand Up @@ -5479,7 +5603,9 @@ template StringTypeOf(T)
static assert(is(StringTypeOf!(char[4]) == char[]));
}

/*
/**
* Create an alias of `T` either if `T` is or if it subtypes a built-in
* associative array.
*/
template AssocArrayTypeOf(T)
{
Expand All @@ -5495,6 +5621,14 @@ template AssocArrayTypeOf(T)
else
static assert(0, T.stringof~" is not an associative array type");
}
///
@safe unittest
{
struct SubTyped{string[int] si; alias si this;}
static assert(is(AssocArrayTypeOf!(int[int]) == int[int]));
static assert(is(AssocArrayTypeOf!SubTyped == string[int]));
static assert(!is(AssocArrayTypeOf!ubyte));
}

@safe unittest
{
Expand All @@ -5516,7 +5650,8 @@ template AssocArrayTypeOf(T)
}
}

/*
/**
* Create an alias of `T` either if `T` is or if it subtypes a built-in type.
*/
template BuiltinTypeOf(T)
{
Expand All @@ -5531,6 +5666,15 @@ template BuiltinTypeOf(T)
else static if (is(AssocArrayTypeOf!T X)) alias BuiltinTypeOf = X;
else static assert(0);
}
///
@safe unittest
{
struct NotSubTyped {}
struct SubTyped{double d; alias d this;}
static assert(is(BuiltinTypeOf!(int[][][]) == int[][][]));
static assert(is(BuiltinTypeOf!SubTyped == double));
static assert(!is(BuiltinTypeOf!NotSubTyped));
}

//::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::://
// isSomething
Expand Down