std.array

Functions and types that manipulate built-in arrays and associative arrays.

This module provides all kinds of functions to create, manipulate or convert arrays:

Function NameDescription
arrayReturns a copy of the input in a newly allocated dynamic array.
appenderReturns a new Appender or RefAppender initialized with a given array.
assocArrayReturns a newly allocated associative array from a range of key/value tuples.
byPairConstruct a range iterating over an associative array by key/value tuples.
insertInPlaceInserts into an existing array at a given position.
joinConcatenates a range of ranges into one array.
minimallyInitializedArrayReturns a new array of type T.
replaceReturns a new array with all occurrences of a certain subrange replaced.
replaceFirstReturns a new array with the first occurrence of a certain subrange replaced.
replaceInPlaceReplaces all occurrences of a certain subrange and puts the result into a given array.
replaceIntoReplaces all occurrences of a certain subrange and puts the result into an output range.
replaceLastReturns a new array with the last occurrence of a certain subrange replaced.
replaceSliceReturns a new array with a given slice replaced.
replicateCreates a new array out of several copies of an input array or range.
sameHeadChecks if the initial segments of two arrays refer to the same place in memory.
sameTailChecks if the final segments of two arrays refer to the same place in memory.
splitEagerly split a range or string into an array.
staticArrayCreates a new static array from given data.
uninitializedArrayReturns a new array of type T without initializing its elements.

Public Imports

std.range.primitives
public import std.range.primitives : save, empty, popFront, popBack, front, back;

Members

Functions

appender
Appender!A appender()
Appender!(E[]) appender(A array)

Convenience function that returns an Appender instance, optionally initialized with array.

appender
RefAppender!(E[]) appender(P arrayPtr)

Convenience function that returns a RefAppender instance initialized with arrayPtr. Don't use null for the array pointer, use the other version of appender instead.

array
ForeachType!Range[] array(Range r)
ForeachType!(PointerTarget!Range)[] array(Range r)

Allocates an array and initializes it with copies of the elements of range r.

array
CopyTypeQualifiers!(ElementType!String, dchar)[] array(String str)

Convert a narrow autodecoding string to an array type that fully supports random access. This is handled as a special case and always returns an array of dchar

assocArray
auto assocArray(Range r)
auto assocArray(Keys keys, Values values)

Returns a newly allocated associative array from a range of key/value tuples or from a range of keys and a range of values.

byPair
auto byPair(AA aa)

Construct a range iterating over an associative array by key/value tuples.

insertInPlace
void insertInPlace(T[] array, size_t pos, U stuff)

Inserts stuff (which must be an input range or any number of implicitly convertible items) in array at position pos.

join
ElementEncodingType!(ElementType!RoR)[] join(RoR ror, R sep)
ElementEncodingType!(ElementType!RoR)[] join(RoR ror, E sep)
ElementEncodingType!(ElementType!RoR)[] join(RoR ror)

Eagerly concatenates all of the ranges in ror together (with the GC) into one array using sep as the separator if present.

minimallyInitializedArray
auto minimallyInitializedArray(I sizes)

Returns a new array of type T allocated on the garbage collected heap.

overlap
CommonType!(T[], U[]) overlap(T[] a, U[] b)

Returns the overlapping portion, if any, of two arrays. Unlike equal, overlap only compares the pointers and lengths in the ranges, not the values referred by them. If r1 and r2 have an overlapping slice, returns that slice. Otherwise, returns the null slice.

replace
E[] replace(E[] subject, R1 from, R2 to)

Replace occurrences of from with to in subject in a new array.

replace
T[] replace(T[] subject, size_t from, size_t to, Range stuff)

Replaces elements from array with indices ranging from from (inclusive) to to (exclusive) with the range stuff.

replaceFirst
E[] replaceFirst(E[] subject, R1 from, R2 to)

Replaces the first occurrence of from with to in subject.

replaceInPlace
void replaceInPlace(T[] array, size_t from, size_t to, Range stuff)

Replaces elements from array with indices ranging from from (inclusive) to to (exclusive) with the range stuff. Expands or shrinks the array as needed.

replaceInto
void replaceInto(Sink sink, E[] subject, R1 from, R2 to)

Replace occurrences of from with to in subject and output the result into sink.

replaceLast
E[] replaceLast(E[] subject, R1 from, R2 to)

Replaces the last occurrence of from with to in subject.

replaceSlice
inout(T)[] replaceSlice(inout(T)[] s, T[] slice, T[] replacement)

Creates a new array such that the items in slice are replaced with the items in replacement. slice and replacement do not need to be the same length. The result will grow or shrink based on the items given.

replicate
ElementEncodingType!S[] replicate(S s, size_t n)
ElementType!S[] replicate(S s, size_t n)
sameHead
bool sameHead(T[] lhs, T[] rhs)

Returns whether the fronts of lhs and rhs both refer to the same place in memory, making one of the arrays a slice of the other which starts at index 0.

sameTail
bool sameTail(T[] lhs, T[] rhs)

Returns whether the backs of lhs and rhs both refer to the same place in memory, making one of the arrays a slice of the other which end at index $.

split
S[] split(S s)
auto split(Range range, Separator sep)
auto split(Range range)

Eagerly splits range into an array, using sep as the delimiter.

staticArray
T[n] staticArray(T[n] a)
auto staticArray(T a)
auto staticArray(T a, size_t rangeLength)
auto staticArray()

Constructs a static array from a. The type of elements can be specified implicitly so that [1, 2].staticArray results in int[2], or explicitly, e.g. [1, 2].staticArray!float returns float[2]. When a is a range whose length is not known at compile time, the number of elements must be given as template argument (e.g. myrange.staticArray!2). Size and type can be combined, if the source range elements are implicitly convertible to the requested element type (eg: 2.iota.staticArray!(long[2])). When the range a is known at compile time, it can also be specified as a template argument to avoid having to specify the number of elements (e.g.: staticArray!(2.iota) or staticArray!(double, 2.iota)).

uninitializedArray
auto uninitializedArray(I sizes)

Returns a new array of type T allocated on the garbage collected heap without initializing its elements. This can be a useful optimization if every element will be immediately initialized. T may be a multidimensional array. In this case sizes may be specified for any number of dimensions from 0 to the number in T.

Structs

Appender
struct Appender(A)

Implements an output range that appends data to an array. This is recommended over array ~= data when appending many elements because it is more efficient. Appender maintains its own array metadata locally, so it can avoid global locking for each append where capacity is non-zero.

RefAppender
struct RefAppender(A)

A version of Appender that can update an array in-place. It forwards all calls to an underlying appender implementation. Any calls made to the appender also update the pointer to the original array passed in.

Meta