Returns a newly-allocated dynamic  array consisting of a copy of the input range, static  array, dynamic  array, or class or struct with an opApply function r. Note that narrow strings are handled as a special case in an overload.

    auto a = array([1, 2, 3, 4, 5][]);
    assert(a == [ 1, 2, 3, 4, 5 ]);

Convert a narrow string to an  array type that fully supports random access. This is handled as a special case and always returns a dchar[], const(dchar)[], or immutable(dchar)[] depending on the constness of the input.

Returns a newly allocated associative array out of elements of the input range, which must be a range of tuples (Key, Value).

    auto a = assocArray(zip([0, 1, 2], ["a", "b", "c"]));
    assert(is(typeof(a) == string[int]));
    assert(a == [0:"a", 1:"b", 2:"c"]);

    auto b = assocArray([ tuple("foo", "bar"), tuple("baz", "quux") ]);
    assert(is(typeof(b) == string[string]));
    assert(b == ["foo":"bar", "baz":"quux"]);

    static assert(!__traits(compiles, [ tuple("foo", "bar", "baz") ].assocArray()));
    static assert(!__traits(compiles, [ tuple("foo") ].assocArray()));
    static assert( __traits(compiles, [ tuple("foo", "bar") ].assocArray()));

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 1 to the number in T.

    double[] arr = uninitializedArray!(double[])(100);
    assert(arr.length == 100);

    double[][] matrix = uninitializedArray!(double[][])(42, 31);
    assert(matrix.length == 42);
    assert(matrix[0].length == 31);

Returns a new array of type T allocated on the garbage collected heap. Initialization is guaranteed only for pointers, references and slices, for preservation of memory safety.

Implements the range interface primitive  empty for built-in arrays. Due to the fact that nonmember functions can be called with the first argument using the dot notation, array. empty is equivalent to  empty(array).

    auto a = [ 1, 2, 3 ];
    assert(!a.empty);
    assert(a[3 .. $].empty);

Implements the range interface primitive  save for built-in arrays. Due to the fact that nonmember functions can be called with the first argument using the dot notation, array. save is equivalent to  save(array). The function does not duplicate the content of the array, it simply returns its argument.

    auto a = [ 1, 2, 3 ];
    auto b = a.save;
    assert(b is a);

Implements the range interface primitive  popFront for built-in arrays. Due to the fact that nonmember functions can be called with the first argument using the dot notation, array. popFront is equivalent to  popFront(array). For narrow strings,  popFront automaticaly advances to the next code point.

    auto a = [ 1, 2, 3 ];
    a.popFront();
    assert(a == [ 2, 3 ]);

Implements the range interface primitive  popBack for built-in arrays. Due to the fact that nonmember functions can be called with the first argument using the dot notation, array. popBack is equivalent to  popBack(array). For narrow strings, popFront automaticaly eliminates the last code point.

    auto a = [ 1, 2, 3 ];
    a.popBack();
    assert(a == [ 1, 2 ]);

Implements the range interface primitive  front for built-in arrays. Due to the fact that nonmember functions can be called with the first argument using the dot notation, array. front is equivalent to  front(array). For narrow strings,  front automaticaly returns the first code point as a dchar.

    int[] a = [ 1, 2, 3 ];
    assert(a.front == 1);

Implements the range interface primitive  back for built-in arrays. Due to the fact that nonmember functions can be called with the first argument using the dot notation, array. back is equivalent to  back(array). For narrow strings,  back automaticaly returns the last code point as a dchar.

    int[] a = [ 1, 2, 3 ];
    assert(a.back == 3);
    a.back += 4;
    assert(a.back == 7);

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

int[] a = [ 1, 2, 3, 4 ];
a.insertInPlace(2, [ 1, 2 ]);
assert(a == [ 1, 2, 1, 2, 3, 4 ]);
a.insertInPlace(3, 10u, 11);
assert(a == [ 1, 2, 1, 10, 11, 2, 3, 4]);

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.

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 $.

Returns an array that consists of s (which must be an input range) repeated n times. This function allocates, fills, and returns a new array. For a lazy version, refer to std.range.repeat.

Split the string s into an array of words, using whitespace as delimiter. Runs of whitespace are merged together (no empty words are produced).

Splits a string by whitespace.

    auto a = " a     bcd   ef gh ";
    assert(equal(splitter(a), ["", "a", "bcd", "ef", "gh"][]));

Splits s into an array, using delim as the delimiter.

Concatenates all of the ranges in ror together into one array using sep as the separator if present.

Replace occurrences of from with to in subject. Returns a new array without changing the contents of subject, or the original array if no match is found.

Same as above, but outputs the result via OutputRange sink. If no match is found the original array is transfered to sink as is.

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

int[] a = [ 1, 2, 3, 4 ];
a.replaceInPlace(1, 3, [ 9, 9, 9 ]);
assert(a == [ 1, 9, 9, 9, 4 ]);

Replaces the first occurrence of from with to in a. Returns a new array without changing the contents of subject, or the original array if no match is found.

Returns an array that is s with slice replaced by replacement[].

Implements an output range that appends data to an array. This is recommended over a ~= data when appending many elements because it is more efficient.

auto app = appender!string();
string b = "abcdefg";
foreach (char c; b) app.put(c);
assert(app.data == "abcdefg");

int[] a = [ 1, 2 ];
auto app2 = appender(a);
app2.put(3);
app2.put([ 4, 5, 6 ]);
assert(app2.data == [ 1, 2, 3, 4, 5, 6 ]);

An 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.

Convenience function that returns an Appender!A object initialized with array.

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