From ca9561b3892b0bb2df97c85235321df0eb313c3e Mon Sep 17 00:00:00 2001 From: Nick Treleaven Date: Sat, 10 Feb 2024 12:32:57 +0000 Subject: [PATCH] [std.algorithm.mutation] Improve `remove` docs Make examples runnable. Add 2 subheadings. Minor tweaks. Fix throwing example of tuple offset. --- std/algorithm/mutation.d | 38 +++++++++++++++++++++++++++++++------- 1 file changed, 31 insertions(+), 7 deletions(-) diff --git a/std/algorithm/mutation.d b/std/algorithm/mutation.d index 61b6a5e4eff..fbef28e5d56 100644 --- a/std/algorithm/mutation.d +++ b/std/algorithm/mutation.d @@ -1813,22 +1813,28 @@ range. For example, here is how to remove a single element from an array: +$(RUNNABLE_EXAMPLE ---- +import std.algorithm.mutation; string[] a = [ "a", "b", "c", "d" ]; a = a.remove(1); // remove element at offset 1 assert(a == [ "a", "c", "d"]); ---- +) Note that `remove` does not change the length of the original range directly; instead, it returns the shortened range. If its return value is not assigned to the original range, the original range will retain its original length, though its contents will have changed: +$(RUNNABLE_EXAMPLE ---- +import std.algorithm.mutation; int[] a = [ 3, 5, 7, 8 ]; assert(remove(a, 1) == [ 3, 7, 8 ]); assert(a == [ 3, 7, 8, 8 ]); ---- +) The element at offset `1` has been removed and the rest of the elements have shifted up to fill its place, however, the original array remains of the same @@ -1838,25 +1844,34 @@ invoked to rearrange elements, and on integers `move` simply copies the source to the destination. To replace `a` with the effect of the removal, simply assign the slice returned by `remove` to it, as shown in the first example. +$(H3 $(LNAME2 remove-multiple, Removing multiple elements)) + Multiple indices can be passed into `remove`. In that case, elements at the respective indices are all removed. The indices must be passed in increasing order, otherwise an exception occurs. +$(RUNNABLE_EXAMPLE ---- +import std.algorithm.mutation; int[] a = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]; assert(remove(a, 1, 3, 5) == [ 0, 2, 4, 6, 7, 8, 9, 10 ]); ---- +) -(Note that all indices refer to slots in the $(I original) array, not -in the array as it is being progressively shortened.) +Note that all indices refer to slots in the $(I original) array, not +in the array as it is being progressively shortened. -Tuples of two integral offsets can be used to remove an indices range: +Tuples of two integral offsets can be supplied to remove a range of indices: +$(RUNNABLE_EXAMPLE ---- +import std.algorithm.mutation, std.typecons; int[] a = [ 3, 4, 5, 6, 7]; -assert(remove(a, 1, tuple(1, 3), 9) == [ 3, 6, 7 ]); +// remove elements at indices 1 and 2 +assert(remove(a, tuple(1, 3)) == [ 3, 6, 7 ]); ---- +) The tuple passes in a range closed to the left and open to the right (consistent with built-in slices), e.g. `tuple(1, 3)` @@ -1865,22 +1880,31 @@ means indices `1` and `2` but not `3`. Finally, any combination of integral offsets and tuples composed of two integral offsets can be passed in: +$(RUNNABLE_EXAMPLE ---- +import std.algorithm.mutation, std.typecons; int[] a = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]; -assert(remove(a, 1, tuple(3, 5), 9) == [ 0, 2, 5, 6, 7, 8, 10 ]); +a = remove(a, 1, tuple(3, 5), 9); +assert(a == [ 0, 2, 5, 6, 7, 8, 10 ]); ---- +) In this case, the slots at positions 1, 3, 4, and 9 are removed from the array. +$(H3 $(LNAME2 remove-moving, Moving strategy)) + If the need is to remove some elements in the range but the order of the remaining elements does not have to be preserved, you may want to pass `SwapStrategy.unstable` to `remove`. +$(RUNNABLE_EXAMPLE ---- +import std.algorithm.mutation; int[] a = [ 0, 1, 2, 3 ]; assert(remove!(SwapStrategy.unstable)(a, 1) == [ 0, 3, 2 ]); ---- +) In the case above, the element at slot `1` is removed, but replaced with the last element of the range. Taking advantage of the relaxation @@ -1888,7 +1912,7 @@ of the stability requirement, `remove` moved elements from the end of the array over the slots to be removed. This way there is less data movement to be done which improves the execution time of the function. -The function `remove` works on bidirectional ranges that have assignable +`remove` works on bidirectional ranges that have assignable lvalue elements. The moving strategy is (listed from fastest to slowest): $(UL @@ -1914,7 +1938,7 @@ Params: offset = which element(s) to remove Returns: - A range containing all of the elements of range with offset removed. + A range containing elements of `range` with 1 or more elements removed. */ Range remove (SwapStrategy s = SwapStrategy.stable, Range, Offset ...)