History

gcc-9.1

Wolfgang Thaller committed 7 years ago

Commit 6fbf4221 parent ec13cc931387 files · +2442466 −1054331Browse files

Showing the changes to gcc/libphobos/src/std/algorithm/mutation.d (1 of 31387 files). Show all

Unified · Split

gcc/libphobos/src/std/algorithm/mutation.d+2909−0
@@ -0,0 +1,2909 @@
1+// Written in the D programming language.
2+/**
3+This is a submodule of $(MREF std, algorithm).
4+It contains generic _mutation algorithms.
5+
6+$(SCRIPT inhibitQuickIndex = 1;)
7+$(BOOKTABLE Cheat Sheet,
8+$(TR $(TH Function Name) $(TH Description))
9+$(T2 bringToFront,
10+ If $(D a = [1, 2, 3]) and $(D b = [4, 5, 6, 7]),
11+ $(D bringToFront(a, b)) leaves $(D a = [4, 5, 6]) and
12+ $(D b = [7, 1, 2, 3]).)
13+$(T2 copy,
14+ Copies a range to another. If
15+ $(D a = [1, 2, 3]) and $(D b = new int[5]), then $(D copy(a, b))
16+ leaves $(D b = [1, 2, 3, 0, 0]) and returns $(D b[3 .. $]).)
17+$(T2 fill,
18+ Fills a range with a pattern,
19+ e.g., if $(D a = new int[3]), then $(D fill(a, 4))
20+ leaves $(D a = [4, 4, 4]) and $(D fill(a, [3, 4])) leaves
21+ $(D a = [3, 4, 3]).)
22+$(T2 initializeAll,
23+ If $(D a = [1.2, 3.4]), then $(D initializeAll(a)) leaves
24+ $(D a = [double.init, double.init]).)
25+$(T2 move,
26+ $(D move(a, b)) moves $(D a) into $(D b). $(D move(a)) reads $(D a)
27+ destructively when necessary.)
28+$(T2 moveEmplace,
29+ Similar to $(D move) but assumes `target` is uninitialized.)
30+$(T2 moveAll,
31+ Moves all elements from one range to another.)
32+$(T2 moveEmplaceAll,
33+ Similar to $(D moveAll) but assumes all elements in `target` are uninitialized.)
34+$(T2 moveSome,
35+ Moves as many elements as possible from one range to another.)
36+$(T2 moveEmplaceSome,
37+ Similar to $(D moveSome) but assumes all elements in `target` are uninitialized.)
38+$(T2 remove,
39+ Removes elements from a range in-place, and returns the shortened
40+ range.)
41+$(T2 reverse,
42+ If $(D a = [1, 2, 3]), $(D reverse(a)) changes it to $(D [3, 2, 1]).)
43+$(T2 strip,
44+ Strips all leading and trailing elements equal to a value, or that
45+ satisfy a predicate.
46+ If $(D a = [1, 1, 0, 1, 1]), then $(D strip(a, 1)) and
47+ $(D strip!(e => e == 1)(a)) returns $(D [0]).)
48+$(T2 stripLeft,
49+ Strips all leading elements equal to a value, or that satisfy a
50+ predicate. If $(D a = [1, 1, 0, 1, 1]), then $(D stripLeft(a, 1)) and
51+ $(D stripLeft!(e => e == 1)(a)) returns $(D [0, 1, 1]).)
52+$(T2 stripRight,
53+ Strips all trailing elements equal to a value, or that satisfy a
54+ predicate.
55+ If $(D a = [1, 1, 0, 1, 1]), then $(D stripRight(a, 1)) and
56+ $(D stripRight!(e => e == 1)(a)) returns $(D [1, 1, 0]).)
57+$(T2 swap,
58+ Swaps two values.)
59+$(T2 swapAt,
60+ Swaps two values by indices.)
61+$(T2 swapRanges,
62+ Swaps all elements of two ranges.)
63+$(T2 uninitializedFill,
64+ Fills a range (assumed uninitialized) with a value.)
65+)
66+
67+Copyright: Andrei Alexandrescu 2008-.
68+
69+License: $(HTTP boost.org/LICENSE_1_0.txt, Boost License 1.0).
70+
71+Authors: $(HTTP erdani.com, Andrei Alexandrescu)
72+
73+Source: $(PHOBOSSRC std/algorithm/_mutation.d)
74+
75+Macros:
76+T2=$(TR $(TDNW $(LREF $1)) $(TD $+))
77+ */
78+module std.algorithm.mutation;
79+
80+import std.range.primitives;
81+import std.traits : isArray, isBlitAssignable, isNarrowString, Unqual, isSomeChar;
82+// FIXME
83+import std.typecons; // : tuple, Tuple;
84+
85+// bringToFront
86+/**
87+The $(D bringToFront) function has considerable flexibility and
88+usefulness. It can rotate elements in one buffer left or right, swap
89+buffers of equal length, and even move elements across disjoint
90+buffers of different types and different lengths.
91+
92+$(D bringToFront) takes two ranges $(D front) and $(D back), which may
93+be of different types. Considering the concatenation of $(D front) and
94+$(D back) one unified range, $(D bringToFront) rotates that unified
95+range such that all elements in $(D back) are brought to the beginning
96+of the unified range. The relative ordering of elements in $(D front)
97+and $(D back), respectively, remains unchanged.
98+
99+The $(D bringToFront) function treats strings at the code unit
100+level and it is not concerned with Unicode character integrity.
101+$(D bringToFront) is designed as a function for moving elements
102+in ranges, not as a string function.
103+
104+Performs $(BIGOH max(front.length, back.length)) evaluations of $(D
105+swap).
106+
107+Preconditions:
108+
109+Either $(D front) and $(D back) are disjoint, or $(D back) is
110+reachable from $(D front) and $(D front) is not reachable from $(D
111+back).
112+
113+Params:
114+ front = an $(REF_ALTTEXT input range, isInputRange, std,range,primitives)
115+ back = a $(REF_ALTTEXT forward range, isForwardRange, std,range,primitives)
116+
117+Returns:
118+ The number of elements brought to the front, i.e., the length of $(D back).
119+
120+See_Also:
121+ $(HTTP sgi.com/tech/stl/_rotate.html, STL's rotate)
122+*/
123+size_t bringToFront(InputRange, ForwardRange)(InputRange front, ForwardRange back)
124+if (isInputRange!InputRange && isForwardRange!ForwardRange)
125+{
126+ import std.string : representation;
127+
128+ static if (isNarrowString!InputRange)
129+ {
130+ auto frontW = representation(front);
131+ }
132+ else
133+ {
134+ alias frontW = front;
135+ }
136+ static if (isNarrowString!ForwardRange)
137+ {
138+ auto backW = representation(back);
139+ }
140+ else
141+ {
142+ alias backW = back;
143+ }
144+
145+ return bringToFrontImpl(frontW, backW);
146+}
147+
148+private size_t bringToFrontImpl(InputRange, ForwardRange)(InputRange front, ForwardRange back)
149+if (isInputRange!InputRange && isForwardRange!ForwardRange)
150+{
151+ import std.array : sameHead;
152+ import std.range : take, Take;
153+ enum bool sameHeadExists = is(typeof(front.sameHead(back)));
154+ size_t result;
155+
156+ for (bool semidone; !front.empty && !back.empty; )
157+ {
158+ static if (sameHeadExists)
159+ {
160+ if (front.sameHead(back)) break; // shortcut
161+ }
162+ // Swap elements until front and/or back ends.
163+ auto back0 = back.save;
164+ size_t nswaps;
165+ do
166+ {
167+ static if (sameHeadExists)
168+ {
169+ // Detect the stepping-over condition.
170+ if (front.sameHead(back0)) back0 = back.save;
171+ }
172+ swapFront(front, back);
173+ ++nswaps;
174+ front.popFront();
175+ back.popFront();
176+ }
177+ while (!front.empty && !back.empty);
178+
179+ if (!semidone) result += nswaps;
180+
181+ // Now deal with the remaining elements.
182+ if (back.empty)
183+ {
184+ if (front.empty) break;
185+ // Right side was shorter, which means that we've brought
186+ // all the back elements to the front.
187+ semidone = true;
188+ // Next pass: bringToFront(front, back0) to adjust the rest.
189+ back = back0;
190+ }
191+ else
192+ {
193+ assert(front.empty);
194+ // Left side was shorter. Let's step into the back.
195+ static if (is(InputRange == Take!ForwardRange))
196+ {
197+ front = take(back0, nswaps);
198+ }
199+ else
200+ {
201+ immutable subresult = bringToFront(take(back0, nswaps),
202+ back);
203+ if (!semidone) result += subresult;
204+ break; // done
205+ }
206+ }
207+ }
208+ return result;
209+}
210+
211+/**
212+The simplest use of $(D bringToFront) is for rotating elements in a
213+buffer. For example:
214+*/
215+@safe unittest
216+{
217+ auto arr = [4, 5, 6, 7, 1, 2, 3];
218+ auto p = bringToFront(arr[0 .. 4], arr[4 .. $]);
219+ assert(p == arr.length - 4);
220+ assert(arr == [ 1, 2, 3, 4, 5, 6, 7 ]);
221+}
222+
223+/**
224+The $(D front) range may actually "step over" the $(D back)
225+range. This is very useful with forward ranges that cannot compute
226+comfortably right-bounded subranges like $(D arr[0 .. 4]) above. In
227+the example below, $(D r2) is a right subrange of $(D r1).
228+*/
229+@safe unittest
230+{
231+ import std.algorithm.comparison : equal;
232+ import std.container : SList;
233+ import std.range.primitives : popFrontN;
234+
235+ auto list = SList!(int)(4, 5, 6, 7, 1, 2, 3);
236+ auto r1 = list[];
237+ auto r2 = list[]; popFrontN(r2, 4);
238+ assert(equal(r2, [ 1, 2, 3 ]));
239+ bringToFront(r1, r2);
240+ assert(equal(list[], [ 1, 2, 3, 4, 5, 6, 7 ]));
241+}
242+
243+/**
244+Elements can be swapped across ranges of different types:
245+*/
246+@safe unittest
247+{
248+ import std.algorithm.comparison : equal;
249+ import std.container : SList;
250+
251+ auto list = SList!(int)(4, 5, 6, 7);
252+ auto vec = [ 1, 2, 3 ];
253+ bringToFront(list[], vec);
254+ assert(equal(list[], [ 1, 2, 3, 4 ]));
255+ assert(equal(vec, [ 5, 6, 7 ]));
256+}
257+
258+/**
259+Unicode integrity is not preserved:
260+*/
261+@safe unittest
262+{
263+ import std.string : representation;
264+ auto ar = representation("a".dup);
265+ auto br = representation("ç".dup);
266+
267+ bringToFront(ar, br);
268+
269+ auto a = cast(char[]) ar;
270+ auto b = cast(char[]) br;
271+
272+ // Illegal UTF-8
273+ assert(a == "\303");
274+ // Illegal UTF-8
275+ assert(b == "\247a");
276+}
277+
278+@safe unittest
279+{
280+ import std.algorithm.comparison : equal;
281+ import std.conv : text;
282+ import std.random : Random, unpredictableSeed, uniform;
283+
284+ // a more elaborate test
285+ {
286+ auto rnd = Random(unpredictableSeed);
287+ int[] a = new int[uniform(100, 200, rnd)];
288+ int[] b = new int[uniform(100, 200, rnd)];
289+ foreach (ref e; a) e = uniform(-100, 100, rnd);
290+ foreach (ref e; b) e = uniform(-100, 100, rnd);
291+ int[] c = a ~ b;
292+ // writeln("a= ", a);
293+ // writeln("b= ", b);
294+ auto n = bringToFront(c[0 .. a.length], c[a.length .. $]);
295+ //writeln("c= ", c);
296+ assert(n == b.length);
297+ assert(c == b ~ a, text(c, "\n", a, "\n", b));
298+ }
299+ // different types, moveFront, no sameHead
300+ {
301+ static struct R(T)
302+ {
303+ T[] data;
304+ size_t i;
305+ @property
306+ {
307+ R save() { return this; }
308+ bool empty() { return i >= data.length; }
309+ T front() { return data[i]; }
310+ T front(real e) { return data[i] = cast(T) e; }
311+ }
312+ void popFront() { ++i; }
313+ }
314+ auto a = R!int([1, 2, 3, 4, 5]);
315+ auto b = R!real([6, 7, 8, 9]);
316+ auto n = bringToFront(a, b);
317+ assert(n == 4);
318+ assert(a.data == [6, 7, 8, 9, 1]);
319+ assert(b.data == [2, 3, 4, 5]);
320+ }
321+ // front steps over back
322+ {
323+ int[] arr, r1, r2;
324+
325+ // back is shorter
326+ arr = [4, 5, 6, 7, 1, 2, 3];
327+ r1 = arr;
328+ r2 = arr[4 .. $];
329+ bringToFront(r1, r2) == 3 || assert(0);
330+ assert(equal(arr, [1, 2, 3, 4, 5, 6, 7]));
331+
332+ // front is shorter
333+ arr = [5, 6, 7, 1, 2, 3, 4];
334+ r1 = arr;
335+ r2 = arr[3 .. $];
336+ bringToFront(r1, r2) == 4 || assert(0);
337+ assert(equal(arr, [1, 2, 3, 4, 5, 6, 7]));
338+ }
339+
340+ // Bugzilla 16959
341+ auto arr = ['4', '5', '6', '7', '1', '2', '3'];
342+ auto p = bringToFront(arr[0 .. 4], arr[4 .. $]);
343+
344+ assert(p == arr.length - 4);
345+ assert(arr == ['1', '2', '3', '4', '5', '6', '7']);
346+}
347+
348+// Tests if types are arrays and support slice assign.
349+private enum bool areCopyCompatibleArrays(T1, T2) =
350+ isArray!T1 && isArray!T2 && is(typeof(T2.init[] = T1.init[]));
351+
352+// copy
353+/**
354+Copies the content of $(D source) into $(D target) and returns the
355+remaining (unfilled) part of $(D target).
356+
357+Preconditions: $(D target) shall have enough room to accommodate
358+the entirety of $(D source).
359+
360+Params:
361+ source = an $(REF_ALTTEXT input range, isInputRange, std,range,primitives)
362+ target = an output range
363+
364+Returns:
365+ The unfilled part of target
366+
367+See_Also:
368+ $(HTTP sgi.com/tech/stl/_copy.html, STL's _copy)
369+ */
370+TargetRange copy(SourceRange, TargetRange)(SourceRange source, TargetRange target)
371+if (areCopyCompatibleArrays!(SourceRange, TargetRange))
372+{
373+ const tlen = target.length;
374+ const slen = source.length;
375+ assert(tlen >= slen,
376+ "Cannot copy a source range into a smaller target range.");
377+
378+ immutable overlaps = __ctfe || () @trusted {
379+ return source.ptr < target.ptr + tlen &&
380+ target.ptr < source.ptr + slen; }();
381+
382+ if (overlaps)
383+ {
384+ foreach (idx; 0 .. slen)
385+ target[idx] = source[idx];
386+ return target[slen .. tlen];
387+ }
388+ else
389+ {
390+ // Array specialization. This uses optimized memory copying
391+ // routines under the hood and is about 10-20x faster than the
392+ // generic implementation.
393+ target[0 .. slen] = source[];
394+ return target[slen .. $];
395+ }
396+}
397+
398+/// ditto
399+TargetRange copy(SourceRange, TargetRange)(SourceRange source, TargetRange target)
400+if (!areCopyCompatibleArrays!(SourceRange, TargetRange) &&
401+ isInputRange!SourceRange &&
402+ isOutputRange!(TargetRange, ElementType!SourceRange))
403+{
404+ // Specialize for 2 random access ranges.
405+ // Typically 2 random access ranges are faster iterated by common
406+ // index than by x.popFront(), y.popFront() pair
407+ static if (isRandomAccessRange!SourceRange &&
408+ hasLength!SourceRange &&
409+ hasSlicing!TargetRange &&
410+ isRandomAccessRange!TargetRange &&
411+ hasLength!TargetRange)
412+ {
413+ auto len = source.length;
414+ foreach (idx; 0 .. len)
415+ target[idx] = source[idx];
416+ return target[len .. target.length];
417+ }
418+ else
419+ {
420+ put(target, source);
421+ return target;
422+ }
423+}
424+
425+///
426+@safe unittest
427+{
428+ int[] a = [ 1, 5 ];
429+ int[] b = [ 9, 8 ];
430+ int[] buf = new int[](a.length + b.length + 10);
431+ auto rem = a.copy(buf); // copy a into buf
432+ rem = b.copy(rem); // copy b into remainder of buf
433+ assert(buf[0 .. a.length + b.length] == [1, 5, 9, 8]);
434+ assert(rem.length == 10); // unused slots in buf
435+}
436+
437+/**
438+As long as the target range elements support assignment from source
439+range elements, different types of ranges are accepted:
440+*/
441+@safe unittest
442+{
443+ float[] src = [ 1.0f, 5 ];
444+ double[] dest = new double[src.length];
445+ src.copy(dest);
446+}
447+
448+/**
449+To _copy at most $(D n) elements from a range, you may want to use
450+$(REF take, std,range):
451+*/
452+@safe unittest
453+{
454+ import std.range;
455+ int[] src = [ 1, 5, 8, 9, 10 ];
456+ auto dest = new int[](3);
457+ src.take(dest.length).copy(dest);
458+ assert(dest == [ 1, 5, 8 ]);
459+}
460+
461+/**
462+To _copy just those elements from a range that satisfy a predicate,
463+use $(LREF filter):
464+*/
465+@safe unittest
466+{
467+ import std.algorithm.iteration : filter;
468+ int[] src = [ 1, 5, 8, 9, 10, 1, 2, 0 ];
469+ auto dest = new int[src.length];
470+ auto rem = src
471+ .filter!(a => (a & 1) == 1)
472+ .copy(dest);
473+ assert(dest[0 .. $ - rem.length] == [ 1, 5, 9, 1 ]);
474+}
475+
476+/**
477+$(REF retro, std,range) can be used to achieve behavior similar to
478+$(HTTP sgi.com/tech/stl/copy_backward.html, STL's copy_backward'):
479+*/
480+@safe unittest
481+{
482+ import std.algorithm, std.range;
483+ int[] src = [1, 2, 4];
484+ int[] dest = [0, 0, 0, 0, 0];
485+ src.retro.copy(dest.retro);
486+ assert(dest == [0, 0, 1, 2, 4]);
487+}
488+
489+// Test CTFE copy.
490+@safe unittest
491+{
492+ enum c = copy([1,2,3], [4,5,6,7]);
493+ assert(c == [7]);
494+}
495+
496+
497+@safe unittest
498+{
499+ import std.algorithm.iteration : filter;
500+
501+ {
502+ int[] a = [ 1, 5 ];
503+ int[] b = [ 9, 8 ];
504+ auto e = copy(filter!("a > 1")(a), b);
505+ assert(b[0] == 5 && e.length == 1);
506+ }
507+
508+ {
509+ int[] a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
510+ copy(a[5 .. 10], a[4 .. 9]);
511+ assert(a[4 .. 9] == [6, 7, 8, 9, 10]);
512+ }
513+
514+ { // Test for bug 7898
515+ enum v =
516+ {
517+ import std.algorithm;
518+ int[] arr1 = [10, 20, 30, 40, 50];
519+ int[] arr2 = arr1.dup;
520+ copy(arr1, arr2);
521+ return 35;
522+ }();
523+ assert(v == 35);
524+ }
525+}
526+
527+@safe unittest
528+{
529+ // Issue 13650
530+ import std.meta : AliasSeq;
531+ foreach (Char; AliasSeq!(char, wchar, dchar))
532+ {
533+ Char[3] a1 = "123";
534+ Char[6] a2 = "456789";
535+ assert(copy(a1[], a2[]) is a2[3..$]);
536+ assert(a1[] == "123");
537+ assert(a2[] == "123789");
538+ }
539+}
540+
541+/**
542+Assigns $(D value) to each element of input _range $(D range).
543+
544+Params:
545+ range = An
546+ $(REF_ALTTEXT input _range, isInputRange, std,_range,primitives)
547+ that exposes references to its elements and has assignable
548+ elements
549+ value = Assigned to each element of range
550+
551+See_Also:
552+ $(LREF uninitializedFill)
553+ $(LREF initializeAll)
554+ */
555+void fill(Range, Value)(auto ref Range range, auto ref Value value)
556+if ((isInputRange!Range && is(typeof(range.front = value)) ||
557+ isSomeChar!Value && is(typeof(range[] = value))))
558+{
559+ alias T = ElementType!Range;
560+
561+ static if (is(typeof(range[] = value)))
562+ {
563+ range[] = value;
564+ }
565+ else static if (is(typeof(range[] = T(value))))
566+ {
567+ range[] = T(value);
568+ }
569+ else
570+ {
571+ for ( ; !range.empty; range.popFront() )
572+ {
573+ range.front = value;
574+ }
575+ }
576+}
577+
578+///
579+@safe unittest
580+{
581+ int[] a = [ 1, 2, 3, 4 ];
582+ fill(a, 5);
583+ assert(a == [ 5, 5, 5, 5 ]);
584+}
585+
586+// issue 16342, test fallback on mutable narrow strings
587+@safe unittest
588+{
589+ char[] chars = ['a', 'b'];
590+ fill(chars, 'c');
591+ assert(chars == "cc");
592+
593+ char[2] chars2 = ['a', 'b'];
594+ fill(chars2, 'c');
595+ assert(chars2 == "cc");
596+
597+ wchar[] wchars = ['a', 'b'];
598+ fill(wchars, wchar('c'));
599+ assert(wchars == "cc"w);
600+
601+ dchar[] dchars = ['a', 'b'];
602+ fill(dchars, dchar('c'));
603+ assert(dchars == "cc"d);
604+}
605+
606+@nogc @safe unittest
607+{
608+ const(char)[] chars;
609+ assert(chars.length == 0);
610+ static assert(!__traits(compiles, fill(chars, 'c')));
611+ wstring wchars;
612+ assert(wchars.length == 0);
613+ static assert(!__traits(compiles, fill(wchars, wchar('c'))));
614+}
615+
616+@nogc @safe unittest
617+{
618+ char[] chars;
619+ fill(chars, 'c');
620+ assert(chars == ""c);
621+}
622+
623+@safe unittest
624+{
625+ shared(char)[] chrs = ['r'];
626+ fill(chrs, 'c');
627+ assert(chrs == [shared(char)('c')]);
628+}
629+
630+@nogc @safe unittest
631+{
632+ struct Str(size_t len)
633+ {
634+ private char[len] _data;
635+ void opIndexAssign(char value) @safe @nogc
636+ {_data[] = value;}
637+ }
638+ Str!2 str;
639+ str.fill(':');
640+ assert(str._data == "::");
641+}
642+
643+@safe unittest
644+{
645+ char[] chars = ['a','b','c','d'];
646+ chars[1 .. 3].fill(':');
647+ assert(chars == "a::d");
648+}
649+// end issue 16342
650+
651+@safe unittest
652+{
653+ import std.conv : text;
654+ import std.internal.test.dummyrange;
655+
656+ int[] a = [ 1, 2, 3 ];
657+ fill(a, 6);
658+ assert(a == [ 6, 6, 6 ], text(a));
659+
660+ void fun0()
661+ {
662+ foreach (i; 0 .. 1000)
663+ {
664+ foreach (ref e; a) e = 6;
665+ }
666+ }
667+ void fun1() { foreach (i; 0 .. 1000) fill(a, 6); }
668+
669+ // fill should accept InputRange
670+ alias InputRange = DummyRange!(ReturnBy.Reference, Length.No, RangeType.Input);
671+ enum filler = uint.max;
672+ InputRange range;
673+ fill(range, filler);
674+ foreach (value; range.arr)
675+ assert(value == filler);
676+}
677+
678+@safe unittest
679+{
680+ //ER8638_1 IS_NOT self assignable
681+ static struct ER8638_1
682+ {
683+ void opAssign(int){}
684+ }
685+
686+ //ER8638_1 IS self assignable
687+ static struct ER8638_2
688+ {
689+ void opAssign(ER8638_2){}
690+ void opAssign(int){}
691+ }
692+
693+ auto er8638_1 = new ER8638_1[](10);
694+ auto er8638_2 = new ER8638_2[](10);
695+ er8638_1.fill(5); //generic case
696+ er8638_2.fill(5); //opSlice(T.init) case
697+}
698+
699+@safe unittest
700+{
701+ {
702+ int[] a = [1, 2, 3];
703+ immutable(int) b = 0;
704+ a.fill(b);
705+ assert(a == [0, 0, 0]);
706+ }
707+ {
708+ double[] a = [1, 2, 3];
709+ immutable(int) b = 0;
710+ a.fill(b);
711+ assert(a == [0, 0, 0]);
712+ }
713+}
714+
715+/**
716+Fills $(D range) with a pattern copied from $(D filler). The length of
717+$(D range) does not have to be a multiple of the length of $(D
718+filler). If $(D filler) is empty, an exception is thrown.
719+
720+Params:
721+ range = An $(REF_ALTTEXT input _range, isInputRange, std,_range,primitives)
722+ that exposes references to its elements and has assignable elements.
723+ filler = The
724+ $(REF_ALTTEXT forward _range, isForwardRange, std,_range,primitives)
725+ representing the _fill pattern.
726+ */
727+void fill(InputRange, ForwardRange)(InputRange range, ForwardRange filler)
728+if (isInputRange!InputRange
729+ && (isForwardRange!ForwardRange
730+ || (isInputRange!ForwardRange && isInfinite!ForwardRange))
731+ && is(typeof(InputRange.init.front = ForwardRange.init.front)))
732+{
733+ static if (isInfinite!ForwardRange)
734+ {
735+ //ForwardRange is infinite, no need for bounds checking or saving
736+ static if (hasSlicing!ForwardRange && hasLength!InputRange
737+ && is(typeof(filler[0 .. range.length])))
738+ {
739+ copy(filler[0 .. range.length], range);
740+ }
741+ else
742+ {
743+ //manual feed
744+ for ( ; !range.empty; range.popFront(), filler.popFront())
745+ {
746+ range.front = filler.front;
747+ }
748+ }
749+ }
750+ else
751+ {
752+ import std.exception : enforce;
753+
754+ enforce(!filler.empty, "Cannot fill range with an empty filler");
755+
756+ static if (hasLength!InputRange && hasLength!ForwardRange
757+ && is(typeof(range.length > filler.length)))
758+ {
759+ //Case we have access to length
760+ immutable len = filler.length;
761+ //Start by bulk copies
762+ while (range.length > len)
763+ {
764+ range = copy(filler.save, range);
765+ }
766+
767+ //and finally fill the partial range. No need to save here.
768+ static if (hasSlicing!ForwardRange && is(typeof(filler[0 .. range.length])))
769+ {
770+ //use a quick copy
771+ auto len2 = range.length;
772+ range = copy(filler[0 .. len2], range);
773+ }
774+ else
775+ {
776+ //iterate. No need to check filler, it's length is longer than range's
777+ for (; !range.empty; range.popFront(), filler.popFront())
778+ {
779+ range.front = filler.front;
780+ }
781+ }
782+ }
783+ else
784+ {
785+ //Most basic case.
786+ auto bck = filler.save;
787+ for (; !range.empty; range.popFront(), filler.popFront())
788+ {
789+ if (filler.empty) filler = bck.save;
790+ range.front = filler.front;
791+ }
792+ }
793+ }
794+}
795+
796+///
797+@safe unittest
798+{
799+ int[] a = [ 1, 2, 3, 4, 5 ];
800+ int[] b = [ 8, 9 ];
801+ fill(a, b);
802+ assert(a == [ 8, 9, 8, 9, 8 ]);
803+}
804+
805+@safe unittest
806+{
807+ import std.exception : assertThrown;
808+ import std.internal.test.dummyrange;
809+
810+ int[] a = [ 1, 2, 3, 4, 5 ];
811+ int[] b = [1, 2];
812+ fill(a, b);
813+ assert(a == [ 1, 2, 1, 2, 1 ]);
814+
815+ // fill should accept InputRange
816+ alias InputRange = DummyRange!(ReturnBy.Reference, Length.No, RangeType.Input);
817+ InputRange range;
818+ fill(range,[1,2]);
819+ foreach (i,value;range.arr)
820+ assert(value == (i%2 == 0?1:2));
821+
822+ //test with a input being a "reference forward" range
823+ fill(a, new ReferenceForwardRange!int([8, 9]));
824+ assert(a == [8, 9, 8, 9, 8]);
825+
826+ //test with a input being an "infinite input" range
827+ fill(a, new ReferenceInfiniteInputRange!int());
828+ assert(a == [0, 1, 2, 3, 4]);
829+
830+ //empty filler test
831+ assertThrown(fill(a, a[$..$]));
832+}
833+
834+/**
835+Initializes all elements of $(D range) with their $(D .init) value.
836+Assumes that the elements of the range are uninitialized.
837+
838+Params:
839+ range = An
840+ $(REF_ALTTEXT input _range, isInputRange, std,_range,primitives)
841+ that exposes references to its elements and has assignable
842+ elements
843+
844+See_Also:
845+ $(LREF fill)
846+ $(LREF uninitializeFill)
847+ */
848+void initializeAll(Range)(Range range)
849+if (isInputRange!Range && hasLvalueElements!Range && hasAssignableElements!Range)
850+{
851+ import core.stdc.string : memset, memcpy;
852+ import std.traits : hasElaborateAssign, isDynamicArray;
853+
854+ alias T = ElementType!Range;
855+ static if (hasElaborateAssign!T)
856+ {
857+ import std.algorithm.internal : addressOf;
858+ //Elaborate opAssign. Must go the memcpy road.
859+ //We avoid calling emplace here, because our goal is to initialize to
860+ //the static state of T.init,
861+ //So we want to avoid any un-necassarilly CC'ing of T.init
862+ auto p = typeid(T).initializer();
863+ if (p.ptr)
864+ {
865+ for ( ; !range.empty ; range.popFront() )
866+ {
867+ static if (__traits(isStaticArray, T))
868+ {
869+ // static array initializer only contains initialization
870+ // for one element of the static array.
871+ auto elemp = cast(void *) addressOf(range.front);
872+ auto endp = elemp + T.sizeof;
873+ while (elemp < endp)
874+ {
875+ memcpy(elemp, p.ptr, p.length);
876+ elemp += p.length;
877+ }
878+ }
879+ else
880+ {
881+ memcpy(addressOf(range.front), p.ptr, T.sizeof);
882+ }
883+ }
884+ }
885+ else
886+ static if (isDynamicArray!Range)
887+ memset(range.ptr, 0, range.length * T.sizeof);
888+ else
889+ for ( ; !range.empty ; range.popFront() )
890+ memset(addressOf(range.front), 0, T.sizeof);
891+ }
892+ else
893+ fill(range, T.init);
894+}
895+
896+/// ditto
897+void initializeAll(Range)(Range range)
898+if (is(Range == char[]) || is(Range == wchar[]))
899+{
900+ alias T = ElementEncodingType!Range;
901+ range[] = T.init;
902+}
903+
904+///
905+@system unittest
906+{
907+ import core.stdc.stdlib : malloc, free;
908+
909+ struct S
910+ {
911+ int a = 10;
912+ }
913+
914+ auto s = (cast(S*) malloc(5 * S.sizeof))[0 .. 5];
915+ initializeAll(s);
916+ assert(s == [S(10), S(10), S(10), S(10), S(10)]);
917+
918+ scope(exit) free(s.ptr);
919+}
920+
921+@system unittest
922+{
923+ import std.algorithm.iteration : filter;
924+ import std.meta : AliasSeq;
925+ import std.traits : hasElaborateAssign;
926+
927+ //Test strings:
928+ //Must work on narrow strings.
929+ //Must reject const
930+ char[3] a = void;
931+ a[].initializeAll();
932+ assert(a[] == [char.init, char.init, char.init]);
933+ string s;
934+ assert(!__traits(compiles, s.initializeAll()));
935+ assert(!__traits(compiles, s.initializeAll()));
936+ assert(s.empty);
937+
938+ //Note: Cannot call uninitializedFill on narrow strings
939+
940+ enum e {e1, e2}
941+ e[3] b1 = void;
942+ b1[].initializeAll();
943+ assert(b1[] == [e.e1, e.e1, e.e1]);
944+ e[3] b2 = void;
945+ b2[].uninitializedFill(e.e2);
946+ assert(b2[] == [e.e2, e.e2, e.e2]);
947+
948+ static struct S1
949+ {
950+ int i;
951+ }
952+ static struct S2
953+ {
954+ int i = 1;
955+ }
956+ static struct S3
957+ {
958+ int i;
959+ this(this){}
960+ }
961+ static struct S4
962+ {
963+ int i = 1;
964+ this(this){}
965+ }
966+ static assert(!hasElaborateAssign!S1);
967+ static assert(!hasElaborateAssign!S2);
968+ static assert( hasElaborateAssign!S3);
969+ static assert( hasElaborateAssign!S4);
970+ assert(!typeid(S1).initializer().ptr);
971+ assert( typeid(S2).initializer().ptr);
972+ assert(!typeid(S3).initializer().ptr);
973+ assert( typeid(S4).initializer().ptr);
974+
975+ foreach (S; AliasSeq!(S1, S2, S3, S4))
976+ {
977+ //initializeAll
978+ {
979+ //Array
980+ S[3] ss1 = void;
981+ ss1[].initializeAll();
982+ assert(ss1[] == [S.init, S.init, S.init]);
983+
984+ //Not array
985+ S[3] ss2 = void;
986+ auto sf = ss2[].filter!"true"();
987+
988+ sf.initializeAll();
989+ assert(ss2[] == [S.init, S.init, S.init]);
990+ }
991+ //uninitializedFill
992+ {
993+ //Array
994+ S[3] ss1 = void;
995+ ss1[].uninitializedFill(S(2));
996+ assert(ss1[] == [S(2), S(2), S(2)]);
997+
998+ //Not array
999+ S[3] ss2 = void;
1000+ auto sf = ss2[].filter!"true"();
1001+ sf.uninitializedFill(S(2));
1002+ assert(ss2[] == [S(2), S(2), S(2)]);
1003+ }
1004+ }
1005+}
1006+
1007+// test that initializeAll works for arrays of static arrays of structs with
1008+// elaborate assigns.
1009+@system unittest
1010+{
1011+ struct Int {
1012+ ~this() {}
1013+ int x = 3;
1014+ }
1015+ Int[2] xs = [Int(1), Int(2)];
1016+ struct R {
1017+ bool done;
1018+ bool empty() { return done; }
1019+ ref Int[2] front() { return xs; }
1020+ void popFront() { done = true; }
1021+ }
1022+ initializeAll(R());
1023+ assert(xs[0].x == 3);
1024+ assert(xs[1].x == 3);
1025+}
1026+
1027+// move
1028+/**
1029+Moves `source` into `target`, via a destructive copy when necessary.
1030+
1031+If `T` is a struct with a destructor or postblit defined, source is reset
1032+to its `.init` value after it is moved into target, otherwise it is
1033+left unchanged.
1034+
1035+Preconditions:
1036+If source has internal pointers that point to itself, it cannot be moved, and
1037+will trigger an assertion failure.
1038+
1039+Params:
1040+ source = Data to copy.
1041+ target = Where to copy into. The destructor, if any, is invoked before the
1042+ copy is performed.
1043+*/
1044+void move(T)(ref T source, ref T target)
1045+{
1046+ // test @safe destructible
1047+ static if (__traits(compiles, (T t) @safe {}))
1048+ trustedMoveImpl(source, target);
1049+ else
1050+ moveImpl(source, target);
1051+}
1052+
1053+/// For non-struct types, `move` just performs `target = source`:
1054+@safe unittest
1055+{
1056+ Object obj1 = new Object;
1057+ Object obj2 = obj1;
1058+ Object obj3;
1059+
1060+ move(obj2, obj3);
1061+ assert(obj3 is obj1);
1062+ // obj2 unchanged
1063+ assert(obj2 is obj1);
1064+}
1065+
1066+///
1067+pure nothrow @safe @nogc unittest
1068+{
1069+ // Structs without destructors are simply copied
1070+ struct S1
1071+ {
1072+ int a = 1;
1073+ int b = 2;
1074+ }
1075+ S1 s11 = { 10, 11 };
1076+ S1 s12;
1077+
1078+ move(s11, s12);
1079+
1080+ assert(s12 == S1(10, 11));
1081+ assert(s11 == s12);
1082+
1083+ // But structs with destructors or postblits are reset to their .init value
1084+ // after copying to the target.
1085+ struct S2
1086+ {
1087+ int a = 1;
1088+ int b = 2;
1089+
1090+ ~this() pure nothrow @safe @nogc { }
1091+ }
1092+ S2 s21 = { 3, 4 };
1093+ S2 s22;
1094+
1095+ move(s21, s22);
1096+
1097+ assert(s21 == S2(1, 2));
1098+ assert(s22 == S2(3, 4));
1099+}
1100+
1101+@safe unittest
1102+{
1103+ import std.exception : assertCTFEable;
1104+ import std.traits;
1105+
1106+ assertCTFEable!((){
1107+ Object obj1 = new Object;
1108+ Object obj2 = obj1;
1109+ Object obj3;
1110+ move(obj2, obj3);
1111+ assert(obj3 is obj1);
1112+
1113+ static struct S1 { int a = 1, b = 2; }
1114+ S1 s11 = { 10, 11 };
1115+ S1 s12;
1116+ move(s11, s12);
1117+ assert(s11.a == 10 && s11.b == 11 && s12.a == 10 && s12.b == 11);
1118+
1119+ static struct S2 { int a = 1; int * b; }
1120+ S2 s21 = { 10, null };
1121+ s21.b = new int;
1122+ S2 s22;
1123+ move(s21, s22);
1124+ assert(s21 == s22);
1125+ });
1126+ // Issue 5661 test(1)
1127+ static struct S3
1128+ {
1129+ static struct X { int n = 0; ~this(){n = 0;} }
1130+ X x;
1131+ }
1132+ static assert(hasElaborateDestructor!S3);
1133+ S3 s31, s32;
1134+ s31.x.n = 1;
1135+ move(s31, s32);
1136+ assert(s31.x.n == 0);
1137+ assert(s32.x.n == 1);
1138+
1139+ // Issue 5661 test(2)
1140+ static struct S4
1141+ {
1142+ static struct X { int n = 0; this(this){n = 0;} }
1143+ X x;
1144+ }
1145+ static assert(hasElaborateCopyConstructor!S4);
1146+ S4 s41, s42;
1147+ s41.x.n = 1;
1148+ move(s41, s42);
1149+ assert(s41.x.n == 0);
1150+ assert(s42.x.n == 1);
1151+
1152+ // Issue 13990 test
1153+ class S5;
1154+
1155+ S5 s51;
1156+ S5 s52 = s51;
1157+ S5 s53;
1158+ move(s52, s53);
1159+ assert(s53 is s51);
1160+}
1161+
1162+/// Ditto
1163+T move(T)(ref T source)
1164+{
1165+ // test @safe destructible
1166+ static if (__traits(compiles, (T t) @safe {}))
1167+ return trustedMoveImpl(source);
1168+ else
1169+ return moveImpl(source);
1170+}
1171+
1172+/// Non-copyable structs can still be moved:
1173+pure nothrow @safe @nogc unittest
1174+{
1175+ struct S
1176+ {
1177+ int a = 1;
1178+ @disable this(this);
1179+ ~this() pure nothrow @safe @nogc {}
1180+ }
1181+ S s1;
1182+ s1.a = 2;
1183+ S s2 = move(s1);
1184+ assert(s1.a == 1);
1185+ assert(s2.a == 2);
1186+}
1187+
1188+private void trustedMoveImpl(T)(ref T source, ref T target) @trusted
1189+{
1190+ moveImpl(source, target);
1191+}
1192+
1193+private void moveImpl(T)(ref T source, ref T target)
1194+{
1195+ import std.traits : hasElaborateDestructor;
1196+
1197+ static if (is(T == struct))
1198+ {
1199+ if (&source == &target) return;
1200+ // Destroy target before overwriting it
1201+ static if (hasElaborateDestructor!T) target.__xdtor();
1202+ }
1203+ // move and emplace source into target
1204+ moveEmplace(source, target);
1205+}
1206+
1207+private T trustedMoveImpl(T)(ref T source) @trusted
1208+{
1209+ return moveImpl(source);
1210+}
1211+
1212+private T moveImpl(T)(ref T source)
1213+{
1214+ T result = void;
1215+ moveEmplace(source, result);
1216+ return result;
1217+}
1218+
1219+@safe unittest
1220+{
1221+ import std.exception : assertCTFEable;
1222+ import std.traits;
1223+
1224+ assertCTFEable!((){
1225+ Object obj1 = new Object;
1226+ Object obj2 = obj1;
1227+ Object obj3 = move(obj2);
1228+ assert(obj3 is obj1);
1229+
1230+ static struct S1 { int a = 1, b = 2; }
1231+ S1 s11 = { 10, 11 };
1232+ S1 s12 = move(s11);
1233+ assert(s11.a == 10 && s11.b == 11 && s12.a == 10 && s12.b == 11);
1234+
1235+ static struct S2 { int a = 1; int * b; }
1236+ S2 s21 = { 10, null };
1237+ s21.b = new int;
1238+ S2 s22 = move(s21);
1239+ assert(s21 == s22);
1240+ });
1241+
1242+ // Issue 5661 test(1)
1243+ static struct S3
1244+ {
1245+ static struct X { int n = 0; ~this(){n = 0;} }
1246+ X x;
1247+ }
1248+ static assert(hasElaborateDestructor!S3);
1249+ S3 s31;
1250+ s31.x.n = 1;
1251+ S3 s32 = move(s31);
1252+ assert(s31.x.n == 0);
1253+ assert(s32.x.n == 1);
1254+
1255+ // Issue 5661 test(2)
1256+ static struct S4
1257+ {
1258+ static struct X { int n = 0; this(this){n = 0;} }
1259+ X x;
1260+ }
1261+ static assert(hasElaborateCopyConstructor!S4);
1262+ S4 s41;
1263+ s41.x.n = 1;
1264+ S4 s42 = move(s41);
1265+ assert(s41.x.n == 0);
1266+ assert(s42.x.n == 1);
1267+
1268+ // Issue 13990 test
1269+ class S5;
1270+
1271+ S5 s51;
1272+ S5 s52 = s51;
1273+ S5 s53;
1274+ s53 = move(s52);
1275+ assert(s53 is s51);
1276+}
1277+
1278+@system unittest
1279+{
1280+ static struct S { int n = 0; ~this() @system { n = 0; } }
1281+ S a, b;
1282+ static assert(!__traits(compiles, () @safe { move(a, b); }));
1283+ static assert(!__traits(compiles, () @safe { move(a); }));
1284+ a.n = 1;
1285+ () @trusted { move(a, b); }();
1286+ assert(a.n == 0);
1287+ a.n = 1;
1288+ () @trusted { move(a); }();
1289+ assert(a.n == 0);
1290+}
1291+
1292+@safe unittest//Issue 6217
1293+{
1294+ import std.algorithm.iteration : map;
1295+ auto x = map!"a"([1,2,3]);
1296+ x = move(x);
1297+}
1298+
1299+@safe unittest// Issue 8055
1300+{
1301+ static struct S
1302+ {
1303+ int x;
1304+ ~this()
1305+ {
1306+ assert(x == 0);
1307+ }
1308+ }
1309+ S foo(S s)
1310+ {
1311+ return move(s);
1312+ }
1313+ S a;
1314+ a.x = 0;
1315+ auto b = foo(a);
1316+ assert(b.x == 0);
1317+}
1318+
1319+@system unittest// Issue 8057
1320+{
1321+ int n = 10;
1322+ struct S
1323+ {
1324+ int x;
1325+ ~this()
1326+ {
1327+ // Access to enclosing scope
1328+ assert(n == 10);
1329+ }
1330+ }
1331+ S foo(S s)
1332+ {
1333+ // Move nested struct
1334+ return move(s);
1335+ }
1336+ S a;
1337+ a.x = 1;
1338+ auto b = foo(a);
1339+ assert(b.x == 1);
1340+
1341+ // Regression 8171
1342+ static struct Array(T)
1343+ {
1344+ // nested struct has no member
1345+ struct Payload
1346+ {
1347+ ~this() {}
1348+ }
1349+ }
1350+ Array!int.Payload x = void;
1351+ move(x);
1352+ move(x, x);
1353+}
1354+
1355+/**
1356+ * Similar to $(LREF move) but assumes `target` is uninitialized. This
1357+ * is more efficient because `source` can be blitted over `target`
1358+ * without destroying or initializing it first.
1359+ *
1360+ * Params:
1361+ * source = value to be moved into target
1362+ * target = uninitialized value to be filled by source
1363+ */
1364+void moveEmplace(T)(ref T source, ref T target) @system
1365+{
1366+ import core.stdc.string : memcpy, memset;
1367+ import std.traits : hasAliasing, hasElaborateAssign,
1368+ hasElaborateCopyConstructor, hasElaborateDestructor,
1369+ isAssignable;
1370+
1371+ static if (!is(T == class) && hasAliasing!T) if (!__ctfe)
1372+ {
1373+ import std.exception : doesPointTo;
1374+ assert(!doesPointTo(source, source), "Cannot move object with internal pointer.");
1375+ }
1376+
1377+ static if (is(T == struct))
1378+ {
1379+ assert(&source !is &target, "source and target must not be identical");
1380+
1381+ static if (hasElaborateAssign!T || !isAssignable!T)
1382+ memcpy(&target, &source, T.sizeof);
1383+ else
1384+ target = source;
1385+
1386+ // If the source defines a destructor or a postblit hook, we must obliterate the
1387+ // object in order to avoid double freeing and undue aliasing
1388+ static if (hasElaborateDestructor!T || hasElaborateCopyConstructor!T)
1389+ {
1390+ // If T is nested struct, keep original context pointer
1391+ static if (__traits(isNested, T))
1392+ enum sz = T.sizeof - (void*).sizeof;
1393+ else
1394+ enum sz = T.sizeof;
1395+
1396+ auto init = typeid(T).initializer();
1397+ if (init.ptr is null) // null ptr means initialize to 0s
1398+ memset(&source, 0, sz);
1399+ else
1400+ memcpy(&source, init.ptr, sz);
1401+ }
1402+ }
1403+ else
1404+ {
1405+ // Primitive data (including pointers and arrays) or class -
1406+ // assignment works great
1407+ target = source;
1408+ }
1409+}
1410+
1411+///
1412+pure nothrow @nogc @system unittest
1413+{
1414+ static struct Foo
1415+ {
1416+ pure nothrow @nogc:
1417+ this(int* ptr) { _ptr = ptr; }
1418+ ~this() { if (_ptr) ++*_ptr; }
1419+ int* _ptr;
1420+ }
1421+
1422+ int val;
1423+ Foo foo1 = void; // uninitialized
1424+ auto foo2 = Foo(&val); // initialized
1425+ assert(foo2._ptr is &val);
1426+
1427+ // Using `move(foo2, foo1)` would have an undefined effect because it would destroy
1428+ // the uninitialized foo1.
1429+ // moveEmplace directly overwrites foo1 without destroying or initializing it first.
1430+ moveEmplace(foo2, foo1);
1431+ assert(foo1._ptr is &val);
1432+ assert(foo2._ptr is null);
1433+ assert(val == 0);
1434+}
1435+
1436+// moveAll
1437+/**
1438+Calls `move(a, b)` for each element `a` in `src` and the corresponding
1439+element `b` in `tgt`, in increasing order.
1440+
1441+Preconditions:
1442+`walkLength(src) <= walkLength(tgt)`.
1443+This precondition will be asserted. If you cannot ensure there is enough room in
1444+`tgt` to accommodate all of `src` use $(LREF moveSome) instead.
1445+
1446+Params:
1447+ src = An $(REF_ALTTEXT input range, isInputRange, std,range,primitives) with
1448+ movable elements.
1449+ tgt = An $(REF_ALTTEXT input range, isInputRange, std,range,primitives) with
1450+ elements that elements from $(D src) can be moved into.
1451+
1452+Returns: The leftover portion of $(D tgt) after all elements from $(D src) have
1453+been moved.
1454+ */
1455+InputRange2 moveAll(InputRange1, InputRange2)(InputRange1 src, InputRange2 tgt)
1456+if (isInputRange!InputRange1 && isInputRange!InputRange2
1457+ && is(typeof(move(src.front, tgt.front))))
1458+{
1459+ return moveAllImpl!move(src, tgt);
1460+}
1461+
1462+///
1463+pure nothrow @safe @nogc unittest
1464+{
1465+ int[3] a = [ 1, 2, 3 ];
1466+ int[5] b;
1467+ assert(moveAll(a[], b[]) is b[3 .. $]);
1468+ assert(a[] == b[0 .. 3]);
1469+ int[3] cmp = [ 1, 2, 3 ];
1470+ assert(a[] == cmp[]);
1471+}
1472+
1473+/**
1474+ * Similar to $(LREF moveAll) but assumes all elements in `tgt` are
1475+ * uninitialized. Uses $(LREF moveEmplace) to move elements from
1476+ * `src` over elements from `tgt`.
1477+ */
1478+InputRange2 moveEmplaceAll(InputRange1, InputRange2)(InputRange1 src, InputRange2 tgt) @system
1479+if (isInputRange!InputRange1 && isInputRange!InputRange2
1480+ && is(typeof(moveEmplace(src.front, tgt.front))))
1481+{
1482+ return moveAllImpl!moveEmplace(src, tgt);
1483+}
1484+
1485+///
1486+pure nothrow @nogc @system unittest
1487+{
1488+ static struct Foo
1489+ {
1490+ ~this() pure nothrow @nogc { if (_ptr) ++*_ptr; }
1491+ int* _ptr;
1492+ }
1493+ int[3] refs = [0, 1, 2];
1494+ Foo[3] src = [Foo(&refs[0]), Foo(&refs[1]), Foo(&refs[2])];
1495+ Foo[5] dst = void;
1496+
1497+ auto tail = moveEmplaceAll(src[], dst[]); // move 3 value from src over dst
1498+ assert(tail.length == 2); // returns remaining uninitialized values
1499+ initializeAll(tail);
1500+
1501+ import std.algorithm.searching : all;
1502+ assert(src[].all!(e => e._ptr is null));
1503+ assert(dst[0 .. 3].all!(e => e._ptr !is null));
1504+}
1505+
1506+@system unittest
1507+{
1508+ struct InputRange
1509+ {
1510+ ref int front() { return data[0]; }
1511+ void popFront() { data.popFront; }
1512+ bool empty() { return data.empty; }
1513+ int[] data;
1514+ }
1515+ auto a = InputRange([ 1, 2, 3 ]);
1516+ auto b = InputRange(new int[5]);
1517+ moveAll(a, b);
1518+ assert(a.data == b.data[0 .. 3]);
1519+ assert(a.data == [ 1, 2, 3 ]);
1520+}
1521+
1522+private InputRange2 moveAllImpl(alias moveOp, InputRange1, InputRange2)(
1523+ ref InputRange1 src, ref InputRange2 tgt)
1524+{
1525+ import std.exception : enforce;
1526+
1527+ static if (isRandomAccessRange!InputRange1 && hasLength!InputRange1 && hasLength!InputRange2
1528+ && hasSlicing!InputRange2 && isRandomAccessRange!InputRange2)
1529+ {
1530+ auto toMove = src.length;
1531+ assert(toMove <= tgt.length);
1532+ foreach (idx; 0 .. toMove)
1533+ moveOp(src[idx], tgt[idx]);
1534+ return tgt[toMove .. tgt.length];
1535+ }
1536+ else
1537+ {
1538+ for (; !src.empty; src.popFront(), tgt.popFront())
1539+ {
1540+ assert(!tgt.empty);
1541+ moveOp(src.front, tgt.front);
1542+ }
1543+ return tgt;
1544+ }
1545+}
1546+
1547+// moveSome
1548+/**
1549+Calls `move(a, b)` for each element `a` in `src` and the corresponding
1550+element `b` in `tgt`, in increasing order, stopping when either range has been
1551+exhausted.
1552+
1553+Params:
1554+ src = An $(REF_ALTTEXT input range, isInputRange, std,range,primitives) with
1555+ movable elements.
1556+ tgt = An $(REF_ALTTEXT input range, isInputRange, std,range,primitives) with
1557+ elements that elements from $(D src) can be moved into.
1558+
1559+Returns: The leftover portions of the two ranges after one or the other of the
1560+ranges have been exhausted.
1561+ */
1562+Tuple!(InputRange1, InputRange2) moveSome(InputRange1, InputRange2)(InputRange1 src, InputRange2 tgt)
1563+if (isInputRange!InputRange1 && isInputRange!InputRange2
1564+ && is(typeof(move(src.front, tgt.front))))
1565+{
1566+ return moveSomeImpl!move(src, tgt);
1567+}
1568+
1569+///
1570+pure nothrow @safe @nogc unittest
1571+{
1572+ int[5] a = [ 1, 2, 3, 4, 5 ];
1573+ int[3] b;
1574+ assert(moveSome(a[], b[])[0] is a[3 .. $]);
1575+ assert(a[0 .. 3] == b);
1576+ assert(a == [ 1, 2, 3, 4, 5 ]);
1577+}
1578+
1579+/**
1580+ * Same as $(LREF moveSome) but assumes all elements in `tgt` are
1581+ * uninitialized. Uses $(LREF moveEmplace) to move elements from
1582+ * `src` over elements from `tgt`.
1583+ */
1584+Tuple!(InputRange1, InputRange2) moveEmplaceSome(InputRange1, InputRange2)(InputRange1 src, InputRange2 tgt) @system
1585+if (isInputRange!InputRange1 && isInputRange!InputRange2
1586+ && is(typeof(move(src.front, tgt.front))))
1587+{
1588+ return moveSomeImpl!moveEmplace(src, tgt);
1589+}
1590+
1591+///
1592+pure nothrow @nogc @system unittest
1593+{
1594+ static struct Foo
1595+ {
1596+ ~this() pure nothrow @nogc { if (_ptr) ++*_ptr; }
1597+ int* _ptr;
1598+ }
1599+ int[4] refs = [0, 1, 2, 3];
1600+ Foo[4] src = [Foo(&refs[0]), Foo(&refs[1]), Foo(&refs[2]), Foo(&refs[3])];
1601+ Foo[3] dst = void;
1602+
1603+ auto res = moveEmplaceSome(src[], dst[]);
1604+ assert(res.length == 2);
1605+
1606+ import std.algorithm.searching : all;
1607+ assert(src[0 .. 3].all!(e => e._ptr is null));
1608+ assert(src[3]._ptr !is null);
1609+ assert(dst[].all!(e => e._ptr !is null));
1610+}
1611+
1612+private Tuple!(InputRange1, InputRange2) moveSomeImpl(alias moveOp, InputRange1, InputRange2)(
1613+ ref InputRange1 src, ref InputRange2 tgt)
1614+{
1615+ for (; !src.empty && !tgt.empty; src.popFront(), tgt.popFront())
1616+ moveOp(src.front, tgt.front);
1617+ return tuple(src, tgt);
1618+ }
1619+
1620+
1621+// SwapStrategy
1622+/**
1623+Defines the swapping strategy for algorithms that need to swap
1624+elements in a range (such as partition and sort). The strategy
1625+concerns the swapping of elements that are not the core concern of the
1626+algorithm. For example, consider an algorithm that sorts $(D [ "abc",
1627+"b", "aBc" ]) according to $(D toUpper(a) < toUpper(b)). That
1628+algorithm might choose to swap the two equivalent strings $(D "abc")
1629+and $(D "aBc"). That does not affect the sorting since both $(D [
1630+"abc", "aBc", "b" ]) and $(D [ "aBc", "abc", "b" ]) are valid
1631+outcomes.
1632+
1633+Some situations require that the algorithm must NOT ever change the
1634+relative ordering of equivalent elements (in the example above, only
1635+$(D [ "abc", "aBc", "b" ]) would be the correct result). Such
1636+algorithms are called $(B stable). If the ordering algorithm may swap
1637+equivalent elements discretionarily, the ordering is called $(B
1638+unstable).
1639+
1640+Yet another class of algorithms may choose an intermediate tradeoff by
1641+being stable only on a well-defined subrange of the range. There is no
1642+established terminology for such behavior; this library calls it $(B
1643+semistable).
1644+
1645+Generally, the $(D stable) ordering strategy may be more costly in
1646+time and/or space than the other two because it imposes additional
1647+constraints. Similarly, $(D semistable) may be costlier than $(D
1648+unstable). As (semi-)stability is not needed very often, the ordering
1649+algorithms in this module parameterized by $(D SwapStrategy) all
1650+choose $(D SwapStrategy.unstable) as the default.
1651+*/
1652+
1653+enum SwapStrategy
1654+{
1655+ /**
1656+ Allows freely swapping of elements as long as the output
1657+ satisfies the algorithm's requirements.
1658+ */
1659+ unstable,
1660+ /**
1661+ In algorithms partitioning ranges in two, preserve relative
1662+ ordering of elements only to the left of the partition point.
1663+ */
1664+ semistable,
1665+ /**
1666+ Preserve the relative ordering of elements to the largest
1667+ extent allowed by the algorithm's requirements.
1668+ */
1669+ stable,
1670+}
1671+
1672+///
1673+@safe unittest
1674+{
1675+ import std.stdio;
1676+ import std.algorithm.sorting : partition;
1677+ int[] a = [0, 1, 2, 3];
1678+ assert(remove!(SwapStrategy.stable)(a, 1) == [0, 2, 3]);
1679+ a = [0, 1, 2, 3];
1680+ assert(remove!(SwapStrategy.unstable)(a, 1) == [0, 3, 2]);
1681+}
1682+
1683+///
1684+@safe unittest
1685+{
1686+ import std.algorithm.sorting : partition;
1687+
1688+ // Put stuff greater than 3 on the left
1689+ auto arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
1690+ assert(partition!(a => a > 3, SwapStrategy.stable)(arr) == [1, 2, 3]);
1691+ assert(arr == [4, 5, 6, 7, 8, 9, 10, 1, 2, 3]);
1692+
1693+ arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
1694+ assert(partition!(a => a > 3, SwapStrategy.semistable)(arr) == [2, 3, 1]);
1695+ assert(arr == [4, 5, 6, 7, 8, 9, 10, 2, 3, 1]);
1696+
1697+ arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
1698+ assert(partition!(a => a > 3, SwapStrategy.unstable)(arr) == [3, 2, 1]);
1699+ assert(arr == [10, 9, 8, 4, 5, 6, 7, 3, 2, 1]);
1700+}
1701+
1702+/**
1703+Eliminates elements at given offsets from `range` and returns the shortened
1704+range.
1705+
1706+For example, here is how to _remove a single element from an array:
1707+
1708+----
1709+string[] a = [ "a", "b", "c", "d" ];
1710+a = a.remove(1); // remove element at offset 1
1711+assert(a == [ "a", "c", "d"]);
1712+----
1713+
1714+Note that `remove` does not change the length of the original _range directly;
1715+instead, it returns the shortened _range. If its return value is not assigned to
1716+the original _range, the original _range will retain its original length, though
1717+its contents will have changed:
1718+
1719+----
1720+int[] a = [ 3, 5, 7, 8 ];
1721+assert(remove(a, 1) == [ 3, 7, 8 ]);
1722+assert(a == [ 3, 7, 8, 8 ]);
1723+----
1724+
1725+The element at _offset `1` has been removed and the rest of the elements have
1726+shifted up to fill its place, however, the original array remains of the same
1727+length. This is because all functions in `std.algorithm` only change $(I
1728+content), not $(I topology). The value `8` is repeated because $(LREF move) was
1729+invoked to rearrange elements, and on integers `move` simply copies the source
1730+to the destination. To replace `a` with the effect of the removal, simply
1731+assign the slice returned by `remove` to it, as shown in the first example.
1732+
1733+Multiple indices can be passed into $(D remove). In that case,
1734+elements at the respective indices are all removed. The indices must
1735+be passed in increasing order, otherwise an exception occurs.
1736+
1737+----
1738+int[] a = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];
1739+assert(remove(a, 1, 3, 5) ==
1740+ [ 0, 2, 4, 6, 7, 8, 9, 10 ]);
1741+----
1742+
1743+(Note that all indices refer to slots in the $(I original) array, not
1744+in the array as it is being progressively shortened.) Finally, any
1745+combination of integral offsets and tuples composed of two integral
1746+offsets can be passed in.
1747+
1748+----
1749+int[] a = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];
1750+assert(remove(a, 1, tuple(3, 5), 9) == [ 0, 2, 5, 6, 7, 8, 10 ]);
1751+----
1752+
1753+In this case, the slots at positions 1, 3, 4, and 9 are removed from
1754+the array. The tuple passes in a range closed to the left and open to
1755+the right (consistent with built-in slices), e.g. $(D tuple(3, 5))
1756+means indices $(D 3) and $(D 4) but not $(D 5).
1757+
1758+If the need is to remove some elements in the range but the order of
1759+the remaining elements does not have to be preserved, you may want to
1760+pass $(D SwapStrategy.unstable) to $(D remove).
1761+
1762+----
1763+int[] a = [ 0, 1, 2, 3 ];
1764+assert(remove!(SwapStrategy.unstable)(a, 1) == [ 0, 3, 2 ]);
1765+----
1766+
1767+In the case above, the element at slot $(D 1) is removed, but replaced
1768+with the last element of the range. Taking advantage of the relaxation
1769+of the stability requirement, $(D remove) moved elements from the end
1770+of the array over the slots to be removed. This way there is less data
1771+movement to be done which improves the execution time of the function.
1772+
1773+The function $(D remove) works on bidirectional ranges that have assignable
1774+lvalue elements. The moving strategy is (listed from fastest to slowest):
1775+$(UL $(LI If $(D s == SwapStrategy.unstable && isRandomAccessRange!Range &&
1776+hasLength!Range && hasLvalueElements!Range), then elements are moved from the
1777+end of the range into the slots to be filled. In this case, the absolute
1778+minimum of moves is performed.) $(LI Otherwise, if $(D s ==
1779+SwapStrategy.unstable && isBidirectionalRange!Range && hasLength!Range
1780+&& hasLvalueElements!Range), then elements are still moved from the
1781+end of the range, but time is spent on advancing between slots by repeated
1782+calls to $(D range.popFront).) $(LI Otherwise, elements are moved
1783+incrementally towards the front of $(D range); a given element is never
1784+moved several times, but more elements are moved than in the previous
1785+cases.))
1786+
1787+Params:
1788+ s = a SwapStrategy to determine if the original order needs to be preserved
1789+ range = a $(REF_ALTTEXT bidirectional range, isBidirectionalRange, std,_range,primitives)
1790+ with a length member
1791+ offset = which element(s) to remove
1792+
1793+Returns:
1794+ a range containing all of the elements of range with offset removed
1795+ */
1796+Range remove
1797+(SwapStrategy s = SwapStrategy.stable, Range, Offset...)
1798+(Range range, Offset offset)
1799+if (s != SwapStrategy.stable
1800+ && isBidirectionalRange!Range
1801+ && hasLvalueElements!Range
1802+ && hasLength!Range
1803+ && Offset.length >= 1)
1804+{
1805+ Tuple!(size_t, "pos", size_t, "len")[offset.length] blackouts;
1806+ foreach (i, v; offset)
1807+ {
1808+ static if (is(typeof(v[0]) : size_t) && is(typeof(v[1]) : size_t))
1809+ {
1810+ blackouts[i].pos = v[0];
1811+ blackouts[i].len = v[1] - v[0];
1812+ }
1813+ else
1814+ {
1815+ static assert(is(typeof(v) : size_t), typeof(v).stringof);
1816+ blackouts[i].pos = v;
1817+ blackouts[i].len = 1;
1818+ }
1819+ static if (i > 0)
1820+ {
1821+ import std.exception : enforce;
1822+
1823+ enforce(blackouts[i - 1].pos + blackouts[i - 1].len
1824+ <= blackouts[i].pos,
1825+ "remove(): incorrect ordering of elements to remove");
1826+ }
1827+ }
1828+
1829+ size_t left = 0, right = offset.length - 1;
1830+ auto tgt = range.save;
1831+ size_t tgtPos = 0;
1832+
1833+ while (left <= right)
1834+ {
1835+ // Look for a blackout on the right
1836+ if (blackouts[right].pos + blackouts[right].len >= range.length)
1837+ {
1838+ range.popBackExactly(blackouts[right].len);
1839+
1840+ // Since right is unsigned, we must check for this case, otherwise
1841+ // we might turn it into size_t.max and the loop condition will not
1842+ // fail when it should.
1843+ if (right > 0)
1844+ {
1845+ --right;
1846+ continue;
1847+ }
1848+ else
1849+ break;
1850+ }
1851+ // Advance to next blackout on the left
1852+ assert(blackouts[left].pos >= tgtPos);
1853+ tgt.popFrontExactly(blackouts[left].pos - tgtPos);
1854+ tgtPos = blackouts[left].pos;
1855+
1856+ // Number of elements to the right of blackouts[right]
1857+ immutable tailLen = range.length - (blackouts[right].pos + blackouts[right].len);
1858+ size_t toMove = void;
1859+ if (tailLen < blackouts[left].len)
1860+ {
1861+ toMove = tailLen;
1862+ blackouts[left].pos += toMove;
1863+ blackouts[left].len -= toMove;
1864+ }
1865+ else
1866+ {
1867+ toMove = blackouts[left].len;
1868+ ++left;
1869+ }
1870+ tgtPos += toMove;
1871+ foreach (i; 0 .. toMove)
1872+ {
1873+ move(range.back, tgt.front);
1874+ range.popBack();
1875+ tgt.popFront();
1876+ }
1877+ }
1878+
1879+ return range;
1880+}
1881+
1882+/// Ditto
1883+Range remove
1884+(SwapStrategy s = SwapStrategy.stable, Range, Offset...)
1885+(Range range, Offset offset)
1886+if (s == SwapStrategy.stable
1887+ && isBidirectionalRange!Range
1888+ && hasLvalueElements!Range
1889+ && Offset.length >= 1)
1890+{
1891+ auto result = range;
1892+ auto src = range, tgt = range;
1893+ size_t pos;
1894+ foreach (pass, i; offset)
1895+ {
1896+ static if (is(typeof(i[0])) && is(typeof(i[1])))
1897+ {
1898+ auto from = i[0], delta = i[1] - i[0];
1899+ }
1900+ else
1901+ {
1902+ auto from = i;
1903+ enum delta = 1;
1904+ }
1905+
1906+ static if (pass > 0)
1907+ {
1908+ import std.exception : enforce;
1909+ enforce(pos <= from,
1910+ "remove(): incorrect ordering of elements to remove");
1911+
1912+ for (; pos < from; ++pos, src.popFront(), tgt.popFront())
1913+ {
1914+ move(src.front, tgt.front);
1915+ }
1916+ }
1917+ else
1918+ {
1919+ src.popFrontExactly(from);
1920+ tgt.popFrontExactly(from);
1921+ pos = from;
1922+ }
1923+ // now skip source to the "to" position
1924+ src.popFrontExactly(delta);
1925+ result.popBackExactly(delta);
1926+ pos += delta;
1927+ }
1928+ // leftover move
1929+ moveAll(src, tgt);
1930+ return result;
1931+}
1932+
1933+///
1934+@safe pure unittest
1935+{
1936+ import std.typecons : tuple;
1937+
1938+ auto a = [ 0, 1, 2, 3, 4, 5 ];
1939+ assert(remove!(SwapStrategy.stable)(a, 1) == [ 0, 2, 3, 4, 5 ]);
1940+ a = [ 0, 1, 2, 3, 4, 5 ];
1941+ assert(remove!(SwapStrategy.stable)(a, 1, 3) == [ 0, 2, 4, 5] );
1942+ a = [ 0, 1, 2, 3, 4, 5 ];
1943+ assert(remove!(SwapStrategy.stable)(a, 1, tuple(3, 6)) == [ 0, 2 ]);
1944+
1945+ a = [ 0, 1, 2, 3, 4, 5 ];
1946+ assert(remove!(SwapStrategy.unstable)(a, 1) == [0, 5, 2, 3, 4]);
1947+ a = [ 0, 1, 2, 3, 4, 5 ];
1948+ assert(remove!(SwapStrategy.unstable)(a, tuple(1, 4)) == [0, 5, 4]);
1949+}
1950+
1951+@safe unittest
1952+{
1953+ import std.exception : assertThrown;
1954+ import std.range;
1955+
1956+ // http://d.puremagic.com/issues/show_bug.cgi?id=10173
1957+ int[] test = iota(0, 10).array();
1958+ assertThrown(remove!(SwapStrategy.stable)(test, tuple(2, 4), tuple(1, 3)));
1959+ assertThrown(remove!(SwapStrategy.unstable)(test, tuple(2, 4), tuple(1, 3)));
1960+ assertThrown(remove!(SwapStrategy.stable)(test, 2, 4, 1, 3));
1961+ assertThrown(remove!(SwapStrategy.unstable)(test, 2, 4, 1, 3));
1962+}
1963+
1964+@safe unittest
1965+{
1966+ import std.range;
1967+ int[] a = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];
1968+ a = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];
1969+ assert(remove!(SwapStrategy.stable)(a, 1) ==
1970+ [ 0, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]);
1971+
1972+ a = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];
1973+ assert(remove!(SwapStrategy.unstable)(a, 0, 10) ==
1974+ [ 9, 1, 2, 3, 4, 5, 6, 7, 8 ]);
1975+
1976+ a = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];
1977+ assert(remove!(SwapStrategy.unstable)(a, 0, tuple(9, 11)) ==
1978+ [ 8, 1, 2, 3, 4, 5, 6, 7 ]);
1979+ // http://d.puremagic.com/issues/show_bug.cgi?id=5224
1980+ a = [ 1, 2, 3, 4 ];
1981+ assert(remove!(SwapStrategy.unstable)(a, 2) ==
1982+ [ 1, 2, 4 ]);
1983+
1984+ a = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];
1985+ assert(remove!(SwapStrategy.stable)(a, 1, 5) ==
1986+ [ 0, 2, 3, 4, 6, 7, 8, 9, 10 ]);
1987+
1988+ a = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];
1989+ assert(remove!(SwapStrategy.stable)(a, 1, 3, 5)
1990+ == [ 0, 2, 4, 6, 7, 8, 9, 10]);
1991+ a = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];
1992+ assert(remove!(SwapStrategy.stable)(a, 1, tuple(3, 5))
1993+ == [ 0, 2, 5, 6, 7, 8, 9, 10]);
1994+
1995+ a = iota(0, 10).array();
1996+ assert(remove!(SwapStrategy.unstable)(a, tuple(1, 4), tuple(6, 7))
1997+ == [0, 9, 8, 7, 4, 5]);
1998+}
1999+
2000+@safe unittest
2001+{
2002+ // Issue 11576
2003+ auto arr = [1,2,3];
2004+ arr = arr.remove!(SwapStrategy.unstable)(2);
2005+ assert(arr == [1,2]);
2006+
2007+}
2008+
2009+@safe unittest
2010+{
2011+ import std.range;
2012+ // Bug# 12889
2013+ int[1][] arr = [[0], [1], [2], [3], [4], [5], [6]];
2014+ auto orig = arr.dup;
2015+ foreach (i; iota(arr.length))
2016+ {
2017+ assert(orig == arr.remove!(SwapStrategy.unstable)(tuple(i,i)));
2018+ assert(orig == arr.remove!(SwapStrategy.stable)(tuple(i,i)));
2019+ }
2020+}
2021+
2022+/**
2023+Reduces the length of the
2024+$(REF_ALTTEXT bidirectional range, isBidirectionalRange, std,_range,primitives) $(D range) by removing
2025+elements that satisfy $(D pred). If $(D s = SwapStrategy.unstable),
2026+elements are moved from the right end of the range over the elements
2027+to eliminate. If $(D s = SwapStrategy.stable) (the default),
2028+elements are moved progressively to front such that their relative
2029+order is preserved. Returns the filtered range.
2030+
2031+Params:
2032+ range = a bidirectional ranges with lvalue elements
2033+
2034+Returns:
2035+ the range with all of the elements where $(D pred) is $(D true)
2036+ removed
2037+*/
2038+Range remove(alias pred, SwapStrategy s = SwapStrategy.stable, Range)
2039+(Range range)
2040+if (isBidirectionalRange!Range
2041+ && hasLvalueElements!Range)
2042+{
2043+ import std.functional : unaryFun;
2044+ auto result = range;
2045+ static if (s != SwapStrategy.stable)
2046+ {
2047+ for (;!range.empty;)
2048+ {
2049+ if (!unaryFun!pred(range.front))
2050+ {
2051+ range.popFront();
2052+ continue;
2053+ }
2054+ move(range.back, range.front);
2055+ range.popBack();
2056+ result.popBack();
2057+ }
2058+ }
2059+ else
2060+ {
2061+ auto tgt = range;
2062+ for (; !range.empty; range.popFront())
2063+ {
2064+ if (unaryFun!(pred)(range.front))
2065+ {
2066+ // yank this guy
2067+ result.popBack();
2068+ continue;
2069+ }
2070+ // keep this guy
2071+ move(range.front, tgt.front);
2072+ tgt.popFront();
2073+ }
2074+ }
2075+ return result;
2076+}
2077+
2078+///
2079+@safe unittest
2080+{
2081+ static immutable base = [1, 2, 3, 2, 4, 2, 5, 2];
2082+
2083+ int[] arr = base[].dup;
2084+
2085+ // using a string-based predicate
2086+ assert(remove!("a == 2")(arr) == [ 1, 3, 4, 5 ]);
2087+
2088+ // The original array contents have been modified,
2089+ // so we need to reset it to its original state.
2090+ // The length is unmodified however.
2091+ arr[] = base[];
2092+
2093+ // using a lambda predicate
2094+ assert(remove!(a => a == 2)(arr) == [ 1, 3, 4, 5 ]);
2095+}
2096+
2097+@safe unittest
2098+{
2099+ int[] a = [ 1, 2, 3, 2, 3, 4, 5, 2, 5, 6 ];
2100+ assert(remove!("a == 2", SwapStrategy.unstable)(a) ==
2101+ [ 1, 6, 3, 5, 3, 4, 5 ]);
2102+ a = [ 1, 2, 3, 2, 3, 4, 5, 2, 5, 6 ];
2103+ assert(remove!("a == 2", SwapStrategy.stable)(a) ==
2104+ [ 1, 3, 3, 4, 5, 5, 6 ]);
2105+}
2106+
2107+@nogc @system unittest
2108+{
2109+ // @nogc test
2110+ int[10] arr = [0,1,2,3,4,5,6,7,8,9];
2111+ alias pred = e => e < 5;
2112+
2113+ auto r = arr[].remove!(SwapStrategy.unstable)(0);
2114+ r = r.remove!(SwapStrategy.stable)(0);
2115+ r = r.remove!(pred, SwapStrategy.unstable);
2116+ r = r.remove!(pred, SwapStrategy.stable);
2117+}
2118+
2119+@safe unittest
2120+{
2121+ import std.algorithm.comparison : min;
2122+ import std.algorithm.searching : all, any;
2123+ import std.algorithm.sorting : isStrictlyMonotonic;
2124+ import std.array : array;
2125+ import std.meta : AliasSeq;
2126+ import std.range : iota, only;
2127+ import std.typecons : Tuple;
2128+ alias S = Tuple!(int[2]);
2129+ S[] soffsets;
2130+ foreach (start; 0 .. 5)
2131+ foreach (end; min(start+1,5) .. 5)
2132+ soffsets ~= S([start,end]);
2133+ alias D = Tuple!(int[2],int[2]);
2134+ D[] doffsets;
2135+ foreach (start1; 0 .. 10)
2136+ foreach (end1; min(start1+1,10) .. 10)
2137+ foreach (start2; end1 .. 10)
2138+ foreach (end2; min(start2+1,10) .. 10)
2139+ doffsets ~= D([start1,end1],[start2,end2]);
2140+ alias T = Tuple!(int[2],int[2],int[2]);
2141+ T[] toffsets;
2142+ foreach (start1; 0 .. 15)
2143+ foreach (end1; min(start1+1,15) .. 15)
2144+ foreach (start2; end1 .. 15)
2145+ foreach (end2; min(start2+1,15) .. 15)
2146+ foreach (start3; end2 .. 15)
2147+ foreach (end3; min(start3+1,15) .. 15)
2148+ toffsets ~= T([start1,end1],[start2,end2],[start3,end3]);
2149+
2150+ static void verify(O...)(int[] r, int len, int removed, bool stable, O offsets)
2151+ {
2152+ assert(r.length == len - removed);
2153+ assert(!stable || r.isStrictlyMonotonic);
2154+ assert(r.all!(e => all!(o => e < o[0] || e >= o[1])(offsets.only)));
2155+ }
2156+
2157+ foreach (offsets; AliasSeq!(soffsets,doffsets,toffsets))
2158+ foreach (os; offsets)
2159+ {
2160+ int len = 5*os.length;
2161+ auto w = iota(0, len).array;
2162+ auto x = w.dup;
2163+ auto y = w.dup;
2164+ auto z = w.dup;
2165+ alias pred = e => any!(o => o[0] <= e && e < o[1])(only(os.expand));
2166+ w = w.remove!(SwapStrategy.unstable)(os.expand);
2167+ x = x.remove!(SwapStrategy.stable)(os.expand);
2168+ y = y.remove!(pred, SwapStrategy.unstable);
2169+ z = z.remove!(pred, SwapStrategy.stable);
2170+ int removed;
2171+ foreach (o; os)
2172+ removed += o[1] - o[0];
2173+ verify(w, len, removed, false, os[]);
2174+ verify(x, len, removed, true, os[]);
2175+ verify(y, len, removed, false, os[]);
2176+ verify(z, len, removed, true, os[]);
2177+ assert(w == y);
2178+ assert(x == z);
2179+ }
2180+}
2181+
2182+// reverse
2183+/**
2184+Reverses $(D r) in-place. Performs $(D r.length / 2) evaluations of $(D
2185+swap).
2186+Params:
2187+ r = a $(REF_ALTTEXT bidirectional range, isBidirectionalRange, std,range,primitives)
2188+ with swappable elements or a random access range with a length member
2189+
2190+See_Also:
2191+ $(HTTP sgi.com/tech/stl/_reverse.html, STL's _reverse), $(REF retro, std,range) for a lazy reversed range view
2192+*/
2193+void reverse(Range)(Range r)
2194+if (isBidirectionalRange!Range && !isRandomAccessRange!Range
2195+ && hasSwappableElements!Range)
2196+{
2197+ while (!r.empty)
2198+ {
2199+ swap(r.front, r.back);
2200+ r.popFront();
2201+ if (r.empty) break;
2202+ r.popBack();
2203+ }
2204+}
2205+
2206+///
2207+@safe unittest
2208+{
2209+ int[] arr = [ 1, 2, 3 ];
2210+ reverse(arr);
2211+ assert(arr == [ 3, 2, 1 ]);
2212+}
2213+
2214+///ditto
2215+void reverse(Range)(Range r)
2216+if (isRandomAccessRange!Range && hasLength!Range)
2217+{
2218+ //swapAt is in fact the only way to swap non lvalue ranges
2219+ immutable last = r.length-1;
2220+ immutable steps = r.length/2;
2221+ for (size_t i = 0; i < steps; i++)
2222+ {
2223+ r.swapAt(i, last-i);
2224+ }
2225+}
2226+
2227+@safe unittest
2228+{
2229+ int[] range = null;
2230+ reverse(range);
2231+ range = [ 1 ];
2232+ reverse(range);
2233+ assert(range == [1]);
2234+ range = [1, 2];
2235+ reverse(range);
2236+ assert(range == [2, 1]);
2237+ range = [1, 2, 3];
2238+ reverse(range);
2239+ assert(range == [3, 2, 1]);
2240+}
2241+
2242+/**
2243+Reverses $(D r) in-place, where $(D r) is a narrow string (having
2244+elements of type $(D char) or $(D wchar)). UTF sequences consisting of
2245+multiple code units are preserved properly.
2246+
2247+Params:
2248+ s = a narrow string
2249+
2250+Bugs:
2251+ When passing a sting with unicode modifiers on characters, such as $(D \u0301),
2252+ this function will not properly keep the position of the modifier. For example,
2253+ reversing $(D ba\u0301d) ("bád") will result in d\u0301ab ("d́ab") instead of
2254+ $(D da\u0301b) ("dáb").
2255+*/
2256+void reverse(Char)(Char[] s)
2257+if (isNarrowString!(Char[]) && !is(Char == const) && !is(Char == immutable))
2258+{
2259+ import std.string : representation;
2260+ import std.utf : stride;
2261+
2262+ auto r = representation(s);
2263+ for (size_t i = 0; i < s.length; )
2264+ {
2265+ immutable step = stride(s, i);
2266+ if (step > 1)
2267+ {
2268+ .reverse(r[i .. i + step]);
2269+ i += step;
2270+ }
2271+ else
2272+ {
2273+ ++i;
2274+ }
2275+ }
2276+ reverse(r);
2277+}
2278+
2279+///
2280+@safe unittest
2281+{
2282+ char[] arr = "hello\U00010143\u0100\U00010143".dup;
2283+ reverse(arr);
2284+ assert(arr == "\U00010143\u0100\U00010143olleh");
2285+}
2286+
2287+@safe unittest
2288+{
2289+ void test(string a, string b)
2290+ {
2291+ auto c = a.dup;
2292+ reverse(c);
2293+ assert(c == b, c ~ " != " ~ b);
2294+ }
2295+
2296+ test("a", "a");
2297+ test(" ", " ");
2298+ test("\u2029", "\u2029");
2299+ test("\u0100", "\u0100");
2300+ test("\u0430", "\u0430");
2301+ test("\U00010143", "\U00010143");
2302+ test("abcdefcdef", "fedcfedcba");
2303+ test("hello\U00010143\u0100\U00010143", "\U00010143\u0100\U00010143olleh");
2304+}
2305+
2306+/**
2307+ The strip group of functions allow stripping of either leading, trailing,
2308+ or both leading and trailing elements.
2309+
2310+ The $(D stripLeft) function will strip the $(D front) of the range,
2311+ the $(D stripRight) function will strip the $(D back) of the range,
2312+ while the $(D strip) function will strip both the $(D front) and $(D back)
2313+ of the range.
2314+
2315+ Note that the $(D strip) and $(D stripRight) functions require the range to
2316+ be a $(LREF BidirectionalRange) range.
2317+
2318+ All of these functions come in two varieties: one takes a target element,
2319+ where the range will be stripped as long as this element can be found.
2320+ The other takes a lambda predicate, where the range will be stripped as
2321+ long as the predicate returns true.
2322+
2323+ Params:
2324+ range = a $(REF_ALTTEXT bidirectional range, isBidirectionalRange, std,range,primitives)
2325+ or $(REF_ALTTEXT input range, isInputRange, std,range,primitives)
2326+ element = the elements to remove
2327+
2328+ Returns:
2329+ a Range with all of range except element at the start and end
2330+*/
2331+Range strip(Range, E)(Range range, E element)
2332+if (isBidirectionalRange!Range && is(typeof(range.front == element) : bool))
2333+{
2334+ return range.stripLeft(element).stripRight(element);
2335+}
2336+
2337+/// ditto
2338+Range strip(alias pred, Range)(Range range)
2339+if (isBidirectionalRange!Range && is(typeof(pred(range.back)) : bool))
2340+{
2341+ return range.stripLeft!pred().stripRight!pred();
2342+}
2343+
2344+/// ditto
2345+Range stripLeft(Range, E)(Range range, E element)
2346+if (isInputRange!Range && is(typeof(range.front == element) : bool))
2347+{
2348+ import std.algorithm.searching : find;
2349+ return find!((auto ref a) => a != element)(range);
2350+}
2351+
2352+/// ditto
2353+Range stripLeft(alias pred, Range)(Range range)
2354+if (isInputRange!Range && is(typeof(pred(range.front)) : bool))
2355+{
2356+ import std.algorithm.searching : find;
2357+ import std.functional : not;
2358+
2359+ return find!(not!pred)(range);
2360+}
2361+
2362+/// ditto
2363+Range stripRight(Range, E)(Range range, E element)
2364+if (isBidirectionalRange!Range && is(typeof(range.back == element) : bool))
2365+{
2366+ for (; !range.empty; range.popBack())
2367+ {
2368+ if (range.back != element)
2369+ break;
2370+ }
2371+ return range;
2372+}
2373+
2374+/// ditto
2375+Range stripRight(alias pred, Range)(Range range)
2376+if (isBidirectionalRange!Range && is(typeof(pred(range.back)) : bool))
2377+{
2378+ for (; !range.empty; range.popBack())
2379+ {
2380+ if (!pred(range.back))
2381+ break;
2382+ }
2383+ return range;
2384+}
2385+
2386+/// Strip leading and trailing elements equal to the target element.
2387+@safe pure unittest
2388+{
2389+ assert(" foobar ".strip(' ') == "foobar");
2390+ assert("00223.444500".strip('0') == "223.4445");
2391+ assert("ëëêéüŗōpéêëë".strip('ë') == "êéüŗōpéê");
2392+ assert([1, 1, 0, 1, 1].strip(1) == [0]);
2393+ assert([0.0, 0.01, 0.01, 0.0].strip(0).length == 2);
2394+}
2395+
2396+/// Strip leading and trailing elements while the predicate returns true.
2397+@safe pure unittest
2398+{
2399+ assert(" foobar ".strip!(a => a == ' ')() == "foobar");
2400+ assert("00223.444500".strip!(a => a == '0')() == "223.4445");
2401+ assert("ëëêéüŗōpéêëë".strip!(a => a == 'ë')() == "êéüŗōpéê");
2402+ assert([1, 1, 0, 1, 1].strip!(a => a == 1)() == [0]);
2403+ assert([0.0, 0.01, 0.5, 0.6, 0.01, 0.0].strip!(a => a < 0.4)().length == 2);
2404+}
2405+
2406+/// Strip leading elements equal to the target element.
2407+@safe pure unittest
2408+{
2409+ assert(" foobar ".stripLeft(' ') == "foobar ");
2410+ assert("00223.444500".stripLeft('0') == "223.444500");
2411+ assert("ůůűniçodêéé".stripLeft('ů') == "űniçodêéé");
2412+ assert([1, 1, 0, 1, 1].stripLeft(1) == [0, 1, 1]);
2413+ assert([0.0, 0.01, 0.01, 0.0].stripLeft(0).length == 3);
2414+}
2415+
2416+/// Strip leading elements while the predicate returns true.
2417+@safe pure unittest
2418+{
2419+ assert(" foobar ".stripLeft!(a => a == ' ')() == "foobar ");
2420+ assert("00223.444500".stripLeft!(a => a == '0')() == "223.444500");
2421+ assert("ůůűniçodêéé".stripLeft!(a => a == 'ů')() == "űniçodêéé");
2422+ assert([1, 1, 0, 1, 1].stripLeft!(a => a == 1)() == [0, 1, 1]);
2423+ assert([0.0, 0.01, 0.10, 0.5, 0.6].stripLeft!(a => a < 0.4)().length == 2);
2424+}
2425+
2426+/// Strip trailing elements equal to the target element.
2427+@safe pure unittest
2428+{
2429+ assert(" foobar ".stripRight(' ') == " foobar");
2430+ assert("00223.444500".stripRight('0') == "00223.4445");
2431+ assert("ùniçodêéé".stripRight('é') == "ùniçodê");
2432+ assert([1, 1, 0, 1, 1].stripRight(1) == [1, 1, 0]);
2433+ assert([0.0, 0.01, 0.01, 0.0].stripRight(0).length == 3);
2434+}
2435+
2436+/// Strip trailing elements while the predicate returns true.
2437+@safe pure unittest
2438+{
2439+ assert(" foobar ".stripRight!(a => a == ' ')() == " foobar");
2440+ assert("00223.444500".stripRight!(a => a == '0')() == "00223.4445");
2441+ assert("ùniçodêéé".stripRight!(a => a == 'é')() == "ùniçodê");
2442+ assert([1, 1, 0, 1, 1].stripRight!(a => a == 1)() == [1, 1, 0]);
2443+ assert([0.0, 0.01, 0.10, 0.5, 0.6].stripRight!(a => a > 0.4)().length == 3);
2444+}
2445+
2446+// swap
2447+/**
2448+Swaps $(D lhs) and $(D rhs). The instances $(D lhs) and $(D rhs) are moved in
2449+memory, without ever calling $(D opAssign), nor any other function. $(D T)
2450+need not be assignable at all to be swapped.
2451+
2452+If $(D lhs) and $(D rhs) reference the same instance, then nothing is done.
2453+
2454+$(D lhs) and $(D rhs) must be mutable. If $(D T) is a struct or union, then
2455+its fields must also all be (recursively) mutable.
2456+
2457+Params:
2458+ lhs = Data to be swapped with $(D rhs).
2459+ rhs = Data to be swapped with $(D lhs).
2460+*/
2461+void swap(T)(ref T lhs, ref T rhs) @trusted pure nothrow @nogc
2462+if (isBlitAssignable!T && !is(typeof(lhs.proxySwap(rhs))))
2463+{
2464+ import std.traits : hasAliasing, hasElaborateAssign, isAssignable,
2465+ isStaticArray;
2466+ static if (hasAliasing!T) if (!__ctfe)
2467+ {
2468+ import std.exception : doesPointTo;
2469+ assert(!doesPointTo(lhs, lhs), "Swap: lhs internal pointer.");
2470+ assert(!doesPointTo(rhs, rhs), "Swap: rhs internal pointer.");
2471+ assert(!doesPointTo(lhs, rhs), "Swap: lhs points to rhs.");
2472+ assert(!doesPointTo(rhs, lhs), "Swap: rhs points to lhs.");
2473+ }
2474+
2475+ static if (hasElaborateAssign!T || !isAssignable!T)
2476+ {
2477+ if (&lhs != &rhs)
2478+ {
2479+ // For structs with non-trivial assignment, move memory directly
2480+ ubyte[T.sizeof] t = void;
2481+ auto a = (cast(ubyte*) &lhs)[0 .. T.sizeof];
2482+ auto b = (cast(ubyte*) &rhs)[0 .. T.sizeof];
2483+ t[] = a[];
2484+ a[] = b[];
2485+ b[] = t[];
2486+ }
2487+ }
2488+ else
2489+ {
2490+ //Avoid assigning overlapping arrays. Dynamic arrays are fine, because
2491+ //it's their ptr and length properties which get assigned rather
2492+ //than their elements when assigning them, but static arrays are value
2493+ //types and therefore all of their elements get copied as part of
2494+ //assigning them, which would be assigning overlapping arrays if lhs
2495+ //and rhs were the same array.
2496+ static if (isStaticArray!T)
2497+ {
2498+ if (lhs.ptr == rhs.ptr)
2499+ return;
2500+ }
2501+
2502+ // For non-struct types, suffice to do the classic swap
2503+ auto tmp = lhs;
2504+ lhs = rhs;
2505+ rhs = tmp;
2506+ }
2507+}
2508+
2509+///
2510+@safe unittest
2511+{
2512+ // Swapping POD (plain old data) types:
2513+ int a = 42, b = 34;
2514+ swap(a, b);
2515+ assert(a == 34 && b == 42);
2516+
2517+ // Swapping structs with indirection:
2518+ static struct S { int x; char c; int[] y; }
2519+ S s1 = { 0, 'z', [ 1, 2 ] };
2520+ S s2 = { 42, 'a', [ 4, 6 ] };
2521+ swap(s1, s2);
2522+ assert(s1.x == 42);
2523+ assert(s1.c == 'a');
2524+ assert(s1.y == [ 4, 6 ]);
2525+
2526+ assert(s2.x == 0);
2527+ assert(s2.c == 'z');
2528+ assert(s2.y == [ 1, 2 ]);
2529+
2530+ // Immutables cannot be swapped:
2531+ immutable int imm1 = 1, imm2 = 2;
2532+ static assert(!__traits(compiles, swap(imm1, imm2)));
2533+
2534+ int c = imm1 + 0;
2535+ int d = imm2 + 0;
2536+ swap(c, d);
2537+ assert(c == 2);
2538+ assert(d == 1);
2539+}
2540+
2541+///
2542+@safe unittest
2543+{
2544+ // Non-copyable types can still be swapped.
2545+ static struct NoCopy
2546+ {
2547+ this(this) { assert(0); }
2548+ int n;
2549+ string s;
2550+ }
2551+ NoCopy nc1, nc2;
2552+ nc1.n = 127; nc1.s = "abc";
2553+ nc2.n = 513; nc2.s = "uvwxyz";
2554+
2555+ swap(nc1, nc2);
2556+ assert(nc1.n == 513 && nc1.s == "uvwxyz");
2557+ assert(nc2.n == 127 && nc2.s == "abc");
2558+
2559+ swap(nc1, nc1);
2560+ swap(nc2, nc2);
2561+ assert(nc1.n == 513 && nc1.s == "uvwxyz");
2562+ assert(nc2.n == 127 && nc2.s == "abc");
2563+
2564+ // Types containing non-copyable fields can also be swapped.
2565+ static struct NoCopyHolder
2566+ {
2567+ NoCopy noCopy;
2568+ }
2569+ NoCopyHolder h1, h2;
2570+ h1.noCopy.n = 31; h1.noCopy.s = "abc";
2571+ h2.noCopy.n = 65; h2.noCopy.s = null;
2572+
2573+ swap(h1, h2);
2574+ assert(h1.noCopy.n == 65 && h1.noCopy.s == null);
2575+ assert(h2.noCopy.n == 31 && h2.noCopy.s == "abc");
2576+
2577+ swap(h1, h1);
2578+ swap(h2, h2);
2579+ assert(h1.noCopy.n == 65 && h1.noCopy.s == null);
2580+ assert(h2.noCopy.n == 31 && h2.noCopy.s == "abc");
2581+
2582+ // Const types cannot be swapped.
2583+ const NoCopy const1, const2;
2584+ assert(const1.n == 0 && const2.n == 0);
2585+ static assert(!__traits(compiles, swap(const1, const2)));
2586+}
2587+
2588+@safe unittest
2589+{
2590+ //Bug# 4789
2591+ int[1] s = [1];
2592+ swap(s, s);
2593+
2594+ int[3] a = [1, 2, 3];
2595+ swap(a[1], a[2]);
2596+ assert(a == [1, 3, 2]);
2597+}
2598+
2599+@safe unittest
2600+{
2601+ static struct NoAssign
2602+ {
2603+ int i;
2604+ void opAssign(NoAssign) @disable;
2605+ }
2606+ auto s1 = NoAssign(1);
2607+ auto s2 = NoAssign(2);
2608+ swap(s1, s2);
2609+ assert(s1.i == 2);
2610+ assert(s2.i == 1);
2611+}
2612+
2613+@safe unittest
2614+{
2615+ struct S
2616+ {
2617+ const int i;
2618+ int i2 = 2;
2619+ int i3 = 3;
2620+ }
2621+ S s;
2622+ static assert(!__traits(compiles, swap(s, s)));
2623+ swap(s.i2, s.i3);
2624+ assert(s.i2 == 3);
2625+ assert(s.i3 == 2);
2626+}
2627+
2628+@safe unittest
2629+{
2630+ //11853
2631+ import std.traits : isAssignable;
2632+ alias T = Tuple!(int, double);
2633+ static assert(isAssignable!T);
2634+}
2635+
2636+@safe unittest
2637+{
2638+ // 12024
2639+ import std.datetime;
2640+ SysTime a, b;
2641+ swap(a, b);
2642+}
2643+
2644+@system unittest // 9975
2645+{
2646+ import std.exception : doesPointTo, mayPointTo;
2647+ static struct S2
2648+ {
2649+ union
2650+ {
2651+ size_t sz;
2652+ string s;
2653+ }
2654+ }
2655+ S2 a , b;
2656+ a.sz = -1;
2657+ assert(!doesPointTo(a, b));
2658+ assert( mayPointTo(a, b));
2659+ swap(a, b);
2660+
2661+ //Note: we can catch an error here, because there is no RAII in this test
2662+ import std.exception : assertThrown;
2663+ void* p, pp;
2664+ p = &p;
2665+ assertThrown!Error(move(p));
2666+ assertThrown!Error(move(p, pp));
2667+ assertThrown!Error(swap(p, pp));
2668+}
2669+
2670+@system unittest
2671+{
2672+ static struct A
2673+ {
2674+ int* x;
2675+ this(this) { x = new int; }
2676+ }
2677+ A a1, a2;
2678+ swap(a1, a2);
2679+
2680+ static struct B
2681+ {
2682+ int* x;
2683+ void opAssign(B) { x = new int; }
2684+ }
2685+ B b1, b2;
2686+ swap(b1, b2);
2687+}
2688+
2689+/// ditto
2690+void swap(T)(ref T lhs, ref T rhs)
2691+if (is(typeof(lhs.proxySwap(rhs))))
2692+{
2693+ lhs.proxySwap(rhs);
2694+}
2695+
2696+/**
2697+Swaps two elements in-place of a range `r`,
2698+specified by their indices `i1` and `i2`.
2699+
2700+Params:
2701+ r = a range with swappable elements
2702+ i1 = first index
2703+ i2 = second index
2704+*/
2705+void swapAt(R)(auto ref R r, size_t i1, size_t i2)
2706+{
2707+ static if (is(typeof(&r.swapAt)))
2708+ {
2709+ r.swapAt(i1, i2);
2710+ }
2711+ else static if (is(typeof(&r[i1])))
2712+ {
2713+ swap(r[i1], r[i2]);
2714+ }
2715+ else
2716+ {
2717+ if (i1 == i2) return;
2718+ auto t1 = r.moveAt(i1);
2719+ auto t2 = r.moveAt(i2);
2720+ r[i2] = t1;
2721+ r[i1] = t2;
2722+ }
2723+}
2724+
2725+///
2726+pure @safe nothrow unittest
2727+{
2728+ import std.algorithm.comparison : equal;
2729+ auto a = [1, 2, 3];
2730+ a.swapAt(1, 2);
2731+ assert(a.equal([1, 3, 2]));
2732+}
2733+
2734+pure @safe nothrow unittest
2735+{
2736+ import std.algorithm.comparison : equal;
2737+ auto a = [4, 5, 6];
2738+ a.swapAt(1, 1);
2739+ assert(a.equal([4, 5, 6]));
2740+}
2741+
2742+pure @safe nothrow unittest
2743+{
2744+ // test non random access ranges
2745+ import std.algorithm.comparison : equal;
2746+ import std.array : array;
2747+
2748+ char[] b = ['a', 'b', 'c'];
2749+ b.swapAt(1, 2);
2750+ assert(b.equal(['a', 'c', 'b']));
2751+
2752+ int[3] c = [1, 2, 3];
2753+ c.swapAt(1, 2);
2754+ assert(c.array.equal([1, 3, 2]));
2755+
2756+ // opIndex returns lvalue
2757+ struct RandomIndexType(T)
2758+ {
2759+ T payload;
2760+
2761+ @property ref auto opIndex(size_t i)
2762+ {
2763+ return payload[i];
2764+ }
2765+
2766+ }
2767+ auto d = RandomIndexType!(int[])([4, 5, 6]);
2768+ d.swapAt(1, 2);
2769+ assert(d.payload.equal([4, 6, 5]));
2770+
2771+ // custom moveAt and opIndexAssign
2772+ struct RandomMoveAtType(T)
2773+ {
2774+ T payload;
2775+
2776+ ElementType!T moveAt(size_t i)
2777+ {
2778+ return payload.moveAt(i);
2779+ }
2780+
2781+ void opIndexAssign(ElementType!T val, size_t idx)
2782+ {
2783+ payload[idx] = val;
2784+ }
2785+ }
2786+ auto e = RandomMoveAtType!(int[])([7, 8, 9]);
2787+ e.swapAt(1, 2);
2788+ assert(e.payload.equal([7, 9, 8]));
2789+
2790+
2791+ // custom swapAt
2792+ struct RandomSwapAtType(T)
2793+ {
2794+ T payload;
2795+
2796+ void swapAt(size_t i)
2797+ {
2798+ return payload.swapAt(i);
2799+ }
2800+ }
2801+ auto f = RandomMoveAtType!(int[])([10, 11, 12]);
2802+ swapAt(f, 1, 2);
2803+ assert(f.payload.equal([10, 12, 11]));
2804+}
2805+
2806+private void swapFront(R1, R2)(R1 r1, R2 r2)
2807+if (isInputRange!R1 && isInputRange!R2)
2808+{
2809+ static if (is(typeof(swap(r1.front, r2.front))))
2810+ {
2811+ swap(r1.front, r2.front);
2812+ }
2813+ else
2814+ {
2815+ auto t1 = moveFront(r1), t2 = moveFront(r2);
2816+ r1.front = move(t2);
2817+ r2.front = move(t1);
2818+ }
2819+}
2820+
2821+// swapRanges
2822+/**
2823+Swaps all elements of $(D r1) with successive elements in $(D r2).
2824+Returns a tuple containing the remainder portions of $(D r1) and $(D
2825+r2) that were not swapped (one of them will be empty). The ranges may
2826+be of different types but must have the same element type and support
2827+swapping.
2828+
2829+Params:
2830+ r1 = an $(REF_ALTTEXT input _range, isInputRange, std,_range,primitives)
2831+ with swappable elements
2832+ r2 = an $(REF_ALTTEXT input _range, isInputRange, std,_range,primitives)
2833+ with swappable elements
2834+
2835+Returns:
2836+ Tuple containing the remainder portions of r1 and r2 that were not swapped
2837+*/
2838+Tuple!(InputRange1, InputRange2)
2839+swapRanges(InputRange1, InputRange2)(InputRange1 r1, InputRange2 r2)
2840+if (hasSwappableElements!InputRange1 && hasSwappableElements!InputRange2
2841+ && is(ElementType!InputRange1 == ElementType!InputRange2))
2842+{
2843+ for (; !r1.empty && !r2.empty; r1.popFront(), r2.popFront())
2844+ {
2845+ swap(r1.front, r2.front);
2846+ }
2847+ return tuple(r1, r2);
2848+}
2849+
2850+///
2851+@safe unittest
2852+{
2853+ import std.range : empty;
2854+ int[] a = [ 100, 101, 102, 103 ];
2855+ int[] b = [ 0, 1, 2, 3 ];
2856+ auto c = swapRanges(a[1 .. 3], b[2 .. 4]);
2857+ assert(c[0].empty && c[1].empty);
2858+ assert(a == [ 100, 2, 3, 103 ]);
2859+ assert(b == [ 0, 1, 101, 102 ]);
2860+}
2861+
2862+/**
2863+Initializes each element of $(D range) with $(D value).
2864+Assumes that the elements of the range are uninitialized.
2865+This is of interest for structs that
2866+define copy constructors (for all other types, $(LREF fill) and
2867+uninitializedFill are equivalent).
2868+
2869+Params:
2870+ range = An
2871+ $(REF_ALTTEXT input _range, isInputRange, std,_range,primitives)
2872+ that exposes references to its elements and has assignable
2873+ elements
2874+ value = Assigned to each element of range
2875+
2876+See_Also:
2877+ $(LREF fill)
2878+ $(LREF initializeAll)
2879+ */
2880+void uninitializedFill(Range, Value)(Range range, Value value)
2881+if (isInputRange!Range && hasLvalueElements!Range && is(typeof(range.front = value)))
2882+{
2883+ import std.traits : hasElaborateAssign;
2884+
2885+ alias T = ElementType!Range;
2886+ static if (hasElaborateAssign!T)
2887+ {
2888+ import std.conv : emplaceRef;
2889+
2890+ // Must construct stuff by the book
2891+ for (; !range.empty; range.popFront())
2892+ emplaceRef!T(range.front, value);
2893+ }
2894+ else
2895+ // Doesn't matter whether fill is initialized or not
2896+ return fill(range, value);
2897+}
2898+
2899+///
2900+nothrow @system unittest
2901+{
2902+ import core.stdc.stdlib : malloc, free;
2903+
2904+ auto s = (cast(int*) malloc(5 * int.sizeof))[0 .. 5];
2905+ uninitializedFill(s, 42);
2906+ assert(s == [ 42, 42, 42, 42, 42 ]);
2907+
2908+ scope(exit) free(s.ptr);
2909+}

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t