std.array.static_array

Author: timotheecour

std/array.d

@@ -3891,3 +3891,231 @@ unittest
     assert(appS.data == "hellow");
     assert(appA.data == "hellow");
 }
+
+version(all)
+{
+
+import std.traits : CommonType, Unqual, isStaticArray;
+import std.conv : emplaceRef;
+
+// @nogc: https://issues.dlang.org/show_bug.cgi?id=18439
+//nothrow @safe pure:
+nothrow:
+@safe:
+pure:
+
+/++
+Returns a static array constructed from `a`. The type of elements can be
+specified implicitly (`int[2] a = staticArray(1,2);`) or explicitly
+(`float[2] a = staticArray!float(1,2)`).
+D20180214T203015: The result is an rvalue, therefore uses like
+`foo(staticArray(1, 2, 3))` may be inefficient because of the copies.
++/
+// D20180214T185602: Workaround https://issues.dlang.org/show_bug.cgi?id=16779 (make alias to staticArray once fixed)
+pragma(inline, true) U[T.length] staticArray(U = CommonType!T, T...)(T a) @nogc
+{
+    return [a];
+}
+
+/// ditto
+pragma(inline, true) U[T.length] staticArrayCast(U, T...)(T a) @nogc
+{
+    enum n = T.length;
+    U[n] ret = void;
+    static foreach (i; 0 .. n)
+    {
+        // TODO: If any of these throws, the destructors of the already-constructed elements is not called. https://github.com/dlang/phobos/pull/4936/files#r131709329
+        emplaceRef!U(ret[i], cast(U) a[i]);
+    }
+    return ret;
+}
+
+///
+@safe unittest
+{
+    int val = 3;
+    staticArray(1, 2, val).assertSame!int([1, 2, 3]);
+    staticArray(1, 2.0).assertSame!double([1, 2.0]);
+    assert(!__traits(compiles, staticArray(1, "")));
+    staticArray().assertSame!void([]);
+    staticArray!float(1, 2).assertSame!float([1, 2]);
+    // see D20180214T185602
+    // auto a = staticArray!byte(1, 2);
+    staticArrayCast!byte(1, 2).assertSame!byte([1, 2]);
+    staticArrayCast!byte(1, 129).assertSame!byte([1, -127]);
+
+    staticArrayCast!(const(int))(1, 2).assertSame!(const(int))([1, 2]);
+    staticArrayCast!(immutable(int))(1, 2).assertSame!(immutable(int))([1, 2]);
+    staticArray([1]).assertSame!(int[])([[1]]);
+    version (Bug)
+    {
+        // NOTE: correctly issues a deprecation
+        int[] a2 = staticArray(1, 2);
+    }
+}
+
+/++
+Returns a static array constructed from `arr`. The type of elements can be
+specified implicitly (`int[2] a = [1,2].asStatic;`) or explicitly
+(`float[2] a = [1,2].asStaticCast!float`).
+See also D20180214T203015.
++/
+pragma(inline, true) T[n] asStatic(T, size_t n)(auto ref T[n] arr) @nogc
+{
+    return arr;
+}
+
+/// ditto
+U[n] asStaticCast(U, T, size_t n)(auto ref T[n] arr) @nogc
+{
+    U[n] ret = void;
+    static foreach (i; 0 .. n)
+    {
+        emplaceRef!U(ret[i], cast(U) arr[i]);
+    }
+    return ret;
+}
+
+///
+@safe unittest
+{
+    int val = 3;
+    static immutable gold = [1, 2, 3];
+    [1, 2, val].asStatic.assertSame!int([1, 2, 3]);
+
+    @nogc void checkNogc()
+    {
+        [1, 2, val].asStatic.assertSame!int(gold);
+    }
+
+    [1, 2, val].asStaticCast!double.assertSame!double(gold);
+    [1, 2, 3].asStaticCast!int.assertSame!int(gold);
+
+    [1, 2, 3].asStaticCast!(const(int)).assertSame!(const(int))(gold);
+    [1, 2, 3].asStaticCast!(const(double)).assertSame!(const(double))(gold);
+    {
+        const(int)[3] a2 = [1, 2, 3].asStatic;
+    }
+
+    [1, 129].asStaticCast!byte.assertSame!byte([1, -127]);
+
+    version (Bug)
+    {
+        // https://issues.dlang.org/show_bug.cgi?id=16779
+        auto a2 = [1, 2, 3].asStatic!byte;
+        auto a3 = [1, 2, 3].asStatic!ubyte;
+
+        // NOTE: correctly issues a deprecation
+        int[] a2 = [1, 2].asStatic;
+    }
+}
+
+/// ditto but with an range
+auto asStatic(size_t n, T)(T a) @nogc
+{
+    // TODO: ElementType vs ForeachType
+    alias U = typeof(a[0]);
+    U[n] ret = void;
+    size_t i;
+    foreach (ref ai; a)
+    {
+        emplaceRef!U(ret[i++], ai);
+    }
+    assert(i == n);
+    return ret;
+}
+
+/// ditto
+auto asStaticCast(Un : U[n], U, size_t n, T)(T a) @nogc
+{
+    U[n] ret = void;
+    size_t i;
+    foreach (ref ai; a)
+    {
+        emplaceRef!U(ret[i++], cast(U) ai);
+    }
+    assert(i == n);
+    return ret;
+}
+
+///
+@safe unittest
+{
+    import std.range;
+
+    2.iota.asStatic!2.assertSame!int([0, 1]);
+    2.iota.asStaticCast!(double[2]).assertSame!double([0, 1]);
+    2.iota.asStaticCast!(byte[2]).assertSame!byte([0, 1]);
+}
+
+///
+@system unittest
+{
+    import std.range;
+
+    assert(isThrown!Error(2.iota.asStatic!1));
+    assert(isThrown!Error(2.iota.asStatic!3));
+}
+
+/// ditto but with an alias
+auto asStatic(alias arr)() @nogc
+{
+    enum n = arr.length;
+    alias U = typeof(arr[0]);
+    U[n] ret = void;
+    static foreach (i; 0 .. n)
+    {
+        emplaceRef!U(ret[i], arr[i]);
+    }
+    return ret;
+}
+
+/// ditto
+auto asStaticCast(U, alias arr)() @nogc
+{
+    enum n = arr.length;
+    U[n] ret = void;
+    static foreach (i; 0 .. n)
+    {
+        emplaceRef!U(ret[i], cast(U) arr[i]);
+    }
+    return ret;
+}
+
+///
+@safe unittest
+{
+    import std.range;
+
+    enum a = asStatic!(2.iota);
+    asStatic!(2.iota).assertSame!int([0, 1]);
+    asStaticCast!(double, 2.iota).assertSame!double([0, 1]);
+    asStaticCast!(byte, 2.iota).assertSame!byte([0, 1]);
+}
+
+// Note: can't use `version (unittest)` because of https://issues.dlang.org/show_bug.cgi?id=18488
+void assertSame(T, T1, T2)(T1 a, T2 b) @nogc
+{
+    assert(is(T1 == T[T1.length]));
+    assert(a == b);
+}
+
+// TODO: add this to assertThrown in std.exception
+bool isThrown(T : Throwable = Exception, E)(lazy E expression) @system
+{
+    try
+    {
+        expression();
+        return false;
+    }
+    catch (T)
+    {
+        return true;
+    }
+    catch (Exception)
+    {
+        return false;
+    }
+}
+
+}