1
2
3
4
5
6
7
8
9
import std.stdio;
 
void main(){
    int result;
    func(150,200,result);
    writefln("%d",result);
}
 
void func(int param1,int param2,out int result){
 ...

1
2
3
4
5
6
7
8
9
var
i = real;
dipeso = real;
dopeso = real;
rpeso = real;
ypeso = real;
dinar = 113.897700;
dollar = 42.9110;
riyal = 11.448700;
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
void main()
{
    for(int i=0; i<8; i++)
      writefln("%s! = %s", i, factorial(i));
}
 
template factorial(T)
 ...

1
2
3
4
5
6
7
8
9
import std.stdio, std.concurrency;
 
void foo()
{
    bool cont = true;
 
    while (cont)
    {
        receive( // delegates are used to match the message type
 ...

1
2
3
4
5
6
7
8
9
import std.stdio, std.algorithm, std.range;
 
void main()
{
    immutable int[] a1 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
    immutable int[] a2 = [6, 7, 8, 9];
 
    // must be immutable to allow access from inside mySum
    immutable pivot = 5;
 ...

1
2
3
4
5
6
7
8
import std.stdio;
 
void main()
{
    /* Infinite loop, because the logical expression is always
     * true */
    while (true) {
        write("0:Exit, 1:Turkish, 2:English - Your choice? ");
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
void main()
{
    int number;
 
    while (number == 3) {
        write("Number? ");
        readf(" %s", &number);
 ...

1
2
3
4
5
6
7
 
#!/usr/bin/rdmd
import std.stdio;
void main()
{
    writeln("Hello, world with automated script running!");
}

1
2
3
4
5
6
7
8
9
% cat myprog.d
#!/usr/bin/rdmd
import std.stdio;
void main()
{
    writeln("Hello, world with automated script running!");
}
% ./myprog.d
Hello, world with automated script running!

1
2
3
4
5
6
7
8
import std.stdio;
void main(char[][] p_Args) 
{ 
 foreach(char[] l_Arg; p_Args)
 {
   writefln("Argument '%s'", l_Arg);
 }
}

1
2
3
4
5
6
7
8
9
import std.stdio;
 
void main()
{
    int number;
 
    while (number >= 0) {
        write("Please enter a number: ");
        readf(" %s", &number);
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
void main()
{
    int number;
 
    while (number >= 0) {
        write("Please enter a number: ");
        readf(" %s", &number);
 ...

1
2
3
4
5
6
7
8
9
import std.stdio, std.algorithm, std.range, std.string;
 
void main()
{
    dstring[][dstring] signs2words;
    foreach(dchar[] w; lines(File("words.txt")))
    {
        w = w.chomp().toLower();
        immutable key = w.dup.sort().release().idup;
 ...

1
2
3
4
5
6
7
import std.stdio: writefln;
 
void main(string[] args)
{
    foreach (i, arg; args)
        writefln("args[%d] = '%s'", i, arg);
}

1
2
3
4
5
6
7
8
9
// whileloop.d
// while..loop and do..while examples in D
// To Compile: C:\dmd\MKoD_ex>..\bin\dmd whileloop.d
private import std.stdio;
 
int main()
{
    int ix = 0;
    
 ...

1
2
3
4
5
6
import std.stdio;
 
void main(){
        writeln("やほ～");
        
}

1
2
3
4
void main(){
        std.stdio.writeln("やほ～");
        
}

1
2
3
4
5
6
import std.stdio;
 
void main(){
        auto val1 = 0,val2 = -9.2;
        writefln("%d,%f",val1,val2);
}

1
2
3
4
void main(){
        auto val1 = 0,val2 = -9.2;
        writefln("%d,%f",val1,val2);
}

1
2
3
4
5
import std.stdio;
 
void main(){
        writeln(typeof('u'w).stringof);
}

1
2
3
4
5
import std.stdio;
 
void main(){
        writeln(typeof('u').stringof);
}

1
2
3
4
5
import std.stdio;
 
void main(){
        writeln(('u').stringof);
}

1
2
3
4
5
import std.stdio;
 
void main(){
        writeln(('u'w).stringof);
}

1
2
3
4
5
6
import std.stdio;
 
void main()
{
    writeln("Hello, world!");
}

1
2
3
4
5
6
7
8
9
import std.stdio: writeln;
 
auto filter(alias pred, T)(T[] arr)
{
    T[] r; foreach (v; arr) if (pred(v)) r ~= v; return r;
}
 
void main()
{
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
class X
{
    int p_prop;
 
    @property auto x() { return P!(int, "p_prop")(this.p_prop, this); }
 
    struct P(T, string p)
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
class Foo
{
  int[string] vals;
 
  Foo opIndexAssign(int val, string key)
  {
    writefln("Got key %s", key);
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
pure Type[] Reversed(Type)(const lazy Type[] Source)
{
        if (Source.length <= 1) return Source;
        else
        {
                return Source[$-1] ~ Reversed(Source[0..$-1]);
        }
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
pure Type[] Reversed(Type)(const lazy Type[] Source)
{
        if (Source.length <= 1) return Source;
        else
        {
                return Source[$-1] ~ Reversed(Source[0..$-1]);
        }
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
class Foo
{
  int[string] vals;
 
  Foo opIndexAssign(int val, string key)
  {
    vals[key] = val;
 ...