Anonymous user
Call a function: Difference between revisions
+ D entry
(+ D entry) |
|||
Line 314:
add2 1 #=> 3
</lang>
=={{header|D}}==
<lang d>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);
}</lang>
{{out}}
<pre>true
false</pre>
=={{header|Déjà Vu}}==
| |||