Data commit

Task/Call-a-function/D/call-a-function.d

@@ -0,0 +1,103 @@
+import std.traits;
+
+enum isSubroutine(alias F) = is(ReturnType!F == void);
+
+void main() {
+    void foo1() {}
+
+    // Calling a function that requires no arguments:
+    foo1();
+    foo1; // Alternative syntax.
+
+
+    void foo2(int x, int y) {}
+
+    immutable lambda = function int(int x) => x ^^ 2;
+
+    // Calling a function with a fixed number of arguments:
+    foo2(1, 2);
+    foo2(1, 2);
+    cast(void)lambda(1);
+
+
+    void foo3(int x, int y=2) {}
+
+    // Calling a function with optional arguments:
+    foo3(1);
+    foo3(1, 3);
+
+    int sum(int[] arr...) {
+        int tot = 0;
+        foreach (immutable x; arr)
+            tot += x;
+        return tot;
+    }
+
+    real sum2(Args...)(Args arr) {
+        typeof(return) tot = 0;
+        foreach (immutable x; arr)
+            tot += x;
+        return tot;
+    }
+
+    // Calling a function with a variable number of arguments:
+    assert(sum(1, 2, 3) == 6);
+    assert(sum(1, 2, 3, 4) == 10);
+    assert(sum2(1, 2.5, 3.5) == 7);
+
+    // Calling a function with named arguments:
+    // Various struct or tuple-based tricks can be used for this,
+    // but currently D doesn't have named arguments.
+
+
+    // Using a function in statement context (?):
+    if (1)
+        foo1;
+
+    // Using a function in first-class context within an expression:
+    assert(sum(1) == 1);
+
+
+    auto foo4() { return 1; }
+
+    // Obtaining the return value of a function:
+    immutable x = foo4;
+
+
+    // Distinguishing built-in functions and user-defined functions:
+    // There are no built-in functions, beside the operators, and
+    // pseudo-functions like assert().
+
+
+    int myFynction(int x) { return x; }
+    void mySubroutine(int x) {}
+
+    // Distinguishing subroutines and functions:
+    // (A subroutine is merely a function that has no explicit
+    // return statement and will return void).
+    pragma(msg, isSubroutine!mySubroutine); // Prints: true
+    pragma(msg, isSubroutine!myFynction);   // Prints: false
+
+
+    void foo5(int a, in int b, ref int c, out int d, lazy int e, scope int f) {}
+
+    // Stating whether arguments are passed by value, by reference, etc:
+    alias STC = ParameterStorageClass;
+    alias psct = ParameterStorageClassTuple!foo5;
+    static assert(psct.length == 6); // Six parameters.
+    static assert(psct[0] == STC.none);
+    static assert(psct[1] == STC.none);
+    static assert(psct[2] == STC.ref_);
+    static assert(psct[3] == STC.out_);
+    static assert(psct[4] == STC.lazy_);
+    static assert(psct[5] == STC.scope_);
+    // There are also inout and auto ref.
+
+
+    int foo6(int a, int b) { return a + b; }
+
+    // Is partial application possible and how:
+    import std.functional;
+    alias foo6b = partial!(foo6, 5);
+    assert(foo6b(6) == 11);
+}