mirrors/phobos
1
0
Fork 0
mirror of https://github.com/dlang/phobos.git synced 2025-05-04 17:11:26 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Fix if constraints indentation

Browse source
This commit is contained in:
Sebastian Wilzbach 2018-03-24 13:17:53 +01:00
parent 47aa7db188
commit 8f86a0d734
10 changed files with 90 additions and 76 deletions
Download patch file Download diff file Expand all files Collapse all files

10
std/algorithm/searching.d
View file

@ -1378,8 +1378,8 @@ if (isInputRange!Range && !isInfinite!Range &&
} }
private auto extremum(alias selector = "a < b", Range)(Range r) private auto extremum(alias selector = "a < b", Range)(Range r)
if (isInputRange!Range && !isInfinite!Range && if (isInputRange!Range && !isInfinite!Range &&
!is(typeof(unaryFun!selector(ElementType!(Range).init)))) !is(typeof(unaryFun!selector(ElementType!(Range).init))))
{ {
return extremum!(a => a, selector)(r); return extremum!(a => a, selector)(r);
} }
@ -1388,9 +1388,9 @@ private auto extremum(alias selector = "a < b", Range)(Range r)
private auto extremum(alias selector = "a < b", Range, private auto extremum(alias selector = "a < b", Range,
RangeElementType = ElementType!Range) RangeElementType = ElementType!Range)
(Range r, RangeElementType seedElement) (Range r, RangeElementType seedElement)
if (isInputRange!Range && !isInfinite!Range && if (isInputRange!Range && !isInfinite!Range &&
!is(CommonType!(ElementType!Range, RangeElementType) == void) && !is(CommonType!(ElementType!Range, RangeElementType) == void) &&
!is(typeof(unaryFun!selector(ElementType!(Range).init)))) !is(typeof(unaryFun!selector(ElementType!(Range).init))))
{ {
return extremum!(a => a, selector)(r, seedElement); return extremum!(a => a, selector)(r, seedElement);
} }

9
std/concurrency.d
View file

@ -430,7 +430,8 @@ private template isSpawnable(F, T...)
* pointer indirection. This is necessary for enforcing isolation among * pointer indirection. This is necessary for enforcing isolation among
* threads. * threads.
*/ */
Tid spawn(F, T...)(F fn, T args) if (isSpawnable!(F, T)) Tid spawn(F, T...)(F fn, T args)
if (isSpawnable!(F, T))
{ {
static assert(!hasLocalAliasing!(T), "Aliases to mutable thread-local data not allowed."); static assert(!hasLocalAliasing!(T), "Aliases to mutable thread-local data not allowed.");
return _spawn(false, fn, args); return _spawn(false, fn, args);
@ -504,7 +505,8 @@ Tid spawn(F, T...)(F fn, T args) if (isSpawnable!(F, T))
* Returns: * Returns:
* A Tid representing the new thread. * A Tid representing the new thread.
*/ */
Tid spawnLinked(F, T...)(F fn, T args) if (isSpawnable!(F, T)) Tid spawnLinked(F, T...)(F fn, T args)
if (isSpawnable!(F, T))
{ {
static assert(!hasLocalAliasing!(T), "Aliases to mutable thread-local data not allowed."); static assert(!hasLocalAliasing!(T), "Aliases to mutable thread-local data not allowed.");
return _spawn(true, fn, args); return _spawn(true, fn, args);
@ -513,7 +515,8 @@ Tid spawnLinked(F, T...)(F fn, T args) if (isSpawnable!(F, T))
/* /*
* *
*/ */
private Tid _spawn(F, T...)(bool linked, F fn, T args) if (isSpawnable!(F, T)) private Tid _spawn(F, T...)(bool linked, F fn, T args)
if (isSpawnable!(F, T))
{ {
// TODO: MessageList and &exec should be shared. // TODO: MessageList and &exec should be shared.
auto spawnTid = Tid(new MessageBox); auto spawnTid = Tid(new MessageBox);

3
std/conv.d
View file

@ -5974,7 +5974,8 @@ if (isIntegral!T)
Returns the representation of an enumerated value, i.e. the value converted to Returns the representation of an enumerated value, i.e. the value converted to
the base type of the enumeration. the base type of the enumeration.
*/ */
OriginalType!E asOriginalType(E)(E value) if (is(E == enum)) OriginalType!E asOriginalType(E)(E value)
if (is(E == enum))
{ {
return value; return value;
} }

3
std/digest/crc.d
View file

@ -159,7 +159,8 @@ alias CRC64ISO = CRC!(64, 0xD800000000000000);
* *
* See $(D std.digest.digest) for differences between template and OOP API. * See $(D std.digest.digest) for differences between template and OOP API.
*/ */
struct CRC(uint N, ulong P) if (N == 32 || N == 64) struct CRC(uint N, ulong P)
if (N == 32 || N == 64)
{ {
private: private:
static if (N == 32) static if (N == 32)

4
std/experimental/allocator/common.d
View file

@ -608,8 +608,8 @@ version(unittest)
} }
package void testAllocatorObject(RCAllocInterface)(RCAllocInterface a) package void testAllocatorObject(RCAllocInterface)(RCAllocInterface a)
if (is(RCAllocInterface == RCIAllocator) if (is(RCAllocInterface == RCIAllocator)
|| is (RCAllocInterface == shared RCISharedAllocator)) || is (RCAllocInterface == shared RCISharedAllocator))
{ {
import std.conv : text; import std.conv : text;
import std.math : isPowerOf2; import std.math : isPowerOf2;

4
std/numeric.d
View file

@ -2610,7 +2610,7 @@ Returns:
The greatest common divisor of the given arguments. The greatest common divisor of the given arguments.
*/ */
T gcd(T)(T a, T b) T gcd(T)(T a, T b)
if (isIntegral!T) if (isIntegral!T)
{ {
static if (is(T == const) || is(T == immutable)) static if (is(T == const) || is(T == immutable))
{ {
@ -2667,7 +2667,7 @@ T gcd(T)(T a, T b)
// user-defined types. // user-defined types.
/// ditto /// ditto
T gcd(T)(T a, T b) T gcd(T)(T a, T b)
if (!isIntegral!T && if (!isIntegral!T &&
is(typeof(T.init % T.init)) && is(typeof(T.init % T.init)) &&
is(typeof(T.init == 0 || T.init > 0))) is(typeof(T.init == 0 || T.init > 0)))
{ {

4
std/range/package.d
View file

@ -7808,7 +7808,7 @@ See_Also: $(LREF chunks)
*/ */
auto slide(Flag!"withPartial" f = Yes.withPartial, auto slide(Flag!"withPartial" f = Yes.withPartial,
Source)(Source source, size_t windowSize, size_t stepSize = 1) Source)(Source source, size_t windowSize, size_t stepSize = 1)
if (isForwardRange!Source) if (isForwardRange!Source)
{ {
return Slides!(f, Source)(source, windowSize, stepSize); return Slides!(f, Source)(source, windowSize, stepSize);
} }
@ -7871,7 +7871,7 @@ auto slide(Flag!"withPartial" f = Yes.withPartial,
} }
private struct Slides(Flag!"withPartial" withPartial = Yes.withPartial, Source) private struct Slides(Flag!"withPartial" withPartial = Yes.withPartial, Source)
if (isForwardRange!Source) if (isForwardRange!Source)
{ {
private: private:
Source source; Source source;

2
std/regex/internal/backtracking.d
View file

@ -14,7 +14,7 @@ import std.regex.internal.ir;
regular expressions. regular expressions.
+/ +/
@trusted class BacktrackingMatcher(Char, Stream = Input!Char) : Matcher!Char @trusted class BacktrackingMatcher(Char, Stream = Input!Char) : Matcher!Char
if (is(Char : dchar)) if (is(Char : dchar))
{ {
alias DataIndex = Stream.DataIndex; alias DataIndex = Stream.DataIndex;
struct State struct State

98
std/traits.d
View file

@ -601,7 +601,7 @@ static assert(fullyQualifiedName!(const MyStruct[]) == "const(myModule.MyStruct[
----------------- -----------------
*/ */
template fullyQualifiedName(T...) template fullyQualifiedName(T...)
if (T.length == 1) if (T.length == 1)
{ {
static if (is(T)) static if (is(T))
@ -1027,7 +1027,7 @@ private template fqnType(T,
* (see template $(LREF functionAttributes)). * (see template $(LREF functionAttributes)).
*/ */
template ReturnType(func...) template ReturnType(func...)
if (func.length == 1 && isCallable!func) if (func.length == 1 && isCallable!func)
{ {
static if (is(FunctionTypeOf!func R == return)) static if (is(FunctionTypeOf!func R == return))
alias ReturnType = R; alias ReturnType = R;
@ -1086,7 +1086,7 @@ to function, a delegate, a struct with an $(D opCall), a pointer to a
struct with an $(D opCall), or a class with an $(D opCall). struct with an $(D opCall), or a class with an $(D opCall).
*/ */
template Parameters(func...) template Parameters(func...)
if (func.length == 1 && isCallable!func) if (func.length == 1 && isCallable!func)
{ {
static if (is(FunctionTypeOf!func P == function)) static if (is(FunctionTypeOf!func P == function))
alias Parameters = P; alias Parameters = P;
@ -1136,8 +1136,8 @@ Returns the number of arguments of function $(D func).
arity is undefined for variadic functions. arity is undefined for variadic functions.
*/ */
template arity(func...) template arity(func...)
if (func.length == 1 && isCallable!func && if (func.length == 1 && isCallable!func &&
variadicFunctionStyle!func == Variadic.no) variadicFunctionStyle!func == Variadic.no)
{ {
enum size_t arity = Parameters!func.length; enum size_t arity = Parameters!func.length;
} }
@ -1182,7 +1182,7 @@ enum ParameterStorageClass : uint
/// ditto /// ditto
template ParameterStorageClassTuple(func...) template ParameterStorageClassTuple(func...)
if (func.length == 1 && isCallable!func) if (func.length == 1 && isCallable!func)
{ {
alias Func = FunctionTypeOf!func; alias Func = FunctionTypeOf!func;
@ -1338,7 +1338,7 @@ template extractParameterStorageClassFlags(Attribs...)
Get, as a tuple, the identifiers of the parameters to a function symbol. Get, as a tuple, the identifiers of the parameters to a function symbol.
*/ */
template ParameterIdentifierTuple(func...) template ParameterIdentifierTuple(func...)
if (func.length == 1 && isCallable!func) if (func.length == 1 && isCallable!func)
{ {
static if (is(FunctionTypeOf!func PT == __parameters)) static if (is(FunctionTypeOf!func PT == __parameters))
{ {
@ -1425,7 +1425,7 @@ Get, as a tuple, the default value of the parameters to a function symbol.
If a parameter doesn't have the default value, $(D void) is returned instead. If a parameter doesn't have the default value, $(D void) is returned instead.
*/ */
template ParameterDefaults(func...) template ParameterDefaults(func...)
if (func.length == 1 && isCallable!func) if (func.length == 1 && isCallable!func)
{ {
alias param_names = ParameterIdentifierTuple!func; alias param_names = ParameterIdentifierTuple!func;
static if (is(FunctionTypeOf!(func[0]) PT == __parameters)) static if (is(FunctionTypeOf!(func[0]) PT == __parameters))
@ -1573,7 +1573,7 @@ enum FunctionAttribute : uint
/// ditto /// ditto
template functionAttributes(func...) template functionAttributes(func...)
if (func.length == 1 && isCallable!func) if (func.length == 1 && isCallable!func)
{ {
// @bug: workaround for opCall // @bug: workaround for opCall
alias FuncSym = Select!(is(typeof(__traits(getFunctionAttributes, func))), alias FuncSym = Select!(is(typeof(__traits(getFunctionAttributes, func))),
@ -1749,8 +1749,8 @@ See_Also:
$(LREF functionAttributes) $(LREF functionAttributes)
*/ */
template hasFunctionAttributes(args...) template hasFunctionAttributes(args...)
if (args.length > 0 && isCallable!(args[0]) if (args.length > 0 && isCallable!(args[0])
&& allSatisfy!(isSomeString, typeof(args[1 .. $]))) && allSatisfy!(isSomeString, typeof(args[1 .. $])))
{ {
enum bool hasFunctionAttributes = { enum bool hasFunctionAttributes = {
import std.algorithm.searching : canFind; import std.algorithm.searching : canFind;
@ -1933,7 +1933,7 @@ template hasFunctionAttributes(args...)
$(D true) if $(D func) is $(D @safe) or $(D @trusted). $(D true) if $(D func) is $(D @safe) or $(D @trusted).
*/ */
template isSafe(alias func) template isSafe(alias func)
if (isCallable!func) if (isCallable!func)
{ {
enum isSafe = (functionAttributes!func & FunctionAttribute.safe) != 0 || enum isSafe = (functionAttributes!func & FunctionAttribute.safe) != 0 ||
(functionAttributes!func & FunctionAttribute.trusted) != 0; (functionAttributes!func & FunctionAttribute.trusted) != 0;
@ -2092,7 +2092,7 @@ Returns:
one of the strings "D", "C", "Windows", "Pascal", or "Objective-C" one of the strings "D", "C", "Windows", "Pascal", or "Objective-C"
*/ */
template functionLinkage(func...) template functionLinkage(func...)
if (func.length == 1 && isCallable!func) if (func.length == 1 && isCallable!func)
{ {
enum string functionLinkage = __traits(getLinkage, FunctionTypeOf!func); enum string functionLinkage = __traits(getLinkage, FunctionTypeOf!func);
} }
@ -2146,7 +2146,7 @@ enum Variadic
/// ditto /// ditto
template variadicFunctionStyle(func...) template variadicFunctionStyle(func...)
if (func.length == 1 && isCallable!func) if (func.length == 1 && isCallable!func)
{ {
enum string varargs = __traits(getFunctionVariadicStyle, FunctionTypeOf!func); enum string varargs = __traits(getFunctionVariadicStyle, FunctionTypeOf!func);
enum Variadic variadicFunctionStyle = enum Variadic variadicFunctionStyle =
@ -2196,7 +2196,7 @@ Do not confuse function types with function pointer types; function types are
usually used for compile-time reflection purposes. usually used for compile-time reflection purposes.
*/ */
template FunctionTypeOf(func...) template FunctionTypeOf(func...)
if (func.length == 1 && isCallable!func) if (func.length == 1 && isCallable!func)
{ {
static if (is(typeof(& func[0]) Fsym : Fsym*) && is(Fsym == function) || is(typeof(& func[0]) Fsym == delegate)) static if (is(typeof(& func[0]) Fsym : Fsym*) && is(Fsym == function) || is(typeof(& func[0]) Fsym == delegate))
{ {
@ -2301,7 +2301,7 @@ template FunctionTypeOf(func...)
* attrs = The desired $(LREF FunctionAttribute)s of the result type. * attrs = The desired $(LREF FunctionAttribute)s of the result type.
*/ */
template SetFunctionAttributes(T, string linkage, uint attrs) template SetFunctionAttributes(T, string linkage, uint attrs)
if (isFunctionPointer!T || isDelegate!T) if (isFunctionPointer!T || isDelegate!T)
{ {
mixin({ mixin({
import std.algorithm.searching : canFind; import std.algorithm.searching : canFind;
@ -2376,7 +2376,7 @@ template SetFunctionAttributes(T, string linkage, uint attrs)
/// Ditto /// Ditto
template SetFunctionAttributes(T, string linkage, uint attrs) template SetFunctionAttributes(T, string linkage, uint attrs)
if (is(T == function)) if (is(T == function))
{ {
// To avoid a lot of syntactic headaches, we just use the above version to // To avoid a lot of syntactic headaches, we just use the above version to
// operate on the corresponding function pointer type and then remove the // operate on the corresponding function pointer type and then remove the
@ -2390,7 +2390,7 @@ template SetFunctionAttributes(T, string linkage, uint attrs)
alias ExternC(T) = SetFunctionAttributes!(T, "C", functionAttributes!T); alias ExternC(T) = SetFunctionAttributes!(T, "C", functionAttributes!T);
auto assumePure(T)(T t) auto assumePure(T)(T t)
if (isFunctionPointer!T || isDelegate!T) if (isFunctionPointer!T || isDelegate!T)
{ {
enum attrs = functionAttributes!T | FunctionAttribute.pure_; enum attrs = functionAttributes!T | FunctionAttribute.pure_;
return cast(SetFunctionAttributes!(T, functionLinkage!T, attrs)) t; return cast(SetFunctionAttributes!(T, functionLinkage!T, attrs)) t;
@ -2471,7 +2471,7 @@ Returns:
`false` otherwise `false` otherwise
*/ */
template isInnerClass(T) template isInnerClass(T)
if (is(T == class)) if (is(T == class))
{ {
import std.meta : staticIndexOf; import std.meta : staticIndexOf;
@ -2517,7 +2517,7 @@ Determines whether $(D T) has its own context pointer.
$(D T) must be either $(D class), $(D struct), or $(D union). $(D T) must be either $(D class), $(D struct), or $(D union).
*/ */
template isNested(T) template isNested(T)
if (is(T == class) || is(T == struct) || is(T == union)) if (is(T == class) || is(T == struct) || is(T == union))
{ {
enum isNested = __traits(isNested, T); enum isNested = __traits(isNested, T);
} }
@ -4003,7 +4003,7 @@ int[] abc = cast(int[]) [ EnumMembers!E ];
example below. example below.
*/ */
template EnumMembers(E) template EnumMembers(E)
if (is(E == enum)) if (is(E == enum))
{ {
import std.meta : AliasSeq; import std.meta : AliasSeq;
// Supply the specified identifier to an constant value. // Supply the specified identifier to an constant value.
@ -4213,7 +4213,7 @@ template BaseTypeTuple(A)
* BaseClassesTuple!Object) yields the empty type tuple. * BaseClassesTuple!Object) yields the empty type tuple.
*/ */
template BaseClassesTuple(T) template BaseClassesTuple(T)
if (is(T == class)) if (is(T == class))
{ {
static if (is(T == Object)) static if (is(T == Object))
{ {
@ -4364,7 +4364,7 @@ class or interface $(D C). Covariant duplicates are shrunk into the most
derived one. derived one.
*/ */
template MemberFunctionsTuple(C, string name) template MemberFunctionsTuple(C, string name)
if (is(C == class) || is(C == interface)) if (is(C == class) || is(C == interface))
{ {
static if (__traits(hasMember, C, name)) static if (__traits(hasMember, C, name))
{ {
@ -4647,7 +4647,8 @@ template TemplateArgsOf(T : Base!Args, alias Base, Args...)
} }
private template maxAlignment(U...) if (isTypeTuple!U) private template maxAlignment(U...)
if (isTypeTuple!U)
{ {
import std.meta : staticMap; import std.meta : staticMap;
static if (U.length == 0) static if (U.length == 0)
@ -4665,7 +4666,8 @@ private template maxAlignment(U...) if (isTypeTuple!U)
/** /**
Returns class instance alignment. Returns class instance alignment.
*/ */
template classInstanceAlignment(T) if (is(T == class)) template classInstanceAlignment(T)
if (is(T == class))
{ {
alias classInstanceAlignment = maxAlignment!(void*, typeof(T.tupleof)); alias classInstanceAlignment = maxAlignment!(void*, typeof(T.tupleof));
} }
@ -5072,9 +5074,9 @@ Determines whether the function type $(D F) is covariant with $(D G), i.e.,
functions of the type $(D F) can override ones of the type $(D G). functions of the type $(D F) can override ones of the type $(D G).
*/ */
template isCovariantWith(F, G) template isCovariantWith(F, G)
if (is(F == function) && is(G == function) || if (is(F == function) && is(G == function) ||
is(F == delegate) && is(G == delegate) || is(F == delegate) && is(G == delegate) ||
isFunctionPointer!F && isFunctionPointer!G) isFunctionPointer!F && isFunctionPointer!G)
{ {
static if (is(F : G)) static if (is(F : G))
enum isCovariantWith = true; enum isCovariantWith = true;
@ -5331,7 +5333,8 @@ Note: Trying to use returned value will result in a
// SomethingTypeOf // SomethingTypeOf
//:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::// //::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::://
private template AliasThisTypeOf(T) if (isAggregateType!T) private template AliasThisTypeOf(T)
if (isAggregateType!T)
{ {
alias members = AliasSeq!(__traits(getAliasThis, T)); alias members = AliasSeq!(__traits(getAliasThis, T));
@ -6874,7 +6877,7 @@ template isTypeTuple(T...)
Detect whether symbol or type $(D T) is a function pointer. Detect whether symbol or type $(D T) is a function pointer.
*/ */
template isFunctionPointer(T...) template isFunctionPointer(T...)
if (T.length == 1) if (T.length == 1)
{ {
static if (is(T[0] U) || is(typeof(T[0]) U)) static if (is(T[0] U) || is(typeof(T[0]) U))
{ {
@ -6910,7 +6913,7 @@ template isFunctionPointer(T...)
Detect whether symbol or type $(D T) is a delegate. Detect whether symbol or type $(D T) is a delegate.
*/ */
template isDelegate(T...) template isDelegate(T...)
if (T.length == 1) if (T.length == 1)
{ {
static if (is(typeof(& T[0]) U : U*) && is(typeof(& T[0]) U == delegate)) static if (is(typeof(& T[0]) U : U*) && is(typeof(& T[0]) U == delegate))
{ {
@ -6953,7 +6956,7 @@ Returns:
A `bool` A `bool`
*/ */
template isSomeFunction(T...) template isSomeFunction(T...)
if (T.length == 1) if (T.length == 1)
{ {
static if (is(typeof(& T[0]) U : U*) && is(U == function) || is(typeof(& T[0]) U == delegate)) static if (is(typeof(& T[0]) U : U*) && is(U == function) || is(typeof(& T[0]) U == delegate))
{ {
@ -7017,7 +7020,7 @@ Detect whether $(D T) is a callable object, which can be called with the
function call operator $(D $(LPAREN)...$(RPAREN)). function call operator $(D $(LPAREN)...$(RPAREN)).
*/ */
template isCallable(T...) template isCallable(T...)
if (T.length == 1) if (T.length == 1)
{ {
static if (is(typeof(& T[0].opCall) == delegate)) static if (is(typeof(& T[0].opCall) == delegate))
// T is a object which has a member function opCall(). // T is a object which has a member function opCall().
@ -7051,7 +7054,7 @@ template isCallable(T...)
* Detect whether $(D T) is an abstract function. * Detect whether $(D T) is an abstract function.
*/ */
template isAbstractFunction(T...) template isAbstractFunction(T...)
if (T.length == 1) if (T.length == 1)
{ {
enum bool isAbstractFunction = __traits(isAbstractFunction, T[0]); enum bool isAbstractFunction = __traits(isAbstractFunction, T[0]);
} }
@ -7071,7 +7074,7 @@ template isAbstractFunction(T...)
* Detect whether $(D T) is a final function. * Detect whether $(D T) is a final function.
*/ */
template isFinalFunction(T...) template isFinalFunction(T...)
if (T.length == 1) if (T.length == 1)
{ {
enum bool isFinalFunction = __traits(isFinalFunction, T[0]); enum bool isFinalFunction = __traits(isFinalFunction, T[0]);
} }
@ -7113,7 +7116,7 @@ template isNestedFunction(alias f)
* Detect whether $(D T) is an abstract class. * Detect whether $(D T) is an abstract class.
*/ */
template isAbstractClass(T...) template isAbstractClass(T...)
if (T.length == 1) if (T.length == 1)
{ {
enum bool isAbstractClass = __traits(isAbstractClass, T[0]); enum bool isAbstractClass = __traits(isAbstractClass, T[0]);
} }
@ -7137,7 +7140,7 @@ template isAbstractClass(T...)
* Detect whether $(D T) is a final class. * Detect whether $(D T) is a final class.
*/ */
template isFinalClass(T...) template isFinalClass(T...)
if (T.length == 1) if (T.length == 1)
{ {
enum bool isFinalClass = __traits(isFinalClass, T[0]); enum bool isFinalClass = __traits(isFinalClass, T[0]);
} }
@ -7500,7 +7503,8 @@ 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 than one type is of the same size, the leftmost argument of these in will be
returned. returned.
*/ */
template Largest(T...) if (T.length >= 1) template Largest(T...)
if (T.length >= 1)
{ {
static if (T.length == 1) static if (T.length == 1)
{ {
@ -7595,7 +7599,7 @@ template Signed(T)
Returns the most negative value of the numeric type T. Returns the most negative value of the numeric type T.
*/ */
template mostNegative(T) template mostNegative(T)
if (isNumeric!T || isSomeChar!T || isBoolean!T) if (isNumeric!T || isSomeChar!T || isBoolean!T)
{ {
static if (is(typeof(T.min_normal))) static if (is(typeof(T.min_normal)))
enum mostNegative = -T.max; enum mostNegative = -T.max;
@ -7631,7 +7635,7 @@ Get the type that a scalar type `T` will $(LINK2 $(ROOT_DIR)spec/type.html#integ
to in multi-term arithmetic expressions. to in multi-term arithmetic expressions.
*/ */
template Promoted(T) template Promoted(T)
if (isScalarType!T) if (isScalarType!T)
{ {
alias Promoted = CopyTypeQualifiers!(T, typeof(T.init + T.init)); alias Promoted = CopyTypeQualifiers!(T, typeof(T.init + T.init));
} }
@ -7677,7 +7681,7 @@ might be more convenient in generic code, e.g. as a template argument
when invoking staticMap. when invoking staticMap.
*/ */
template mangledName(sth...) template mangledName(sth...)
if (sth.length == 1) if (sth.length == 1)
{ {
enum string mangledName = sth[0].mangleof; enum string mangledName = sth[0].mangleof;
} }
@ -7731,7 +7735,8 @@ version(unittest) void freeFunc(string);
Aliases itself to $(D T[0]) if the boolean $(D condition) is $(D true) Aliases itself to $(D T[0]) if the boolean $(D condition) is $(D true)
and to $(D T[1]) otherwise. and to $(D T[1]) otherwise.
*/ */
template Select(bool condition, T...) if (T.length == 2) template Select(bool condition, T...)
if (T.length == 2)
{ {
import std.meta : Alias; import std.meta : Alias;
alias Select = Alias!(T[!condition]); alias Select = Alias!(T[!condition]);
@ -8259,7 +8264,8 @@ enum ifTestable(T, alias pred = a => a) = __traits(compiles, { if (pred(T.init))
* Returns: * Returns:
* `true` if `X` is a type, `false` otherwise * `true` if `X` is a type, `false` otherwise
*/ */
template isType(X...) if (X.length == 1) template isType(X...)
if (X.length == 1)
{ {
enum isType = is(X[0]); enum isType = is(X[0]);
} }
@ -8302,7 +8308,8 @@ template isType(X...) if (X.length == 1)
* Use $(LREF isFunctionPointer) or $(LREF isDelegate) for detecting those types * Use $(LREF isFunctionPointer) or $(LREF isDelegate) for detecting those types
* respectively. * respectively.
*/ */
template isFunction(X...) if (X.length == 1) template isFunction(X...)
if (X.length == 1)
{ {
static if (is(typeof(&X[0]) U : U*) && is(U == function) || static if (is(typeof(&X[0]) U : U*) && is(U == function) ||
is(typeof(&X[0]) U == delegate)) is(typeof(&X[0]) U == delegate))
@ -8338,7 +8345,8 @@ template isFunction(X...) if (X.length == 1)
* Returns: * Returns:
* `true` if `X` is final, `false` otherwise * `true` if `X` is final, `false` otherwise
*/ */
template isFinal(X...) if (X.length == 1) template isFinal(X...)
if (X.length == 1)
{ {
static if (is(X[0] == class)) static if (is(X[0] == class))
enum isFinal = __traits(isFinalClass, X[0]); enum isFinal = __traits(isFinalClass, X[0]);

29
std/typecons.d
View file

@ -419,13 +419,13 @@ private:
// Used in Tuple.toString // Used in Tuple.toString
private template sharedToString(alias field) private template sharedToString(alias field)
if (is(typeof(field) == shared)) if (is(typeof(field) == shared))
{ {
static immutable sharedToString = typeof(field).stringof; static immutable sharedToString = typeof(field).stringof;
} }
private template sharedToString(alias field) private template sharedToString(alias field)
if (!is(typeof(field) == shared)) if (!is(typeof(field) == shared))
{ {
alias sharedToString = field; alias sharedToString = field;
} }
@ -1326,7 +1326,7 @@ if (distinctFieldNames!(Specs))
A new `Tuple`. A new `Tuple`.
*/ */
auto reverse(T)(T t) auto reverse(T)(T t)
if (isTuple!T) if (isTuple!T)
{ {
import std.meta : Reverse; import std.meta : Reverse;
// @@@BUG@@@ Cannot be an internal function due to forward reference issues. // @@@BUG@@@ Cannot be an internal function due to forward reference issues.
@ -1349,7 +1349,7 @@ auto reverse(T)(T t)
/* Get a Tuple type with the reverse specification of Tuple T. */ /* Get a Tuple type with the reverse specification of Tuple T. */
private template ReverseTupleType(T) private template ReverseTupleType(T)
if (isTuple!T) if (isTuple!T)
{ {
static if (is(T : Tuple!A, A...)) static if (is(T : Tuple!A, A...))
alias ReverseTupleType = Tuple!(ReverseTupleSpecs!A); alias ReverseTupleType = Tuple!(ReverseTupleSpecs!A);
@ -1946,7 +1946,7 @@ enum isTuple(T) = __traits(compiles,
// used by both Rebindable and UnqualRef // used by both Rebindable and UnqualRef
private mixin template RebindableCommon(T, U, alias This) private mixin template RebindableCommon(T, U, alias This)
if (is(T == class) || is(T == interface) || isAssociativeArray!T) if (is(T == class) || is(T == interface) || isAssociativeArray!T)
{ {
private union private union
{ {
@ -2005,7 +2005,7 @@ Params:
T = An object, interface, array slice type, or associative array type. T = An object, interface, array slice type, or associative array type.
*/ */
template Rebindable(T) template Rebindable(T)
if (is(T == class) || is(T == interface) || isDynamicArray!T || isAssociativeArray!T) if (is(T == class) || is(T == interface) || isDynamicArray!T || isAssociativeArray!T)
{ {
static if (is(T == const U, U) || is(T == immutable U, U)) static if (is(T == const U, U) || is(T == immutable U, U))
{ {
@ -2076,7 +2076,7 @@ Returns:
A newly constructed `Rebindable` initialized with the given reference. A newly constructed `Rebindable` initialized with the given reference.
*/ */
Rebindable!T rebindable(T)(T obj) Rebindable!T rebindable(T)(T obj)
if (is(T == class) || is(T == interface) || isDynamicArray!T || isAssociativeArray!T) if (is(T == class) || is(T == interface) || isDynamicArray!T || isAssociativeArray!T)
{ {
typeof(return) ret; typeof(return) ret;
ret = obj; ret = obj;
@ -2199,7 +2199,7 @@ Rebindable!T rebindable(T)(Rebindable!T obj)
T = A class or interface type. T = A class or interface type.
*/ */
template UnqualRef(T) template UnqualRef(T)
if (is(T == class) || is(T == interface)) if (is(T == class) || is(T == interface))
{ {
static if (is(T == const U, U) static if (is(T == const U, U)
|| is(T == immutable U, U) || is(T == immutable U, U)
@ -3235,7 +3235,7 @@ $(D this) must not be in the null state.
/// ditto /// ditto
auto nullable(alias nullValue, T)(T t) auto nullable(alias nullValue, T)(T t)
if (is (typeof(nullValue) == T)) if (is (typeof(nullValue) == T))
{ {
return Nullable!(T, nullValue)(t); return Nullable!(T, nullValue)(t);
} }
@ -3948,7 +3948,7 @@ $(UL
) )
*/ */
class AutoImplement(Base, alias how, alias what = isAbstractFunction) : Base class AutoImplement(Base, alias how, alias what = isAbstractFunction) : Base
if (!is(how == class)) if (!is(how == class))
{ {
private alias autoImplement_helper_ = private alias autoImplement_helper_ =
AutoImplement_Helper!("autoImplement_helper_", "Base", Base, typeof(this), how, what); AutoImplement_Helper!("autoImplement_helper_", "Base", Base, typeof(this), how, what);
@ -3959,7 +3959,7 @@ class AutoImplement(Base, alias how, alias what = isAbstractFunction) : Base
class AutoImplement( class AutoImplement(
Interface, BaseClass, alias how, Interface, BaseClass, alias how,
alias what = isAbstractFunction) : BaseClass, Interface alias what = isAbstractFunction) : BaseClass, Interface
if (is(Interface == interface) && is(BaseClass == class)) if (is(Interface == interface) && is(BaseClass == class))
{ {
private alias autoImplement_helper_ = AutoImplement_Helper!( private alias autoImplement_helper_ = AutoImplement_Helper!(
"autoImplement_helper_", "Interface", Interface, typeof(this), how, what); "autoImplement_helper_", "Interface", Interface, typeof(this), how, what);
@ -7028,7 +7028,7 @@ It's illegal to move a class instance even if you are sure there
are no pointers to it. As such, it is illegal to move a scoped object. are no pointers to it. As such, it is illegal to move a scoped object.
*/ */
template scoped(T) template scoped(T)
if (is(T == class)) if (is(T == class))
{ {
// _d_newclass now use default GC alignment (looks like (void*).sizeof * 2 for // _d_newclass now use default GC alignment (looks like (void*).sizeof * 2 for
// small objects). We will just use the maximum of filed alignments. // small objects). We will just use the maximum of filed alignments.
@ -7166,7 +7166,7 @@ template scoped(T)
} }
private uintptr_t _alignUp(uintptr_t alignment)(uintptr_t n) private uintptr_t _alignUp(uintptr_t alignment)(uintptr_t n)
if (alignment > 0 && !((alignment - 1) & alignment)) if (alignment > 0 && !((alignment - 1) & alignment))
{ {
enum badEnd = alignment - 1; // 0b11, 0b111, ... enum badEnd = alignment - 1; // 0b11, 0b111, ...
return (n + badEnd) & ~badEnd; return (n + badEnd) & ~badEnd;
@ -7624,7 +7624,8 @@ final switch (e)
} }
---- ----
*/ */
struct BitFlags(E, Flag!"unsafe" unsafe = No.unsafe) if (unsafe || isBitFlagEnum!(E)) struct BitFlags(E, Flag!"unsafe" unsafe = No.unsafe)
if (unsafe || isBitFlagEnum!(E))
{ {
@safe @nogc pure nothrow: @safe @nogc pure nothrow:
private: private: