mirror of
https://github.com/dlang/phobos.git
synced 2025-04-29 14:40:30 +03:00
DStyle: Constraints on declarations should have the same indentation level
This commit is contained in:
Sebastian Wilzbach
parent
b5e76a2ef4
commit
87dec58a41
59 changed files with 1270 additions and 1170 deletions
|
|
@ -84,7 +84,7 @@ range.
|
|||
*/
|
||||
uint among(alias pred = (a, b) => a == b, Value, Values...)
|
||||
(Value value, Values values)
|
||||
if (Values.length != 0)
|
||||
if (Values.length != 0)
|
||||
{
|
||||
foreach (uint i, ref v; values)
|
||||
{
|
||||
|
|
@ -96,7 +96,7 @@ uint among(alias pred = (a, b) => a == b, Value, Values...)
|
|||
|
||||
/// Ditto
|
||||
template among(values...)
|
||||
if (isExpressionTuple!values)
|
||||
if (isExpressionTuple!values)
|
||||
{
|
||||
uint among(Value)(Value value)
|
||||
if (!is(CommonType!(Value, values) == void))
|
||||
|
|
@ -617,7 +617,8 @@ if (isInputRange!R1 && isInputRange!R2 && !(isSomeString!R1 && isSomeString!R2))
|
|||
}
|
||||
|
||||
/// ditto
|
||||
int cmp(alias pred = "a < b", R1, R2)(R1 r1, R2 r2) if (isSomeString!R1 && isSomeString!R2)
|
||||
int cmp(alias pred = "a < b", R1, R2)(R1 r1, R2 r2)
|
||||
if (isSomeString!R1 && isSomeString!R2)
|
||||
{
|
||||
import core.stdc.string : memcmp;
|
||||
import std.utf : decode;
|
||||
|
|
@ -958,7 +959,7 @@ range of range (of range...) comparisons.
|
|||
|
||||
// MaxType
|
||||
private template MaxType(T...)
|
||||
if (T.length >= 1)
|
||||
if (T.length >= 1)
|
||||
{
|
||||
static if (T.length == 1)
|
||||
{
|
||||
|
|
@ -1200,7 +1201,7 @@ Does not allocate GC memory.
|
|||
*/
|
||||
size_t levenshteinDistance(alias equals = (a,b) => a == b, Range1, Range2)
|
||||
(Range1 s, Range2 t)
|
||||
if (isForwardRange!(Range1) && isForwardRange!(Range2))
|
||||
if (isForwardRange!(Range1) && isForwardRange!(Range2))
|
||||
{
|
||||
alias eq = binaryFun!(equals);
|
||||
|
||||
|
|
@ -1271,7 +1272,7 @@ size_t levenshteinDistance(alias equals = (a,b) => a == b, Range1, Range2)
|
|||
/// ditto
|
||||
size_t levenshteinDistance(alias equals = (a,b) => a == b, Range1, Range2)
|
||||
(auto ref Range1 s, auto ref Range2 t)
|
||||
if (isConvertibleToString!Range1 || isConvertibleToString!Range2)
|
||||
if (isConvertibleToString!Range1 || isConvertibleToString!Range2)
|
||||
{
|
||||
import std.meta : staticMap;
|
||||
alias Types = staticMap!(convertToString, Range1, Range2);
|
||||
|
|
@ -1312,7 +1313,7 @@ Allocates GC memory for the returned EditOp[] array.
|
|||
Tuple!(size_t, EditOp[])
|
||||
levenshteinDistanceAndPath(alias equals = (a,b) => a == b, Range1, Range2)
|
||||
(Range1 s, Range2 t)
|
||||
if (isForwardRange!(Range1) && isForwardRange!(Range2))
|
||||
if (isForwardRange!(Range1) && isForwardRange!(Range2))
|
||||
{
|
||||
Levenshtein!(Range1, binaryFun!(equals)) lev;
|
||||
auto d = lev.distanceWithPath(s, t);
|
||||
|
|
@ -1344,7 +1345,7 @@ levenshteinDistanceAndPath(alias equals = (a,b) => a == b, Range1, Range2)
|
|||
Tuple!(size_t, EditOp[])
|
||||
levenshteinDistanceAndPath(alias equals = (a,b) => a == b, Range1, Range2)
|
||||
(auto ref Range1 s, auto ref Range2 t)
|
||||
if (isConvertibleToString!Range1 || isConvertibleToString!Range2)
|
||||
if (isConvertibleToString!Range1 || isConvertibleToString!Range2)
|
||||
{
|
||||
import std.meta : staticMap;
|
||||
alias Types = staticMap!(convertToString, Range1, Range2);
|
||||
|
|
@ -1375,7 +1376,7 @@ See_Also:
|
|||
$(REF maxElement, std,algorithm,searching)
|
||||
*/
|
||||
MaxType!T max(T...)(T args)
|
||||
if (T.length >= 2)
|
||||
if (T.length >= 2)
|
||||
{
|
||||
//Get "a"
|
||||
static if (T.length <= 2)
|
||||
|
|
@ -1448,7 +1449,7 @@ MaxType!T max(T...)(T args)
|
|||
|
||||
// MinType
|
||||
private template MinType(T...)
|
||||
if (T.length >= 1)
|
||||
if (T.length >= 1)
|
||||
{
|
||||
static if (T.length == 1)
|
||||
{
|
||||
|
|
@ -1489,7 +1490,7 @@ See_Also:
|
|||
$(REF minElement, std,algorithm,searching)
|
||||
*/
|
||||
MinType!T min(T...)(T args)
|
||||
if (T.length >= 2)
|
||||
if (T.length >= 2)
|
||||
{
|
||||
//Get "a"
|
||||
static if (T.length <= 2)
|
||||
|
|
@ -1560,7 +1561,7 @@ See_Also:
|
|||
*/
|
||||
Tuple!(Range1, Range2)
|
||||
mismatch(alias pred = "a == b", Range1, Range2)(Range1 r1, Range2 r2)
|
||||
if (isInputRange!(Range1) && isInputRange!(Range2))
|
||||
if (isInputRange!(Range1) && isInputRange!(Range2))
|
||||
{
|
||||
for (; !r1.empty && !r2.empty; r1.popFront(), r2.popFront())
|
||||
{
|
||||
|
|
@ -1745,10 +1746,10 @@ Returns:
|
|||
$(D true) if both ranges have the same length, $(D false) otherwise.
|
||||
*/
|
||||
bool isSameLength(Range1, Range2)(Range1 r1, Range2 r2)
|
||||
if (isInputRange!Range1 &&
|
||||
isInputRange!Range2 &&
|
||||
!isInfinite!Range1 &&
|
||||
!isInfinite!Range2)
|
||||
if (isInputRange!Range1 &&
|
||||
isInputRange!Range2 &&
|
||||
!isInfinite!Range1 &&
|
||||
!isInfinite!Range2)
|
||||
{
|
||||
static if (hasLength!(Range1) && hasLength!(Range2))
|
||||
{
|
||||
|
|
@ -1889,11 +1890,11 @@ Returns:
|
|||
|
||||
bool isPermutation(AllocateGC allocate_gc, Range1, Range2)
|
||||
(Range1 r1, Range2 r2)
|
||||
if (allocate_gc == Yes.allocateGC &&
|
||||
isForwardRange!Range1 &&
|
||||
isForwardRange!Range2 &&
|
||||
!isInfinite!Range1 &&
|
||||
!isInfinite!Range2)
|
||||
if (allocate_gc == Yes.allocateGC &&
|
||||
isForwardRange!Range1 &&
|
||||
isForwardRange!Range2 &&
|
||||
!isInfinite!Range1 &&
|
||||
!isInfinite!Range2)
|
||||
{
|
||||
alias E1 = Unqual!(ElementType!Range1);
|
||||
alias E2 = Unqual!(ElementType!Range2);
|
||||
|
|
@ -1937,11 +1938,11 @@ bool isPermutation(AllocateGC allocate_gc, Range1, Range2)
|
|||
/// ditto
|
||||
bool isPermutation(alias pred = "a == b", Range1, Range2)
|
||||
(Range1 r1, Range2 r2)
|
||||
if (is(typeof(binaryFun!(pred))) &&
|
||||
isForwardRange!Range1 &&
|
||||
isForwardRange!Range2 &&
|
||||
!isInfinite!Range1 &&
|
||||
!isInfinite!Range2)
|
||||
if (is(typeof(binaryFun!(pred))) &&
|
||||
isForwardRange!Range1 &&
|
||||
isForwardRange!Range2 &&
|
||||
!isInfinite!Range1 &&
|
||||
!isInfinite!Range2)
|
||||
{
|
||||
import std.algorithm.searching : count;
|
||||
|
||||
|
|
@ -2093,9 +2094,9 @@ Returns:
|
|||
The _first argument that passes the test `pred`.
|
||||
*/
|
||||
CommonType!(T, Ts) either(alias pred = a => a, T, Ts...)(T first, lazy Ts alternatives)
|
||||
if (alternatives.length >= 1 &&
|
||||
!is(CommonType!(T, Ts) == void) &&
|
||||
allSatisfy!(ifTestable, T, Ts))
|
||||
if (alternatives.length >= 1 &&
|
||||
!is(CommonType!(T, Ts) == void) &&
|
||||
allSatisfy!(ifTestable, T, Ts))
|
||||
{
|
||||
alias predFun = unaryFun!pred;
|
||||
|
||||
|
|
|
|||
|
|
@ -70,7 +70,8 @@ import std.functional; // : unaryFun, binaryFun;
|
|||
import std.range.primitives;
|
||||
import std.traits;
|
||||
|
||||
private template aggregate(fun...) if (fun.length >= 1)
|
||||
private template aggregate(fun...)
|
||||
if (fun.length >= 1)
|
||||
{
|
||||
/* --Intentionally not ddoc--
|
||||
* Aggregates elements in each subrange of the given range of ranges using
|
||||
|
|
@ -453,7 +454,8 @@ Returns:
|
|||
See_Also:
|
||||
$(HTTP en.wikipedia.org/wiki/Map_(higher-order_function), Map (higher-order function))
|
||||
*/
|
||||
template map(fun...) if (fun.length >= 1)
|
||||
template map(fun...)
|
||||
if (fun.length >= 1)
|
||||
{
|
||||
auto map(Range)(Range r) if (isInputRange!(Unqual!Range))
|
||||
{
|
||||
|
|
@ -1084,7 +1086,8 @@ Returns:
|
|||
See_Also:
|
||||
$(HTTP en.wikipedia.org/wiki/Filter_(higher-order_function), Filter (higher-order function))
|
||||
*/
|
||||
template filter(alias predicate) if (is(typeof(unaryFun!predicate)))
|
||||
template filter(alias predicate)
|
||||
if (is(typeof(unaryFun!predicate)))
|
||||
{
|
||||
auto filter(Range)(Range range) if (isInputRange!(Unqual!Range))
|
||||
{
|
||||
|
|
@ -1394,7 +1397,8 @@ Group!(pred, Range) group(alias pred = "a == b", Range)(Range r)
|
|||
}
|
||||
|
||||
/// ditto
|
||||
struct Group(alias pred, R) if (isInputRange!R)
|
||||
struct Group(alias pred, R)
|
||||
if (isInputRange!R)
|
||||
{
|
||||
import std.typecons : Rebindable, tuple, Tuple;
|
||||
|
||||
|
|
@ -1542,7 +1546,7 @@ struct Group(alias pred, R) if (isInputRange!R)
|
|||
|
||||
// Used by implementation of chunkBy for non-forward input ranges.
|
||||
private struct ChunkByChunkImpl(alias pred, Range)
|
||||
if (isInputRange!Range && !isForwardRange!Range)
|
||||
if (isInputRange!Range && !isForwardRange!Range)
|
||||
{
|
||||
alias fun = binaryFun!pred;
|
||||
|
||||
|
|
@ -1581,7 +1585,7 @@ private template ChunkByImplIsUnary(alias pred, Range)
|
|||
|
||||
// Implementation of chunkBy for non-forward input ranges.
|
||||
private struct ChunkByImpl(alias pred, Range)
|
||||
if (isInputRange!Range && !isForwardRange!Range)
|
||||
if (isInputRange!Range && !isForwardRange!Range)
|
||||
{
|
||||
enum bool isUnary = ChunkByImplIsUnary!(pred, Range);
|
||||
|
||||
|
|
@ -1645,7 +1649,7 @@ private struct ChunkByImpl(alias pred, Range)
|
|||
|
||||
// Single-pass implementation of chunkBy for forward ranges.
|
||||
private struct ChunkByImpl(alias pred, Range)
|
||||
if (isForwardRange!Range)
|
||||
if (isForwardRange!Range)
|
||||
{
|
||||
import std.typecons : RefCounted;
|
||||
|
||||
|
|
@ -1861,7 +1865,7 @@ private struct ChunkByImpl(alias pred, Range)
|
|||
* element.
|
||||
*/
|
||||
auto chunkBy(alias pred, Range)(Range r)
|
||||
if (isInputRange!Range)
|
||||
if (isInputRange!Range)
|
||||
{
|
||||
return ChunkByImpl!(pred, Range)(r);
|
||||
}
|
||||
|
|
@ -2699,7 +2703,8 @@ See_Also:
|
|||
$(LREF sum) is similar to $(D reduce!((a, b) => a + b)) that offers
|
||||
pairwise summing of floating point numbers.
|
||||
+/
|
||||
template reduce(fun...) if (fun.length >= 1)
|
||||
template reduce(fun...)
|
||||
if (fun.length >= 1)
|
||||
{
|
||||
import std.meta : staticMap;
|
||||
|
||||
|
|
@ -3068,7 +3073,8 @@ The number of seeds must be correspondingly increased.
|
|||
//http://forum.dlang.org/post/oghtttkopzjshsuflelk@forum.dlang.org
|
||||
//Seed is tuple of const.
|
||||
static auto minmaxElement(alias F = min, alias G = max, R)(in R range)
|
||||
@safe pure nothrow if (isInputRange!R)
|
||||
@safe pure nothrow
|
||||
if (isInputRange!R)
|
||||
{
|
||||
return reduce!(F, G)(tuple(ElementType!R.max,
|
||||
ElementType!R.min), range);
|
||||
|
|
@ -3149,7 +3155,8 @@ See_Also:
|
|||
This is functionally equivalent to $(LREF reduce) with the argument order reversed,
|
||||
and without the need to use $(LREF tuple) for multiple seeds.
|
||||
+/
|
||||
template fold(fun...) if (fun.length >= 1)
|
||||
template fold(fun...)
|
||||
if (fun.length >= 1)
|
||||
{
|
||||
auto fold(R, S...)(R r, S seed)
|
||||
{
|
||||
|
|
@ -3522,7 +3529,8 @@ The number of seeds must be correspondingly increased.
|
|||
|
||||
//Seed is tuple of const.
|
||||
static auto minmaxElement(alias F = min, alias G = max, R)(in R range)
|
||||
@safe pure nothrow if (isInputRange!R)
|
||||
@safe pure nothrow
|
||||
if (isInputRange!R)
|
||||
{
|
||||
return range.cumulativeFold!(F, G)(tuple(ElementType!R.max, ElementType!R.min));
|
||||
}
|
||||
|
|
@ -5121,14 +5129,14 @@ See_Also:
|
|||
$(REF nextPermutation, std,algorithm,sorting).
|
||||
*/
|
||||
Permutations!Range permutations(Range)(Range r)
|
||||
if (isRandomAccessRange!Range && hasLength!Range)
|
||||
if (isRandomAccessRange!Range && hasLength!Range)
|
||||
{
|
||||
return typeof(return)(r);
|
||||
}
|
||||
|
||||
/// ditto
|
||||
struct Permutations(Range)
|
||||
if (isRandomAccessRange!Range && hasLength!Range)
|
||||
if (isRandomAccessRange!Range && hasLength!Range)
|
||||
{
|
||||
private size_t[] _indices, _state;
|
||||
private Range _r;
|
||||
|
|
|
|||
|
|
@ -114,7 +114,7 @@ See_Also:
|
|||
$(HTTP sgi.com/tech/stl/_rotate.html, STL's rotate)
|
||||
*/
|
||||
size_t bringToFront(InputRange, ForwardRange)(InputRange front, ForwardRange back)
|
||||
if (isInputRange!InputRange && isForwardRange!ForwardRange)
|
||||
if (isInputRange!InputRange && isForwardRange!ForwardRange)
|
||||
{
|
||||
import std.string : representation;
|
||||
|
||||
|
|
@ -139,7 +139,7 @@ size_t bringToFront(InputRange, ForwardRange)(InputRange front, ForwardRange bac
|
|||
}
|
||||
|
||||
private size_t bringToFrontImpl(InputRange, ForwardRange)(InputRange front, ForwardRange back)
|
||||
if (isInputRange!InputRange && isForwardRange!ForwardRange)
|
||||
if (isInputRange!InputRange && isForwardRange!ForwardRange)
|
||||
{
|
||||
import std.range : take, Take;
|
||||
import std.array : sameHead;
|
||||
|
|
@ -363,7 +363,7 @@ See_Also:
|
|||
$(HTTP sgi.com/tech/stl/_copy.html, STL's _copy)
|
||||
*/
|
||||
TargetRange copy(SourceRange, TargetRange)(SourceRange source, TargetRange target)
|
||||
if (areCopyCompatibleArrays!(SourceRange, TargetRange))
|
||||
if (areCopyCompatibleArrays!(SourceRange, TargetRange))
|
||||
{
|
||||
const tlen = target.length;
|
||||
const slen = source.length;
|
||||
|
|
@ -392,9 +392,9 @@ TargetRange copy(SourceRange, TargetRange)(SourceRange source, TargetRange targe
|
|||
|
||||
/// ditto
|
||||
TargetRange copy(SourceRange, TargetRange)(SourceRange source, TargetRange target)
|
||||
if (!areCopyCompatibleArrays!(SourceRange, TargetRange) &&
|
||||
isInputRange!SourceRange &&
|
||||
isOutputRange!(TargetRange, ElementType!SourceRange))
|
||||
if (!areCopyCompatibleArrays!(SourceRange, TargetRange) &&
|
||||
isInputRange!SourceRange &&
|
||||
isOutputRange!(TargetRange, ElementType!SourceRange))
|
||||
{
|
||||
// Specialize for 2 random access ranges.
|
||||
// Typically 2 random access ranges are faster iterated by common
|
||||
|
|
@ -541,7 +541,7 @@ See_Also:
|
|||
$(LREF initializeAll)
|
||||
*/
|
||||
void fill(Range, Value)(Range range, Value value)
|
||||
if (isInputRange!Range && is(typeof(range.front = value)))
|
||||
if (isInputRange!Range && is(typeof(range.front = value)))
|
||||
{
|
||||
alias T = ElementType!Range;
|
||||
|
||||
|
|
@ -652,10 +652,10 @@ Params:
|
|||
representing the _fill pattern.
|
||||
*/
|
||||
void fill(InputRange, ForwardRange)(InputRange range, ForwardRange filler)
|
||||
if (isInputRange!InputRange
|
||||
&& (isForwardRange!ForwardRange
|
||||
|| (isInputRange!ForwardRange && isInfinite!ForwardRange))
|
||||
&& is(typeof(InputRange.init.front = ForwardRange.init.front)))
|
||||
if (isInputRange!InputRange
|
||||
&& (isForwardRange!ForwardRange
|
||||
|| (isInputRange!ForwardRange && isInfinite!ForwardRange))
|
||||
&& is(typeof(InputRange.init.front = ForwardRange.init.front)))
|
||||
{
|
||||
static if (isInfinite!ForwardRange)
|
||||
{
|
||||
|
|
@ -776,7 +776,7 @@ See_Also:
|
|||
$(LREF uninitializeFill)
|
||||
*/
|
||||
void initializeAll(Range)(Range range)
|
||||
if (isInputRange!Range && hasLvalueElements!Range && hasAssignableElements!Range)
|
||||
if (isInputRange!Range && hasLvalueElements!Range && hasAssignableElements!Range)
|
||||
{
|
||||
import core.stdc.string : memset, memcpy;
|
||||
import std.traits : hasElaborateAssign, isDynamicArray;
|
||||
|
|
@ -825,7 +825,7 @@ void initializeAll(Range)(Range range)
|
|||
|
||||
/// ditto
|
||||
void initializeAll(Range)(Range range)
|
||||
if (is(Range == char[]) || is(Range == wchar[]))
|
||||
if (is(Range == char[]) || is(Range == wchar[]))
|
||||
{
|
||||
alias T = ElementEncodingType!Range;
|
||||
range[] = T.init;
|
||||
|
|
@ -2226,21 +2226,21 @@ if (isNarrowString!(Char[]) && !is(Char == const) && !is(Char == immutable))
|
|||
a Range with all of range except element at the start and end
|
||||
*/
|
||||
Range strip(Range, E)(Range range, E element)
|
||||
if (isBidirectionalRange!Range && is(typeof(range.front == element) : bool))
|
||||
if (isBidirectionalRange!Range && is(typeof(range.front == element) : bool))
|
||||
{
|
||||
return range.stripLeft(element).stripRight(element);
|
||||
}
|
||||
|
||||
/// ditto
|
||||
Range strip(alias pred, Range)(Range range)
|
||||
if (isBidirectionalRange!Range && is(typeof(pred(range.back)) : bool))
|
||||
if (isBidirectionalRange!Range && is(typeof(pred(range.back)) : bool))
|
||||
{
|
||||
return range.stripLeft!pred().stripRight!pred();
|
||||
}
|
||||
|
||||
/// ditto
|
||||
Range stripLeft(Range, E)(Range range, E element)
|
||||
if (isInputRange!Range && is(typeof(range.front == element) : bool))
|
||||
if (isInputRange!Range && is(typeof(range.front == element) : bool))
|
||||
{
|
||||
import std.algorithm.searching : find;
|
||||
return find!((auto ref a) => a != element)(range);
|
||||
|
|
@ -2248,7 +2248,7 @@ Range stripLeft(Range, E)(Range range, E element)
|
|||
|
||||
/// ditto
|
||||
Range stripLeft(alias pred, Range)(Range range)
|
||||
if (isInputRange!Range && is(typeof(pred(range.front)) : bool))
|
||||
if (isInputRange!Range && is(typeof(pred(range.front)) : bool))
|
||||
{
|
||||
import std.algorithm.searching : find;
|
||||
import std.functional : not;
|
||||
|
|
@ -2258,7 +2258,7 @@ Range stripLeft(alias pred, Range)(Range range)
|
|||
|
||||
/// ditto
|
||||
Range stripRight(Range, E)(Range range, E element)
|
||||
if (isBidirectionalRange!Range && is(typeof(range.back == element) : bool))
|
||||
if (isBidirectionalRange!Range && is(typeof(range.back == element) : bool))
|
||||
{
|
||||
for (; !range.empty; range.popBack())
|
||||
{
|
||||
|
|
@ -2270,7 +2270,7 @@ Range stripRight(Range, E)(Range range, E element)
|
|||
|
||||
/// ditto
|
||||
Range stripRight(alias pred, Range)(Range range)
|
||||
if (isBidirectionalRange!Range && is(typeof(pred(range.back)) : bool))
|
||||
if (isBidirectionalRange!Range && is(typeof(pred(range.back)) : bool))
|
||||
{
|
||||
for (; !range.empty; range.popBack())
|
||||
{
|
||||
|
|
@ -2572,7 +2572,7 @@ unittest
|
|||
|
||||
/// ditto
|
||||
void swap(T)(ref T lhs, ref T rhs)
|
||||
if (is(typeof(lhs.proxySwap(rhs))))
|
||||
if (is(typeof(lhs.proxySwap(rhs))))
|
||||
{
|
||||
lhs.proxySwap(rhs);
|
||||
}
|
||||
|
|
@ -2694,7 +2694,7 @@ pure @safe nothrow unittest
|
|||
}
|
||||
|
||||
private void swapFront(R1, R2)(R1 r1, R2 r2)
|
||||
if (isInputRange!R1 && isInputRange!R2)
|
||||
if (isInputRange!R1 && isInputRange!R2)
|
||||
{
|
||||
static if (is(typeof(swap(r1.front, r2.front))))
|
||||
{
|
||||
|
|
@ -2727,8 +2727,8 @@ Returns:
|
|||
*/
|
||||
Tuple!(InputRange1, InputRange2)
|
||||
swapRanges(InputRange1, InputRange2)(InputRange1 r1, InputRange2 r2)
|
||||
if (hasSwappableElements!InputRange1 && hasSwappableElements!InputRange2
|
||||
&& is(ElementType!InputRange1 == ElementType!InputRange2))
|
||||
if (hasSwappableElements!InputRange1 && hasSwappableElements!InputRange2
|
||||
&& is(ElementType!InputRange1 == ElementType!InputRange2))
|
||||
{
|
||||
for (; !r1.empty && !r2.empty; r1.popFront(), r2.popFront())
|
||||
{
|
||||
|
|
@ -2768,7 +2768,7 @@ See_Also:
|
|||
$(LREF initializeAll)
|
||||
*/
|
||||
void uninitializedFill(Range, Value)(Range range, Value value)
|
||||
if (isInputRange!Range && hasLvalueElements!Range && is(typeof(range.front = value)))
|
||||
if (isInputRange!Range && hasLvalueElements!Range && is(typeof(range.front = value)))
|
||||
{
|
||||
import std.traits : hasElaborateAssign;
|
||||
|
||||
|
|
|
|||
|
|
@ -381,7 +381,8 @@ public:
|
|||
/// Ditto
|
||||
BoyerMooreFinder!(binaryFun!(pred), Range) boyerMooreFinder
|
||||
(alias pred = "a == b", Range)
|
||||
(Range needle) if ((isRandomAccessRange!(Range) && hasSlicing!Range) || isSomeString!Range)
|
||||
(Range needle)
|
||||
if ((isRandomAccessRange!(Range) && hasSlicing!Range) || isSomeString!Range)
|
||||
{
|
||||
return typeof(return)(needle);
|
||||
}
|
||||
|
|
@ -615,8 +616,8 @@ Returns:
|
|||
The number of positions in the `haystack` for which `pred` returned true.
|
||||
*/
|
||||
size_t count(alias pred = "a == b", Range, E)(Range haystack, E needle)
|
||||
if (isInputRange!Range && !isInfinite!Range &&
|
||||
is(typeof(binaryFun!pred(haystack.front, needle)) : bool))
|
||||
if (isInputRange!Range && !isInfinite!Range &&
|
||||
is(typeof(binaryFun!pred(haystack.front, needle)) : bool))
|
||||
{
|
||||
bool pred2(ElementType!Range a) { return binaryFun!pred(a, needle); }
|
||||
return count!pred2(haystack);
|
||||
|
|
@ -672,9 +673,9 @@ size_t count(alias pred = "a == b", Range, E)(Range haystack, E needle)
|
|||
|
||||
/// Ditto
|
||||
size_t count(alias pred = "a == b", R1, R2)(R1 haystack, R2 needle)
|
||||
if (isForwardRange!R1 && !isInfinite!R1 &&
|
||||
isForwardRange!R2 &&
|
||||
is(typeof(binaryFun!pred(haystack.front, needle.front)) : bool))
|
||||
if (isForwardRange!R1 && !isInfinite!R1 &&
|
||||
isForwardRange!R2 &&
|
||||
is(typeof(binaryFun!pred(haystack.front, needle.front)) : bool))
|
||||
{
|
||||
assert(!needle.empty, "Cannot count occurrences of an empty range");
|
||||
|
||||
|
|
@ -696,8 +697,8 @@ size_t count(alias pred = "a == b", R1, R2)(R1 haystack, R2 needle)
|
|||
|
||||
/// Ditto
|
||||
size_t count(alias pred = "true", R)(R haystack)
|
||||
if (isInputRange!R && !isInfinite!R &&
|
||||
is(typeof(unaryFun!pred(haystack.front)) : bool))
|
||||
if (isInputRange!R && !isInfinite!R &&
|
||||
is(typeof(unaryFun!pred(haystack.front)) : bool))
|
||||
{
|
||||
size_t result;
|
||||
alias T = ElementType!R; //For narrow strings forces dchar iteration
|
||||
|
|
@ -745,12 +746,12 @@ size_t count(alias pred = "true", R)(R haystack)
|
|||
See_Also: $(REF indexOf, std,string)
|
||||
+/
|
||||
ptrdiff_t countUntil(alias pred = "a == b", R, Rs...)(R haystack, Rs needles)
|
||||
if (isForwardRange!R
|
||||
&& Rs.length > 0
|
||||
&& isForwardRange!(Rs[0]) == isInputRange!(Rs[0])
|
||||
&& is(typeof(startsWith!pred(haystack, needles[0])))
|
||||
&& (Rs.length == 1
|
||||
|| is(typeof(countUntil!pred(haystack, needles[1 .. $])))))
|
||||
if (isForwardRange!R
|
||||
&& Rs.length > 0
|
||||
&& isForwardRange!(Rs[0]) == isInputRange!(Rs[0])
|
||||
&& is(typeof(startsWith!pred(haystack, needles[0])))
|
||||
&& (Rs.length == 1
|
||||
|| is(typeof(countUntil!pred(haystack, needles[1 .. $])))))
|
||||
{
|
||||
typeof(return) result;
|
||||
|
||||
|
|
@ -833,8 +834,8 @@ ptrdiff_t countUntil(alias pred = "a == b", R, Rs...)(R haystack, Rs needles)
|
|||
|
||||
/// ditto
|
||||
ptrdiff_t countUntil(alias pred = "a == b", R, N)(R haystack, N needle)
|
||||
if (isInputRange!R &&
|
||||
is(typeof(binaryFun!pred(haystack.front, needle)) : bool))
|
||||
if (isInputRange!R &&
|
||||
is(typeof(binaryFun!pred(haystack.front, needle)) : bool))
|
||||
{
|
||||
bool pred2(ElementType!R a) { return binaryFun!pred(a, needle); }
|
||||
return countUntil!pred2(haystack);
|
||||
|
|
@ -903,8 +904,8 @@ ptrdiff_t countUntil(alias pred = "a == b", R, N)(R haystack, N needle)
|
|||
before $(D pred(haystack.front)) is $(D true).
|
||||
+/
|
||||
ptrdiff_t countUntil(alias pred, R)(R haystack)
|
||||
if (isInputRange!R &&
|
||||
is(typeof(unaryFun!pred(haystack.front)) : bool))
|
||||
if (isInputRange!R &&
|
||||
is(typeof(unaryFun!pred(haystack.front)) : bool))
|
||||
{
|
||||
typeof(return) i;
|
||||
static if (isRandomAccessRange!R)
|
||||
|
|
@ -1117,8 +1118,8 @@ if (isBidirectionalRange!R &&
|
|||
|
||||
/// Ditto
|
||||
bool endsWith(alias pred, R)(R doesThisEnd)
|
||||
if (isInputRange!R &&
|
||||
ifTestable!(typeof(doesThisEnd.front), unaryFun!pred))
|
||||
if (isInputRange!R &&
|
||||
ifTestable!(typeof(doesThisEnd.front), unaryFun!pred))
|
||||
{
|
||||
return !doesThisEnd.empty && unaryFun!pred(doesThisEnd.back);
|
||||
}
|
||||
|
|
@ -1252,7 +1253,7 @@ Returns:
|
|||
The extreme value according to `map` and `selector` of the passed-in values.
|
||||
*/
|
||||
private auto extremum(alias map = "a", alias selector = "a < b", Range)(Range r)
|
||||
if (isInputRange!Range && !isInfinite!Range)
|
||||
if (isInputRange!Range && !isInfinite!Range)
|
||||
in
|
||||
{
|
||||
assert(!r.empty, "r is an empty range");
|
||||
|
|
@ -1269,8 +1270,8 @@ body
|
|||
private auto extremum(alias map = "a", alias selector = "a < b", Range,
|
||||
RangeElementType = ElementType!Range)
|
||||
(Range r, RangeElementType seedElement)
|
||||
if (isInputRange!Range && !isInfinite!Range &&
|
||||
!is(CommonType!(ElementType!Range, RangeElementType) == void))
|
||||
if (isInputRange!Range && !isInfinite!Range &&
|
||||
!is(CommonType!(ElementType!Range, RangeElementType) == void))
|
||||
{
|
||||
alias mapFun = unaryFun!map;
|
||||
alias selectorFun = binaryFun!selector;
|
||||
|
|
@ -2509,7 +2510,7 @@ See_Also:
|
|||
$(HTTP sgi.com/tech/stl/adjacent_find.html, STL's adjacent_find)
|
||||
*/
|
||||
Range findAdjacent(alias pred = "a == b", Range)(Range r)
|
||||
if (isForwardRange!(Range))
|
||||
if (isForwardRange!(Range))
|
||||
{
|
||||
auto ahead = r.save;
|
||||
if (!ahead.empty)
|
||||
|
|
@ -2587,7 +2588,7 @@ See_Also:
|
|||
*/
|
||||
InputRange findAmong(alias pred = "a == b", InputRange, ForwardRange)(
|
||||
InputRange seq, ForwardRange choices)
|
||||
if (isInputRange!InputRange && isForwardRange!ForwardRange)
|
||||
if (isInputRange!InputRange && isForwardRange!ForwardRange)
|
||||
{
|
||||
for (; !seq.empty && find!pred(choices, seq.front).empty; seq.popFront())
|
||||
{
|
||||
|
|
@ -3283,7 +3284,7 @@ See_Also:
|
|||
$(REF min, std,algorithm,comparison)
|
||||
*/
|
||||
auto minElement(alias map = "a", Range)(Range r)
|
||||
if (isInputRange!Range && !isInfinite!Range)
|
||||
if (isInputRange!Range && !isInfinite!Range)
|
||||
{
|
||||
return extremum!map(r);
|
||||
}
|
||||
|
|
@ -3291,8 +3292,8 @@ auto minElement(alias map = "a", Range)(Range r)
|
|||
/// ditto
|
||||
auto minElement(alias map = "a", Range, RangeElementType = ElementType!Range)
|
||||
(Range r, RangeElementType seed)
|
||||
if (isInputRange!Range && !isInfinite!Range &&
|
||||
!is(CommonType!(ElementType!Range, RangeElementType) == void))
|
||||
if (isInputRange!Range && !isInfinite!Range &&
|
||||
!is(CommonType!(ElementType!Range, RangeElementType) == void))
|
||||
{
|
||||
return extremum!map(r, seed);
|
||||
}
|
||||
|
|
@ -3375,8 +3376,8 @@ See_Also:
|
|||
$(REF max, std,algorithm,comparison)
|
||||
*/
|
||||
auto maxElement(alias map = "a", Range)(Range r)
|
||||
if (isInputRange!Range && !isInfinite!Range &&
|
||||
!is(CommonType!(ElementType!Range, RangeElementType) == void))
|
||||
if (isInputRange!Range && !isInfinite!Range &&
|
||||
!is(CommonType!(ElementType!Range, RangeElementType) == void))
|
||||
{
|
||||
return extremum!(map, "a > b")(r);
|
||||
}
|
||||
|
|
@ -3384,7 +3385,7 @@ auto maxElement(alias map = "a", Range)(Range r)
|
|||
/// ditto
|
||||
auto maxElement(alias map = "a", Range, RangeElementType = ElementType!Range)
|
||||
(Range r, RangeElementType seed)
|
||||
if (isInputRange!Range && !isInfinite!Range)
|
||||
if (isInputRange!Range && !isInfinite!Range)
|
||||
{
|
||||
return extremum!(map, "a > b")(r, seed);
|
||||
}
|
||||
|
|
@ -3477,8 +3478,8 @@ smallest (respectively largest) element and with the same ending as `range`.
|
|||
|
||||
*/
|
||||
Range minPos(alias pred = "a < b", Range)(Range range)
|
||||
if (isForwardRange!Range && !isInfinite!Range &&
|
||||
is(typeof(binaryFun!pred(range.front, range.front))))
|
||||
if (isForwardRange!Range && !isInfinite!Range &&
|
||||
is(typeof(binaryFun!pred(range.front, range.front))))
|
||||
{
|
||||
static if (hasSlicing!Range && isRandomAccessRange!Range && hasLength!Range)
|
||||
{
|
||||
|
|
@ -3593,8 +3594,8 @@ See_Also:
|
|||
$(REF min, std,algorithm,comparison), $(LREF minCount), $(LREF minElement), $(LREF minPos)
|
||||
*/
|
||||
sizediff_t minIndex(alias pred = "a < b", Range)(Range range)
|
||||
if (isForwardRange!Range && !isInfinite!Range &&
|
||||
is(typeof(binaryFun!pred(range.front, range.front))))
|
||||
if (isForwardRange!Range && !isInfinite!Range &&
|
||||
is(typeof(binaryFun!pred(range.front, range.front))))
|
||||
{
|
||||
if (range.empty) return -1;
|
||||
|
||||
|
|
@ -3711,8 +3712,8 @@ See_Also:
|
|||
$(REF max, std,algorithm,comparison), $(LREF maxCount), $(LREF maxElement), $(LREF maxPos)
|
||||
*/
|
||||
sizediff_t maxIndex(alias pred = "a < b", Range)(Range range)
|
||||
if (isInputRange!Range && !isInfinite!Range &&
|
||||
is(typeof(binaryFun!pred(range.front, range.front))))
|
||||
if (isInputRange!Range && !isInfinite!Range &&
|
||||
is(typeof(binaryFun!pred(range.front, range.front))))
|
||||
{
|
||||
return range.minIndex!((a, b) => binaryFun!pred(b, a));
|
||||
}
|
||||
|
|
@ -3800,8 +3801,8 @@ advanced to the point past this segment; otherwise false, and $(D r1) is left
|
|||
in its original position.
|
||||
*/
|
||||
bool skipOver(R1, R2)(ref R1 r1, R2 r2)
|
||||
if (isForwardRange!R1 && isInputRange!R2
|
||||
&& is(typeof(r1.front == r2.front)))
|
||||
if (isForwardRange!R1 && isInputRange!R2
|
||||
&& is(typeof(r1.front == r2.front)))
|
||||
{
|
||||
static if (is(typeof(r1[0 .. $] == r2) : bool)
|
||||
&& is(typeof(r2.length > r1.length) : bool)
|
||||
|
|
@ -3822,9 +3823,9 @@ bool skipOver(R1, R2)(ref R1 r1, R2 r2)
|
|||
|
||||
/// Ditto
|
||||
bool skipOver(alias pred, R1, R2)(ref R1 r1, R2 r2)
|
||||
if (is(typeof(binaryFun!pred(r1.front, r2.front))) &&
|
||||
isForwardRange!R1 &&
|
||||
isInputRange!R2)
|
||||
if (is(typeof(binaryFun!pred(r1.front, r2.front))) &&
|
||||
isForwardRange!R1 &&
|
||||
isInputRange!R2)
|
||||
{
|
||||
static if (hasLength!R1 && hasLength!R2)
|
||||
{
|
||||
|
|
@ -3880,14 +3881,14 @@ predicate, and the range has been advanced by one element; otherwise false, and
|
|||
the range is left untouched.
|
||||
*/
|
||||
bool skipOver(R, E)(ref R r, E e)
|
||||
if (isInputRange!R && is(typeof(r.front == e) : bool))
|
||||
if (isInputRange!R && is(typeof(r.front == e) : bool))
|
||||
{
|
||||
return skipOver!((a, b) => a == b)(r, e);
|
||||
}
|
||||
|
||||
/// Ditto
|
||||
bool skipOver(alias pred, R, E)(ref R r, E e)
|
||||
if (is(typeof(binaryFun!pred(r.front, e))) && isInputRange!R)
|
||||
if (is(typeof(binaryFun!pred(r.front, e))) && isInputRange!R)
|
||||
{
|
||||
if (r.empty || !binaryFun!pred(r.front, e))
|
||||
return false;
|
||||
|
|
@ -4094,8 +4095,8 @@ if (isInputRange!R1 &&
|
|||
|
||||
/// Ditto
|
||||
bool startsWith(alias pred = "a == b", R, E)(R doesThisStart, E withThis)
|
||||
if (isInputRange!R &&
|
||||
is(typeof(binaryFun!pred(doesThisStart.front, withThis)) : bool))
|
||||
if (isInputRange!R &&
|
||||
is(typeof(binaryFun!pred(doesThisStart.front, withThis)) : bool))
|
||||
{
|
||||
return doesThisStart.empty
|
||||
? false
|
||||
|
|
@ -4104,8 +4105,8 @@ bool startsWith(alias pred = "a == b", R, E)(R doesThisStart, E withThis)
|
|||
|
||||
/// Ditto
|
||||
bool startsWith(alias pred, R)(R doesThisStart)
|
||||
if (isInputRange!R &&
|
||||
ifTestable!(typeof(doesThisStart.front), unaryFun!pred))
|
||||
if (isInputRange!R &&
|
||||
ifTestable!(typeof(doesThisStart.front), unaryFun!pred))
|
||||
{
|
||||
return !doesThisStart.empty && unaryFun!pred(doesThisStart.front);
|
||||
}
|
||||
|
|
@ -4315,7 +4316,8 @@ until(alias pred, Range)
|
|||
}
|
||||
|
||||
/// ditto
|
||||
struct Until(alias pred, Range, Sentinel) if (isInputRange!Range)
|
||||
struct Until(alias pred, Range, Sentinel)
|
||||
if (isInputRange!Range)
|
||||
{
|
||||
private Range _input;
|
||||
static if (!is(Sentinel == void))
|
||||
|
|
|
|||
|
|
@ -77,8 +77,8 @@ Returns:
|
|||
cartesian product of the given ranges.
|
||||
*/
|
||||
auto cartesianProduct(R1, R2)(R1 range1, R2 range2)
|
||||
if (!allSatisfy!(isForwardRange, R1, R2) ||
|
||||
anySatisfy!(isInfinite, R1, R2))
|
||||
if (!allSatisfy!(isForwardRange, R1, R2) ||
|
||||
anySatisfy!(isInfinite, R1, R2))
|
||||
{
|
||||
import std.algorithm.iteration : map, joiner;
|
||||
|
||||
|
|
@ -346,9 +346,9 @@ pure nothrow @safe @nogc unittest
|
|||
|
||||
/// ditto
|
||||
auto cartesianProduct(RR...)(RR ranges)
|
||||
if (ranges.length >= 2 &&
|
||||
allSatisfy!(isForwardRange, RR) &&
|
||||
!anySatisfy!(isInfinite, RR))
|
||||
if (ranges.length >= 2 &&
|
||||
allSatisfy!(isForwardRange, RR) &&
|
||||
!anySatisfy!(isInfinite, RR))
|
||||
{
|
||||
// This overload uses a much less template-heavy implementation when
|
||||
// all ranges are finite forward ranges, which is the most common use
|
||||
|
|
@ -443,8 +443,8 @@ auto cartesianProduct(RR...)(RR ranges)
|
|||
|
||||
/// ditto
|
||||
auto cartesianProduct(R1, R2, RR...)(R1 range1, R2 range2, RR otherRanges)
|
||||
if (!allSatisfy!(isForwardRange, R1, R2, RR) ||
|
||||
anySatisfy!(isInfinite, R1, R2, RR))
|
||||
if (!allSatisfy!(isForwardRange, R1, R2, RR) ||
|
||||
anySatisfy!(isInfinite, R1, R2, RR))
|
||||
{
|
||||
/* We implement the n-ary cartesian product by recursively invoking the
|
||||
* binary cartesian product. To make the resulting range nicer, we denest
|
||||
|
|
@ -879,7 +879,7 @@ Returns:
|
|||
See_also: $(LREF setSymmetricDifference)
|
||||
*/
|
||||
struct SetDifference(alias less = "a < b", R1, R2)
|
||||
if (isInputRange!(R1) && isInputRange!(R2))
|
||||
if (isInputRange!(R1) && isInputRange!(R2))
|
||||
{
|
||||
private:
|
||||
R1 r1;
|
||||
|
|
@ -987,8 +987,8 @@ Returns:
|
|||
A range containing the intersection of the given ranges.
|
||||
*/
|
||||
struct SetIntersection(alias less = "a < b", Rs...)
|
||||
if (Rs.length >= 2 && allSatisfy!(isInputRange, Rs) &&
|
||||
!is(CommonType!(staticMap!(ElementType, Rs)) == void))
|
||||
if (Rs.length >= 2 && allSatisfy!(isInputRange, Rs) &&
|
||||
!is(CommonType!(staticMap!(ElementType, Rs)) == void))
|
||||
{
|
||||
private:
|
||||
Rs _input;
|
||||
|
|
@ -1081,8 +1081,8 @@ public:
|
|||
|
||||
/// Ditto
|
||||
SetIntersection!(less, Rs) setIntersection(alias less = "a < b", Rs...)(Rs ranges)
|
||||
if (Rs.length >= 2 && allSatisfy!(isInputRange, Rs) &&
|
||||
!is(CommonType!(staticMap!(ElementType, Rs)) == void))
|
||||
if (Rs.length >= 2 && allSatisfy!(isInputRange, Rs) &&
|
||||
!is(CommonType!(staticMap!(ElementType, Rs)) == void))
|
||||
{
|
||||
return typeof(return)(ranges);
|
||||
}
|
||||
|
|
@ -1152,7 +1152,7 @@ Returns:
|
|||
See_also: $(LREF setDifference)
|
||||
*/
|
||||
struct SetSymmetricDifference(alias less = "a < b", R1, R2)
|
||||
if (isInputRange!(R1) && isInputRange!(R2))
|
||||
if (isInputRange!(R1) && isInputRange!(R2))
|
||||
{
|
||||
private:
|
||||
R1 r1;
|
||||
|
|
|
|||
|
|
@ -160,7 +160,8 @@ Returns:
|
|||
`true` if the range is sorted, false otherwise. `isSorted` allows
|
||||
duplicates, `isStrictlyMonotonic` not.
|
||||
*/
|
||||
bool isSorted(alias less = "a < b", Range)(Range r) if (isForwardRange!(Range))
|
||||
bool isSorted(alias less = "a < b", Range)(Range r)
|
||||
if (isForwardRange!(Range))
|
||||
{
|
||||
if (r.empty) return true;
|
||||
|
||||
|
|
@ -395,7 +396,7 @@ See_Also:
|
|||
STL's $(HTTP sgi.com/tech/stl/stable_partition.html, stable_partition)
|
||||
*/
|
||||
Range partition(alias predicate, SwapStrategy ss, Range)(Range r)
|
||||
if (ss == SwapStrategy.stable && isRandomAccessRange!(Range) && hasLength!Range && hasSlicing!Range)
|
||||
if (ss == SwapStrategy.stable && isRandomAccessRange!(Range) && hasLength!Range && hasSlicing!Range)
|
||||
{
|
||||
import std.algorithm.mutation : bringToFront;
|
||||
|
||||
|
|
@ -417,7 +418,7 @@ Range partition(alias predicate, SwapStrategy ss, Range)(Range r)
|
|||
|
||||
///ditto
|
||||
Range partition(alias predicate, SwapStrategy ss = SwapStrategy.unstable, Range)(Range r)
|
||||
if (ss != SwapStrategy.stable && isInputRange!Range && hasSwappableElements!Range)
|
||||
if (ss != SwapStrategy.stable && isInputRange!Range && hasSwappableElements!Range)
|
||||
{
|
||||
import std.algorithm.mutation : swap;
|
||||
alias pred = unaryFun!(predicate);
|
||||
|
|
@ -772,7 +773,7 @@ Params:
|
|||
Returns: $(D true) if $(D r) is partitioned according to predicate $(D pred).
|
||||
*/
|
||||
bool isPartitioned(alias pred, Range)(Range r)
|
||||
if (isForwardRange!(Range))
|
||||
if (isForwardRange!(Range))
|
||||
{
|
||||
for (; !r.empty; r.popFront())
|
||||
{
|
||||
|
|
@ -949,8 +950,8 @@ makeIndex(
|
|||
Range,
|
||||
RangeIndex)
|
||||
(Range r, RangeIndex index)
|
||||
if (isForwardRange!(Range) && isRandomAccessRange!(RangeIndex)
|
||||
&& is(ElementType!(RangeIndex) : ElementType!(Range)*))
|
||||
if (isForwardRange!(Range) && isRandomAccessRange!(RangeIndex)
|
||||
&& is(ElementType!(RangeIndex) : ElementType!(Range)*))
|
||||
{
|
||||
import std.algorithm.internal : addressOf;
|
||||
import std.exception : enforce;
|
||||
|
|
@ -1049,9 +1050,9 @@ unittest
|
|||
}
|
||||
|
||||
struct Merge(alias less = "a < b", Rs...)
|
||||
if (Rs.length >= 2 &&
|
||||
allSatisfy!(isInputRange, Rs) &&
|
||||
!is(CommonType!(staticMap!(ElementType, Rs)) == void))
|
||||
if (Rs.length >= 2 &&
|
||||
allSatisfy!(isInputRange, Rs) &&
|
||||
!is(CommonType!(staticMap!(ElementType, Rs)) == void))
|
||||
{
|
||||
public Rs source;
|
||||
private size_t _lastFrontIndex = size_t.max;
|
||||
|
|
@ -1286,9 +1287,9 @@ All of its inputs are assumed to be sorted. This can mean that inputs are
|
|||
`false`).
|
||||
*/
|
||||
Merge!(less, Rs) merge(alias less = "a < b", Rs...)(Rs rs)
|
||||
if (Rs.length >= 2 &&
|
||||
allSatisfy!(isInputRange, Rs) &&
|
||||
!is(CommonType!(staticMap!(ElementType, Rs)) == void))
|
||||
if (Rs.length >= 2 &&
|
||||
allSatisfy!(isInputRange, Rs) &&
|
||||
!is(CommonType!(staticMap!(ElementType, Rs)) == void))
|
||||
{
|
||||
return typeof(return)(rs);
|
||||
}
|
||||
|
|
@ -1829,12 +1830,12 @@ See_Also:
|
|||
SortedRange!(Range, less)
|
||||
sort(alias less = "a < b", SwapStrategy ss = SwapStrategy.unstable,
|
||||
Range)(Range r)
|
||||
if (((ss == SwapStrategy.unstable && (hasSwappableElements!Range ||
|
||||
hasAssignableElements!Range)) ||
|
||||
(ss != SwapStrategy.unstable && hasAssignableElements!Range)) &&
|
||||
isRandomAccessRange!Range &&
|
||||
hasSlicing!Range &&
|
||||
hasLength!Range)
|
||||
if (((ss == SwapStrategy.unstable && (hasSwappableElements!Range ||
|
||||
hasAssignableElements!Range)) ||
|
||||
(ss != SwapStrategy.unstable && hasAssignableElements!Range)) &&
|
||||
isRandomAccessRange!Range &&
|
||||
hasSlicing!Range &&
|
||||
hasLength!Range)
|
||||
/+ Unstable sorting uses the quicksort algorithm, which uses swapAt,
|
||||
which either uses swap(...), requiring swappable elements, or just
|
||||
swaps using assignment.
|
||||
|
|
@ -2888,7 +2889,7 @@ SortedRange!(R, ((a, b) => binaryFun!less(unaryFun!transform(a),
|
|||
unaryFun!transform(b))))
|
||||
schwartzSort(alias transform, alias less = "a < b",
|
||||
SwapStrategy ss = SwapStrategy.unstable, R)(R r)
|
||||
if (isRandomAccessRange!R && hasLength!R)
|
||||
if (isRandomAccessRange!R && hasLength!R)
|
||||
{
|
||||
import std.conv : emplace;
|
||||
import std.string : representation;
|
||||
|
|
@ -3017,7 +3018,7 @@ Params:
|
|||
*/
|
||||
void partialSort(alias less = "a < b", SwapStrategy ss = SwapStrategy.unstable,
|
||||
Range)(Range r, size_t n)
|
||||
if (isRandomAccessRange!(Range) && hasLength!(Range) && hasSlicing!(Range))
|
||||
if (isRandomAccessRange!(Range) && hasLength!(Range) && hasSlicing!(Range))
|
||||
{
|
||||
partialSort!(less, ss)(r[0 .. n], r[n .. $]);
|
||||
}
|
||||
|
|
@ -3042,9 +3043,9 @@ Params:
|
|||
|
||||
void partialSort(alias less = "a < b", SwapStrategy ss = SwapStrategy.unstable,
|
||||
Range1, Range2)(Range1 r1, Range2 r2)
|
||||
if (isRandomAccessRange!(Range1) && hasLength!Range1 &&
|
||||
isInputRange!Range2 && is(ElementType!Range1 == ElementType!Range2) &&
|
||||
hasLvalueElements!Range1 && hasLvalueElements!Range2)
|
||||
if (isRandomAccessRange!(Range1) && hasLength!Range1 &&
|
||||
isInputRange!Range2 && is(ElementType!Range1 == ElementType!Range2) &&
|
||||
hasLvalueElements!Range1 && hasLvalueElements!Range2)
|
||||
{
|
||||
topN!(less, ss)(r1, r2);
|
||||
sort!(less, ss)(r1);
|
||||
|
|
@ -3092,7 +3093,7 @@ Stable topN has not been implemented yet.
|
|||
auto topN(alias less = "a < b",
|
||||
SwapStrategy ss = SwapStrategy.unstable,
|
||||
Range)(Range r, size_t nth)
|
||||
if (isRandomAccessRange!(Range) && hasLength!Range && hasSlicing!Range)
|
||||
if (isRandomAccessRange!(Range) && hasLength!Range && hasSlicing!Range)
|
||||
{
|
||||
static assert(ss == SwapStrategy.unstable,
|
||||
"Stable topN not yet implemented");
|
||||
|
|
@ -3541,9 +3542,9 @@ Params:
|
|||
auto topN(alias less = "a < b",
|
||||
SwapStrategy ss = SwapStrategy.unstable,
|
||||
Range1, Range2)(Range1 r1, Range2 r2)
|
||||
if (isRandomAccessRange!(Range1) && hasLength!Range1 &&
|
||||
isInputRange!Range2 && is(ElementType!Range1 == ElementType!Range2) &&
|
||||
hasLvalueElements!Range1 && hasLvalueElements!Range2)
|
||||
if (isRandomAccessRange!(Range1) && hasLength!Range1 &&
|
||||
isInputRange!Range2 && is(ElementType!Range1 == ElementType!Range2) &&
|
||||
hasLvalueElements!Range1 && hasLvalueElements!Range2)
|
||||
{
|
||||
import std.container : BinaryHeap;
|
||||
|
||||
|
|
@ -3669,8 +3670,8 @@ Returns: The slice of `target` containing the copied elements.
|
|||
*/
|
||||
TRange topNCopy(alias less = "a < b", SRange, TRange)
|
||||
(SRange source, TRange target, SortOutput sorted = No.sortOutput)
|
||||
if (isInputRange!(SRange) && isRandomAccessRange!(TRange)
|
||||
&& hasLength!(TRange) && hasSlicing!(TRange))
|
||||
if (isInputRange!(SRange) && isRandomAccessRange!(TRange)
|
||||
&& hasLength!(TRange) && hasSlicing!(TRange))
|
||||
{
|
||||
import std.container : BinaryHeap;
|
||||
|
||||
|
|
@ -3749,10 +3750,10 @@ ignored.
|
|||
void topNIndex(alias less = "a < b", SwapStrategy ss = SwapStrategy.unstable,
|
||||
Range, RangeIndex)
|
||||
(Range r, RangeIndex index, SortOutput sorted = No.sortOutput)
|
||||
if (isRandomAccessRange!Range &&
|
||||
isRandomAccessRange!RangeIndex &&
|
||||
hasAssignableElements!RangeIndex &&
|
||||
isIntegral!(ElementType!(RangeIndex)))
|
||||
if (isRandomAccessRange!Range &&
|
||||
isRandomAccessRange!RangeIndex &&
|
||||
hasAssignableElements!RangeIndex &&
|
||||
isIntegral!(ElementType!(RangeIndex)))
|
||||
{
|
||||
static assert(ss == SwapStrategy.unstable,
|
||||
"Stable swap strategy not implemented yet.");
|
||||
|
|
@ -3782,10 +3783,10 @@ void topNIndex(alias less = "a < b", SwapStrategy ss = SwapStrategy.unstable,
|
|||
void topNIndex(alias less = "a < b", SwapStrategy ss = SwapStrategy.unstable,
|
||||
Range, RangeIndex)
|
||||
(Range r, RangeIndex index, SortOutput sorted = No.sortOutput)
|
||||
if (isRandomAccessRange!Range &&
|
||||
isRandomAccessRange!RangeIndex &&
|
||||
hasAssignableElements!RangeIndex &&
|
||||
is(ElementType!(RangeIndex) == ElementType!(Range)*))
|
||||
if (isRandomAccessRange!Range &&
|
||||
isRandomAccessRange!RangeIndex &&
|
||||
hasAssignableElements!RangeIndex &&
|
||||
is(ElementType!(RangeIndex) == ElementType!(Range)*))
|
||||
{
|
||||
static assert(ss == SwapStrategy.unstable,
|
||||
"Stable swap strategy not implemented yet.");
|
||||
|
|
@ -4066,8 +4067,8 @@ do
|
|||
*/
|
||||
bool nextPermutation(alias less="a < b", BidirectionalRange)
|
||||
(BidirectionalRange range)
|
||||
if (isBidirectionalRange!BidirectionalRange &&
|
||||
hasSwappableElements!BidirectionalRange)
|
||||
if (isBidirectionalRange!BidirectionalRange &&
|
||||
hasSwappableElements!BidirectionalRange)
|
||||
{
|
||||
import std.algorithm.mutation : reverse, swap;
|
||||
import std.algorithm.searching : find;
|
||||
|
|
@ -4323,8 +4324,8 @@ do
|
|||
*/
|
||||
bool nextEvenPermutation(alias less="a < b", BidirectionalRange)
|
||||
(BidirectionalRange range)
|
||||
if (isBidirectionalRange!BidirectionalRange &&
|
||||
hasSwappableElements!BidirectionalRange)
|
||||
if (isBidirectionalRange!BidirectionalRange &&
|
||||
hasSwappableElements!BidirectionalRange)
|
||||
{
|
||||
import std.algorithm.mutation : reverse, swap;
|
||||
import std.algorithm.searching : find;
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue