std.array
| Function Name | Description |
|---|---|
| array | Returns a copy of the input in a newly allocated dynamic array. |
| appender | Returns a new Appender or RefAppender initialized with a given array. |
| assocArray | Returns a newly allocated associative array from a range of key/value tuples. |
| byPair | Construct a range iterating over an associative array by key/value tuples. |
| insertInPlace | Inserts into an existing array at a given position. |
| join | Concatenates a range of ranges into one array. |
| minimallyInitializedArray | Returns a new array of type T. |
| replace | Returns a new array with all occurrences of a certain subrange replaced. |
| replaceFirst | Returns a new array with the first occurrence of a certain subrange replaced. |
| replaceInPlace | Replaces all occurrences of a certain subrange and puts the result into a given array. |
| replaceInto | Replaces all occurrences of a certain subrange and puts the result into an output range. |
| replaceLast | Returns a new array with the last occurrence of a certain subrange replaced. |
| replaceSlice | Returns a new array with a given slice replaced. |
| replicate | Creates a new array out of several copies of an input array or range. |
| sameHead | Checks if the initial segments of two arrays refer to the same place in memory. |
| sameTail | Checks if the final segments of two arrays refer to the same place in memory. |
| split | Eagerly split a range or string into an array. |
| uninitializedArray | Returns a new array of type T without initializing its elements. |
Source std/array.d
- ForeachType!Range[]
array(Range)(Ranger)
if (isIterable!Range && !isNarrowString!Range && !isInfinite!Range);
ForeachType!(PointerTarget!Range)[]array(Range)(Ranger)
if (isPointer!Range && isIterable!(PointerTarget!Range) && !isNarrowString!Range && !isInfinite!Range); - Allocates an array and initializes it with copies of the elements of range
r.Narrow strings are handled as a special case in an overload.Parameters:Range rrange (or aggregate with opApply function) whose elements are copied into the allocated array Returns:allocated and initialized arrayExamples:auto a = array([1, 2, 3, 4, 5][]); writeln(a); // [1, 2, 3, 4, 5]
- ElementType!String[]
array(String)(scope Stringstr)
if (isNarrowString!String); - Convert a narrow string to an array type that fully supports random access. This is handled as a special case and always returns an array of dcharParameters:
String strisNarrowString to be converted to an array of dchar Returns:a dchar[], const(dchar)[], or immutable(dchar)[] depending on the constness of the input.Examples:import std.range.primitives : isRandomAccessRange; writeln("Hello D".array); // "Hello D"d static assert(isRandomAccessRange!string == false); writeln("Hello D"w.array); // "Hello D"d static assert(isRandomAccessRange!dstring == true);
- auto
assocArray(Range)(Ranger)
if (isInputRange!Range); - Returns a newly allocated associative array from a range of key/value tuples.Parameters:
Range rAn input range of tuples of keys and values. Returns:A newly allocated associative array out of elements of the input range, which must be a range of tuples (Key, Value). Returns a null associative array reference when given an empty range.Duplicates Associative arrays have unique keys. If r contains duplicate keys, then the result will contain the value of the last pair for that key in r.
See Also:Examples:import std.range; import std.typecons; auto a = assocArray(zip([0, 1, 2], ["a", "b", "c"])); // aka zipMap assert(is(typeof(a) == string[int])); writeln(a); // [0:"a", 1:"b", 2:"c"] auto b = assocArray([ tuple("foo", "bar"), tuple("baz", "quux") ]); assert(is(typeof(b) == string[string])); writeln(b); // ["foo":"bar", "baz":"quux"]
- auto
byPair(AA)(AAaa)
if (isAssociativeArray!AA); - Construct a range iterating over an associative array by key/value tuples.Parameters:
AA aaThe associative array to iterate over. Returns:A forward range of Tuple's of key and value pairs from the given associative array. The members of each pair can be accessed by name (.key and .value). or by integer index (0 and 1 respectively).Examples:import std.algorithm.sorting : sort; import std.typecons : tuple, Tuple; auto aa = ["a": 1, "b": 2, "c": 3]; Tuple!(string, int)[] pairs; // Iteration over key/value pairs. foreach (pair; aa.byPair) { if (pair.key == "b") pairs ~= tuple("B", pair.value); else pairs ~= pair; } // Iteration order is implementation-dependent, so we should sort it to get // a fixed order. pairs.sort(); assert(pairs == [ tuple("B", 2), tuple("a", 1), tuple("c", 3) ]);
- nothrow @system auto
uninitializedArray(T, I...)(Isizes)
if (isDynamicArray!T && allSatisfy!(isIntegral, I) && hasIndirections!(ElementEncodingType!T));
nothrow @trusted autouninitializedArray(T, I...)(Isizes)
if (isDynamicArray!T && allSatisfy!(isIntegral, I) && !hasIndirections!(ElementEncodingType!T)); - 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.uninitializedArray is nothrow and weakly pure. uninitializedArray is @system if the uninitialized element type has pointers.Parameters:
T The type of the resulting array elements I sizesThe length dimension(s) of the resulting array Returns:An array of T with I.length dimensions.Examples:double[] arr = uninitializedArray!(double[])(100); writeln(arr.length); // 100 double[][] matrix = uninitializedArray!(double[][])(42, 31); writeln(matrix.length); // 42 writeln(matrix[0].length); // 31 char*[] ptrs = uninitializedArray!(char*[])(100); writeln(ptrs.length); // 100
- nothrow @trusted auto
minimallyInitializedArray(T, I...)(Isizes)
if (isDynamicArray!T && allSatisfy!(isIntegral, I)); - Returns a new array of type T allocated on the garbage collected heap.Partial initialization is done for types with indirections, for preservation of memory safety. Note that elements will only be initialized to 0, but not necessarily the element type's .init. minimallyInitializedArray is nothrow and weakly pure.Parameters:
T The type of the array elements I sizesThe length dimension(s) of the resulting array Returns:An array of T with I.length dimensions.Examples:import std.algorithm.comparison : equal; import std.range : repeat; auto arr = minimallyInitializedArray!(int[])(42); writeln(arr.length); // 42 // Elements aren't necessarily initialized to 0 assert(!arr.equal(0.repeat(42)));
- @trusted CommonType!(T[], U[])
overlap(T, U)(T[]a, U[]b)
if (is(typeof(a.ptr <b.ptr) == bool)); - Returns the overlapping portion, if any, of two arrays. Unlike equal,
overlaponly 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.Parameters:T[] aThe first array to compare U[] bThe second array to compare Returns:The overlapping portion of the two arrays.Examples:int[] a = [ 10, 11, 12, 13, 14 ]; int[] b = a[1 .. 3]; writeln(overlap(a, b)); // [11, 12] b = b.dup; // overlap disappears even though the content is the same assert(overlap(a, b).empty); static test()() @nogc { auto a = "It's three o'clock"d; auto b = a[5 .. 10]; return b.overlap(a); } //works at compile-time static assert(test == "three"d);
- void
insertInPlace(T, U...)(ref T[]array, size_tpos, Ustuff)
if (!isSomeString!(T[]) && allSatisfy!(isInputRangeOrConvertible!T, U) && (U.length > 0));
voidinsertInPlace(T, U...)(ref T[]array, size_tpos, Ustuff)
if (isSomeString!(T[]) && allSatisfy!(isCharOrStringOrDcharRange, U)); - Inserts
stuff(which must be an input range or any number of implicitly convertible items) inarrayat positionpos.Parameters:T[] arrayThe array that stuffwill be inserted into.size_t posThe position in arrayto insert thestuff.U stuffAn input range, or any number of implicitly convertible items to insert into array.Examples:int[] a = [ 1, 2, 3, 4 ]; a.insertInPlace(2, [ 1, 2 ]); writeln(a); // [1, 2, 1, 2, 3, 4] a.insertInPlace(3, 10u, 11); writeln(a); // [1, 2, 1, 10, 11, 2, 3, 4]
- pure nothrow @safe bool
sameHead(T)(in T[]lhs, in T[]rhs); - Returns whether the fronts of
lhsandrhsboth refer to the same place in memory, making one of the arrays a slice of the other which starts at index 0.Parameters:T[] lhsthe first array to compare T[] rhsthe second array to compare Returns:true if lhs.ptr == rhs.ptr, false otherwise.Examples:auto a = [1, 2, 3, 4, 5]; auto b = a[0 .. 2]; assert(a.sameHead(b));
- pure nothrow @trusted bool
sameTail(T)(in T[]lhs, in T[]rhs); - Returns whether the backs of
lhsandrhsboth refer to the same place in memory, making one of the arrays a slice of the other which end at index $.Parameters:T[] lhsthe first array to compare T[] rhsthe second array to compare Returns:true if both arrays are the same length and lhs.ptr == rhs.ptr, false otherwise.Examples:auto a = [1, 2, 3, 4, 5]; auto b = a[3..$]; assert(a.sameTail(b));
- ElementEncodingType!S[]
replicate(S)(Ss, size_tn)
if (isDynamicArray!S);
ElementType!S[]replicate(S)(Ss, size_tn)
if (isInputRange!S && !isDynamicArray!S); - Parameters:
S san input range or a dynamic array size_t nnumber of times to repeat sReturns:An array that consists ofsrepeatedntimes. This function allocates, fills, and returns a new array.See Also:For a lazy version, refer to std.range.repeat.Examples:auto a = "abc"; auto s = replicate(a, 3); writeln(s); // "abcabcabc" auto b = [1, 2, 3]; auto c = replicate(b, 3); writeln(c); // [1, 2, 3, 1, 2, 3, 1, 2, 3] auto d = replicate(b, 0); writeln(d); // []
- pure @safe S[]
split(S)(Ss)
if (isSomeString!S);
autosplit(Range, Separator)(Rangerange, Separatorsep)
if (isForwardRange!Range && (is(typeof(ElementType!Range.init == Separator.init)) || is(typeof(ElementType!Range.init == ElementType!Separator.init)) && isForwardRange!Separator));
autosplit(alias isTerminator, Range)(Rangerange)
if (isForwardRange!Range && is(typeof(unaryFun!isTerminator(range.front)))); - Eagerly splits
rangeinto an array, usingsepas the delimiter.When no delimiter is provided, strings are split into an array of words, using whitespace as delimiter. Runs of whitespace are merged together (no empty words are produced). Therangemust be a forward range. The separator can be a value of the same type as the elements inrangeor it can be another forwardrange.Parameters:S sthe string to split by word if no separator is given Range rangethe range to split Separator sepa value of the same type as the elements of rangeor anotherisTerminator a predicate that splits the range when it returns true. Returns:An array containing the divided parts ofrange(or the words ofs).See Also:std.algorithm.iteration.splitter for a lazy version without allocating memory. std.regex.splitter for a version that splits using a regular expression defined separator.Examples:import std.uni : isWhite; writeln("Learning,D,is,fun".split(",")); // ["Learning", "D", "is", "fun"] writeln("Learning D is fun".split!isWhite); // ["Learning", "D", "is", "fun"] writeln("Learning D is fun".split(" D ")); // ["Learning", "is fun"]
Examples:string str = "Hello World!"; writeln(str.split); // ["Hello", "World!"] string str2 = "Hello\t\tWorld\t!"; writeln(str2.split); // ["Hello", "World", "!"]
Examples:writeln(split("hello world")); // ["hello", "world"] writeln(split("192.168.0.1", ".")); // ["192", "168", "0", "1"] auto a = split([1, 2, 3, 4, 5, 1, 2, 3, 4, 5], [2, 3]); writeln(a); // [[1], [4, 5, 1], [4, 5]]
- ElementEncodingType!(ElementType!RoR)[]
join(RoR, R)(RoRror, scope Rsep)
if (isInputRange!RoR && isInputRange!(Unqual!(ElementType!RoR)) && isInputRange!R && is(Unqual!(ElementType!(ElementType!RoR)) == Unqual!(ElementType!R)));
ElementEncodingType!(ElementType!RoR)[]join(RoR, E)(RoRror, scope Esep)
if (isInputRange!RoR && isInputRange!(Unqual!(ElementType!RoR)) && is(E : ElementType!(ElementType!RoR)));
ElementEncodingType!(ElementType!RoR)[]join(RoR)(RoRror)
if (isInputRange!RoR && isInputRange!(Unqual!(ElementType!RoR))); - Eagerly concatenates all of the ranges in
rortogether (with the GC) into one array usingsepas the separator if present.Parameters:RoR rorAn input range of input ranges R sepAn input range, or a single element, to join the ranges on Returns:An array of elementsSee Also:For a lazy version, see std.algorithm.iteration.joinerExamples:writeln(join(["hello", "silly", "world"], " ")); // "hello silly world" writeln(join(["hello", "silly", "world"])); // "hellosillyworld" writeln(join([[1, 2, 3], [4, 5]], [72, 73])); // [1, 2, 3, 72, 73, 4, 5] writeln(join([[1, 2, 3], [4, 5]])); // [1, 2, 3, 4, 5] const string[] arr = ["apple", "banana"]; writeln(arr.join(",")); // "apple,banana" writeln(arr.join()); // "applebanana"
- E[]
replace(E, R1, R2)(E[]subject, R1from, R2to)
if (isDynamicArray!(E[]) && isForwardRange!R1 && isForwardRange!R2 && (hasLength!R2 || isSomeString!R2)); - Replace occurrences of
fromwithtoinsubjectin a new array.Parameters:E[] subjectthe array to scan R1 fromthe item to replace R2 tothe item to replace all instances of fromwithReturns:A new array without changing the contents ofsubject, or the original array if no match is found.See Also:std.algorithm.iteration.substitute for a lazy replace.Examples:writeln("Hello Wörld".replace("o Wö", "o Wo")); // "Hello World" writeln("Hello Wörld".replace("l", "h")); // "Hehho Wörhd"
- void
replaceInto(E, Sink, R1, R2)(Sinksink, E[]subject, R1from, R2to)
if (isOutputRange!(Sink, E) && isDynamicArray!(E[]) && isForwardRange!R1 && isForwardRange!R2 && (hasLength!R2 || isSomeString!R2)); - Replace occurrences of
fromwithtoinsubjectand output the result intosink.Parameters:Sink sinkan output range E[] subjectthe array to scan R1 fromthe item to replace R2 tothe item to replace all instances of fromwithSee Also:std.algorithm.iteration.substitute for a lazy replace.Examples:auto arr = [1, 2, 3, 4, 5]; auto from = [2, 3]; auto to = [4, 6]; auto sink = appender!(int[])(); replaceInto(sink, arr, from, to); writeln(sink.data); // [1, 4, 6, 4, 5]
- T[]
replace(T, Range)(T[]subject, size_tfrom, size_tto, Rangestuff)
if (isInputRange!Range && (is(ElementType!Range : T) || isSomeString!(T[]) && is(ElementType!Range : dchar))); - Replaces elements from array with indices ranging from
from(inclusive) toto(exclusive) with the rangestuff.Parameters:T[] subjectthe array to scan size_t fromthe starting index size_t tothe ending index Range stuffthe items to replace in-between fromandtoReturns:A new array without changing the contents ofsubject.See Also:std.algorithm.iteration.substitute for a lazy replace.Examples:auto a = [ 1, 2, 3, 4 ]; auto b = a.replace(1, 3, [ 9, 9, 9 ]); writeln(a); // [1, 2, 3, 4] writeln(b); // [1, 9, 9, 9, 4]
- void
replaceInPlace(T, Range)(ref T[]array, size_tfrom, size_tto, Rangestuff)
if (is(typeof(replace(array,from,to,stuff)))); - Replaces elements from
arraywith indices ranging fromfrom(inclusive) toto(exclusive) with the rangestuff. Expands or shrinks the array as needed.Parameters:T[] arraythe array to scan size_t fromthe starting index size_t tothe ending index Range stuffthe items to replace in-between fromandtoExamples:int[] a = [1, 4, 5]; replaceInPlace(a, 1u, 2u, [2, 3, 4]); writeln(a); // [1, 2, 3, 4, 5] replaceInPlace(a, 1u, 2u, cast(int[])[]); writeln(a); // [1, 3, 4, 5] replaceInPlace(a, 1u, 3u, a[2 .. 4]); writeln(a); // [1, 4, 5, 5]
- E[]
replaceFirst(E, R1, R2)(E[]subject, R1from, R2to)
if (isDynamicArray!(E[]) && isForwardRange!R1 && is(typeof(appender!(E[])().put(from[0..1]))) && isForwardRange!R2 && is(typeof(appender!(E[])().put(to[0..1])))); - Replaces the first occurrence of
fromwithtoinsubject.Parameters:E[] subjectthe array to scan R1 fromthe item to replace R2 tothe item to replace fromwithReturns:A new array without changing the contents ofsubject, or the original array if no match is found.Examples:auto a = [1, 2, 2, 3, 4, 5]; auto b = a.replaceFirst([2], [1337]); writeln(b); // [1, 1337, 2, 3, 4, 5] auto s = "This is a foo foo list"; auto r = s.replaceFirst("foo", "silly"); writeln(r); // "This is a silly foo list"
- E[]
replaceLast(E, R1, R2)(E[]subject, R1from, R2to)
if (isDynamicArray!(E[]) && isForwardRange!R1 && is(typeof(appender!(E[])().put(from[0..1]))) && isForwardRange!R2 && is(typeof(appender!(E[])().put(to[0..1])))); - Replaces the last occurrence of
fromwithtoinsubject.Parameters:E[] subjectthe array to scan R1 fromthe item to replace R2 tothe item to replace fromwithReturns:A new array without changing the contents ofsubject, or the original array if no match is found.Examples:auto a = [1, 2, 2, 3, 4, 5]; auto b = a.replaceLast([2], [1337]); writeln(b); // [1, 2, 1337, 3, 4, 5] auto s = "This is a foo foo list"; auto r = s.replaceLast("foo", "silly"); writeln(r); // "This is a foo silly list"
- inout(T)[]
replaceSlice(T)(inout(T)[]s, in T[]slice, in T[]replacement); - Creates a new array such that the items in
sliceare replaced with the items inreplacement.sliceandreplacementdo not need to be the same length. The result will grow or shrink based on the items given.Parameters:inout(T)[] sthe base of the new array T[] slicethe slice of sto be replacedT[] replacementthe items to replace slicewithReturns:A new array that isswithslicereplaced byreplacement[].See Also:std.algorithm.iteration.substitute for a lazy replace.Examples:auto a = [1, 2, 3, 4, 5]; auto b = replaceSlice(a, a[1 .. 4], [0, 0, 0]); writeln(b); // [1, 0, 0, 0, 5]
- struct
Appender(A) if (isDynamicArray!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.
Appendermaintains its own array metadata locally, so it can avoid global locking for each append where capacity is non-zero.Parameters:A the array type to simulate. See Also:Examples:auto app = appender!string(); string b = "abcdefg"; foreach (char c; b) app.put(c); writeln(app.data); // "abcdefg" int[] a = [ 1, 2 ]; auto app2 = appender(a); app2.put(3); app2.put([ 4, 5, 6 ]); writeln(app2.data); // [1, 2, 3, 4, 5, 6]
- pure nothrow @trusted this(A
arr); - Constructs an Appender with a given array. Note that this does not copy the data. If the array has a larger capacity as determined by
arr.capacity, it will be used by the appender. After initializing an appender on an array, appending to the original array will reallocate. - pure nothrow @safe void
reserve(size_tnewCapacity); - Reserve at least newCapacity elements for appending. Note that more elements may be reserved than requested. If
newCapacity<= capacity, then nothing is done.Parameters:size_t newCapacitythe capacity the Appender should have - const pure nothrow @property @safe size_t
capacity(); - Returns:the capacity of the array (the maximum number of elements the managed array can accommodate before triggering a reallocation). If any appending will reallocate, 0 will be returned.
- inout pure nothrow @property @trusted inout(ElementEncodingType!A)[]
data(); - Returns:The managed array.
- void
put(U)(Uitem)
if (canPutItem!U); - Appends
itemto the managed array. Performs encoding for char types if A is a differently typed char array.Parameters:U itemthe single item to append - void
put(Range)(Rangeitems)
if (canPutRange!Range); - Appends an entire range to the managed array. Performs encoding for char elements if A is a differently typed char array.Parameters:
Range itemsthe range of items to append - void
opOpAssign(string op : "~", U)(Urhs)
if (__traits(compiles, put(rhs))); - Appends
rhsto the managed array.Parameters:op the assignment operator ~ U rhsElement or range. - pure nothrow @trusted void
clear(); - Clears the managed array. This allows the elements of the array to be reused for appending.
Note clear is disabled for immutable or const element types, due to the possibility that Appender might overwrite immutable data.
- pure @trusted void
shrinkTo(size_tnewlength); - Shrinks the managed array to the given length.Throws:Exception if newlength is greater than the current array length.
Note shrinkTo is disabled for immutable or const element types.
- const string
toString();
const voidtoString(Writer)(ref Writerw, ref const FormatSpec!charfmt)
if (isOutputRange!(Writer, char)); - Gives a string in the form of Appender!(A)(data).Parameters:
Writer wA char accepting output range. FormatSpec!char fmtA std.format.FormatSpec which controls how the array is formatted. Returns:A string if writer is not set; void otherwise.
- struct
RefAppender(A) if (isDynamicArray!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.
Tip Use the arrayPtr overload of appender for construction with type-inference.
Parameters:A The array type to simulate Examples:int[] a = [1, 2]; auto app2 = appender(&a); writeln(app2.data); // [1, 2] writeln(a); // [1, 2] app2 ~= 3; app2 ~= [4, 5, 6]; writeln(app2.data); // [1, 2, 3, 4, 5, 6] writeln(a); // [1, 2, 3, 4, 5, 6] app2.reserve(5); assert(app2.capacity >= 5);
- this(A*
arr); - Constructs a RefAppender with a given array reference. This does not copy the data. If the array has a larger capacity as determined by
arr.capacity, it will be used by the appender.Note Do not use built-in appending (i.e. ~=) on the original array until you are done with the appender, because subsequent calls to the appender will reallocate the array data without those appends.
Parameters:A* arrPointer to an array. Must not be null. - void
opDispatch(string fn, Args...)(Argsargs)
if (__traits(compiles, (Appender!A a) => mixin("a." ~ fn ~ "(args)"))); - Wraps remaining Appender methods such as put.Parameters:
fn Method name to call. Args argsArguments to pass to the method. - void
opOpAssign(string op : "~", U)(Urhs)
if (__traits(compiles, (Appender!A a) { a.put(rhs); } )); - Appends
rhsto the managed array.Parameters:U rhsElement or range. - const @property size_t
capacity(); - Returns the capacity of the array (the maximum number of elements the managed array can accommodate before triggering a reallocation). If any appending will reallocate,
capacityreturns 0. - inout @property inout(ElementEncodingType!A)[]
data(); - Returns the managed array.
- Appender!A
appender(A)()
if (isDynamicArray!A);
Appender!(E[])appender(A : E[], E)(auto ref Aarray); - Convenience function that returns an Appender instance, optionally initialized with
array.Examples:auto w = appender!string; // pre-allocate space for at least 10 elements (this avoids costly reallocations) w.reserve(10); assert(w.capacity >= 10); w.put('a'); // single elements w.put("bc"); // multiple elements // use the append syntax w ~= 'd'; w ~= "ef"; writeln(w.data); // "abcdef"
- RefAppender!(E[])
appender(P : E[]*, E)(ParrayPtr); - Convenience function that returns a RefAppender instance initialized with
arrayPtr. Don't use null for the array pointer, use the other version ofappenderinstead.Examples:int[] a = [1, 2]; auto app2 = appender(&a); writeln(app2.data); // [1, 2] writeln(a); // [1, 2] app2 ~= 3; app2 ~= [4, 5, 6]; writeln(app2.data); // [1, 2, 3, 4, 5, 6] writeln(a); // [1, 2, 3, 4, 5, 6] app2.reserve(5); assert(app2.capacity >= 5);
- T[n]
staticArray(T, size_t n)(auto ref T[n]a);
autostaticArray(size_t n, T)(scope Ta)
if (isInputRange!T);
autostaticArray(size_t n, T)(scope Ta, out size_trangeLength)
if (isInputRange!T);
autostaticArray(Un : U[n], U, size_t n, T)(scope Ta)
if (isInputRange!T && is(ElementType!T : U));
autostaticArray(Un : U[n], U, size_t n, T)(scope Ta, out size_trangeLength)
if (isInputRange!T && is(ElementType!T : U));
autostaticArray(alias a)()
if (isInputRange!(typeof(a)));
autostaticArray(U, alias a)()
if (isInputRange!(typeof(a))); - 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]. Whenais 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 rangeais 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) orstaticArray!(double, 2.iota)).Note
staticArrayreturns by value, so expressions involving large arrays may be inefficient.Parameters:T[n] aThe input elements. If there are less elements than the specified length of the static array, the rest of it is default-initialized. If there are more than specified, the first elements up to the specified length are used. size_t rangeLengthoutputs the number of elements used from ato it. Optional.Returns:A static array constructed froma.Examples:static array from array literalauto a = [0, 1].staticArray; static assert(is(typeof(a) == int[2])); writeln(a); // [0, 1]
Examples:static array from range + sizeimport std.range : iota; auto input = 3.iota; auto a = input.staticArray!2; static assert(is(typeof(a) == int[2])); writeln(a); // [0, 1] auto b = input.staticArray!(long[4]); static assert(is(typeof(b) == long[4])); writeln(b); // [0, 1, 2, 0]
Examples:static array from CT rangeimport std.range : iota; enum a = staticArray!(2.iota); static assert(is(typeof(a) == int[2])); writeln(a); // [0, 1] enum b = staticArray!(long, 2.iota); static assert(is(typeof(b) == long[2])); writeln(b); // [0, 1]