View source code
Display the source code in std/algorithm/mutation.d from which this
page was generated on github.
Report a bug
If you spot a problem with this page, click here to create a
Bugzilla issue.
Improve this page
Quickly fork, edit online, and submit a pull request for this page.
Requires a signedin GitHub account. This works well for small changes.
If you'd like to make larger changes you may want to consider using
local clone.
Module std.algorithm.mutation
This is a submodule of std
.
It contains generic mutation algorithms.
Function Name  Description 

bringToFront  If a = [1, 2, 3] and b = [4, 5, 6, 7] ,
bringToFront(a, b) leaves a = [4, 5, 6] and
b = [7, 1, 2, 3] . 
copy  Copies a range to another. If
a = [1, 2, 3] and b = new int[5] , then copy(a, b)
leaves b = [1, 2, 3, 0, 0] and returns b[3 .. $] . 
fill  Fills a range with a pattern,
e.g., if a = new int[3] , then fill(a, 4)
leaves a = [4, 4, 4] and fill(a, [3, 4]) leaves
a = [3, 4, 3] . 
initializeAll  If a = [1.2, 3.4] , then initializeAll(a) leaves
a = [double . 
move  move(a, b) moves a into b . move(a) reads a
destructively when necessary. 
moveEmplace  Similar to move but assumes target is uninitialized. 
moveAll  Moves all elements from one range to another. 
moveEmplaceAll  Similar to moveAll but assumes all elements in target are uninitialized. 
moveSome  Moves as many elements as possible from one range to another. 
moveEmplaceSome  Similar to moveSome but assumes all elements in target are uninitialized. 
remove  Removes elements from a range inplace, and returns the shortened range. 
reverse  If a = [1, 2, 3] , reverse(a) changes it to [3, 2, 1] . 
strip  Strips all leading and trailing elements equal to a value, or that
satisfy a predicate.
If a = [1, 1, 0, 1, 1] , then strip(a, 1) and
strip!(e => e == 1)(a) returns [0] . 
stripLeft  Strips all leading elements equal to a value, or that satisfy a
predicate. If a = [1, 1, 0, 1, 1] , then stripLeft(a, 1) and
stripLeft!(e => e == 1)(a) returns [0, 1, 1] . 
stripRight  Strips all trailing elements equal to a value, or that satisfy a
predicate.
If a = [1, 1, 0, 1, 1] , then stripRight(a, 1) and
stripRight!(e => e == 1)(a) returns [1, 1, 0] . 
swap  Swaps two values. 
swapAt  Swaps two values by indices. 
swapRanges  Swaps all elements of two ranges. 
uninitializedFill  Fills a range (assumed uninitialized) with a value. 
Functions
Name  Description 

bringToFront

The bringToFront function has considerable flexibility and
usefulness. It can rotate elements in one buffer left or right, swap
buffers of equal length, and even move elements across disjoint
buffers of different types and different lengths.

copy

Copies the content of source into target and returns the
remaining (unfilled) part of target .

fill

Assigns value to each element of input range range .

fill

Fills range with a pattern copied from filler . The length of
range does not have to be a multiple of the length of filler . If filler is empty, an exception is thrown.

initializeAll

Initializes all elements of range with their value.
Assumes that the elements of the range are uninitialized.

move

Moves source into target , via a destructive copy when necessary.

moveAll

Calls move(a, b) for each element a in src and the corresponding
element b in tgt , in increasing order.

moveEmplace

Similar to move but assumes target is uninitialized. This
is more efficient because source can be blitted over target
without destroying or initializing it first.

moveEmplaceAll

Similar to moveAll but assumes all elements in tgt are
uninitialized. Uses moveEmplace to move elements from
src over elements from tgt .

moveEmplaceSome

Same as moveSome but assumes all elements in tgt are
uninitialized. Uses moveEmplace to move elements from
src over elements from tgt .

moveSome

Calls move(a, b) for each element a in src and the corresponding
element b in tgt , in increasing order, stopping when either range has been
exhausted.

remove

Eliminates elements at given offsets from range and returns the shortened
range.

remove

Reduces the length of the
bidirectional range range by removing
elements that satisfy pred . If s = SwapStrategy ,
elements are moved from the right end of the range over the elements
to eliminate. If s = SwapStrategy (the default),
elements are moved progressively to front such that their relative
order is preserved. Returns the filtered range.

reverse

Reverses r inplace. Performs r evaluations of swap .

reverse

Reverses r inplace, where r is a narrow string (having
elements of type char or wchar ). UTF sequences consisting of
multiple code units are preserved properly.

strip

The strip group of functions allow stripping of either leading, trailing, or both leading and trailing elements. 
stripLeft

The strip group of functions allow stripping of either leading, trailing, or both leading and trailing elements. 
stripRight

The strip group of functions allow stripping of either leading, trailing, or both leading and trailing elements. 
swap

Swaps lhs and rhs . The instances lhs and rhs are moved in
memory, without ever calling opAssign , nor any other function. T
need not be assignable at all to be swapped.

swapAt

Swaps two elements inplace of a range r ,
specified by their indices i1 and i2 .

swapRanges

Swaps all elements of r1 with successive elements in r2 .
Returns a tuple containing the remainder portions of r1 and r2 that were not swapped (one of them will be empty). The ranges may
be of different types but must have the same element type and support
swapping.

uninitializedFill

Initializes each element of range with value .
Assumes that the elements of the range are uninitialized.
This is of interest for structs that
define copy constructors (for all other types, fill and
uninitializedFill are equivalent).

Enums
Name  Description 

SwapStrategy

Defines the swapping strategy for algorithms that need to swap
elements in a range (such as partition and sort). The strategy
concerns the swapping of elements that are not the core concern of the
algorithm. For example, consider an algorithm that sorts [ "abc",
"b", "aBc" ] according to toUpper(a) < toUpper(b) . That
algorithm might choose to swap the two equivalent strings "abc"
and "aBc" . That does not affect the sorting since both [
"abc", "aBc", "b" ] and [ "aBc", "abc", "b" ] are valid
outcomes.

Authors
License
Comments
Copyright © 19992017 by the D Language Foundation  Page generated by ddox.