Initial data commit

Task/Enforced-immutability/D/enforced-immutability.d

@@ -0,0 +1,67 @@
+import std.random;
+
+// enum allows to define manifest (compile-time) constants:
+int sqr(int x) { return x ^^ 2; }
+enum int x = 5;
+enum y = sqr(5); // Forces Compile-Time Function Evaluation (CTFE).
+
+// enums are compile-time constants:
+enum MyEnum { A, B, C }
+
+
+// immutable defines values that can't change:
+immutable double pi = 3.1415;
+
+
+// A module-level immutable storage class variable that's not
+// explicitly initialized can be initialized by its constructor,
+// otherwise its value is the default initializer during its life-time.
+
+immutable int z;
+
+static this() {
+    z = uniform(0, 100); // Run-time initialization.
+}
+
+class Test1 {
+    immutable int w;
+
+    this() {
+        w = uniform(0, 100); // Run-time initialization.
+    }
+}
+
+
+// The items array can't be immutable here.
+// "in" is short for "const scope":
+void foo(const scope int[] items) {
+    // items is constant here.
+    // items[0] = 100; // Cannot modify const expression.
+}
+
+
+struct Test2 {
+    int x_; // Mutable.
+    @property int x() { return this.x_; }
+}
+
+// Unlike C++, D const and immutable are transitive.
+// And there is also "inout". See D docs.
+
+void main() {
+    int[] data = [10, 20, 30];
+    foo(data);
+    data[0] = 100; // But data is mutable here.
+
+    // Currently manifest constants like arrays and associative arrays
+    // are copied in-place every time they are used:
+    enum array = [1, 2, 3];
+    foo(array);
+
+    auto t = Test2(100);
+    auto x2 = t.x; // Reading x is allowed.
+    assert(x2 == 100);
+
+    // Not allowed, the setter property is missing:
+    // t.x = 10; // Error: not a property t.x
+}