[Riddick]

Il linguaggio di programmazione D, noto anche semplicemente come D, è un object-oriented, imperativo, multi-paradigma di linguaggio di programmazione di sistema progettato da Walter Bright della Digital Mars. E 'nato come un re-engineering di C + +, ma anche se è prevalentemente influenzato da quel linguaggio, non è una variante del C + +. D ha ridisegnato alcune caratteristiche di C + + ed è stato influenzato da concetti utilizzati in altri linguaggi di programmazione, come Java, Python, C #, e Eiffel.

Features

D è stato progettato con le lezioni apprese da C + + pratico di utilizzo, piuttosto che da un punto di vista teorico. Anche se molti usi C / C + + concetti scarta anche alcuni, e come tale non è compatibile con codice C / C + + di origine. Essa aggiunge alle funzionalità di C + + di progettazione anche l'attuazione in sede contrattuale, unit testing, moduli vero, raccolta dei rifiuti, le matrici di prima classe, array associativi, array dinamici, di matrice affettare, funzioni nidificate, le classi interne, chiusure, le funzioni anonime, compilare la funzione di tempo esecuzione, la valutazione pigra e ha una sintassi riprogettato modello. D mantiene C + + 's la capacità di fare a basso livello di codifica, e aggiunge ad essa con il supporto per un assembler inline integrato. C + + l'ereditarietà multipla, è sostituito dal eredità stile Java singola con interfacce e mixin. D's dichiarazione, la dichiarazione e la sintassi di espressione corrisponde molto a quello di C + +.

L'assembler inline caratterizza le differenze tra D e linguaggi applicativi come Java e C #. Un assembler inline consente ai programmatori di inserire codice assembly specifico per il computer all'interno di codice standard D-una tecnica spesso utilizzata dai programmatori di sistema per accedere alle funzioni di basso livello del processore necessario per eseguire i programmi che si interfacciano direttamente con l'hardware sottostante, come i sistemi operativi e driver di periferica.

D è dotato di supporto per i commenti di documentazione, che permette la generazione automatica della documentazione.

Programming paradigms

D supporta tre principali paradigmi di programmazione-imperativo, object-oriented, e metaprogrammazione.

D 2.0 aggiunge due paradigmi di programmazione - funzionale, concorrente (modello Actor).

Imperative

Programmazione imperativa in D è quasi identica a C. Funzioni, dati, dichiarazioni, dichiarazioni ed espressioni di lavoro proprio come in C, e la libreria di runtime C si può accedere direttamente. Alcune differenze notevoli tra D e C, nel settore della programmazione imperativa comprendono D's ciclo costrutto foreach, che permette di ciclare su un insieme e funzioni nidificate, che sono funzioni che vengono dichiarate all'interno di un altro e possono accedere alle variabili locali della funzione di inclusione.

Object oriented

Programmazione orientata agli oggetti in D si basa su una gerarchia di ereditarietà singola, con tutte le classi derivate dalla classe Object. D non supporta l'ereditarietà multipla, invece, utilizza interfacce Java-style, che sono paragonabili a C + + puro classi astratte e mixin, che consentono di separare le funzionalità comuni fuori della gerarchia di ereditarietà. Inoltre, D 2.0 consente di dichiarare metodi statici e finali (non virtuale) nelle interfacce.

Metaprogramming

Metaprogrammazione è supportato da una combinazione di modelli, di compilazione funzione il tempo di esecuzione, tuple e mixin stringa. I seguenti esempi illustrano alcune delle caratteristiche di D's in fase di compilazione.

Modelli in D può essere scritto in uno stile più funzione simile a quelli in C + +. Questa è una funzione regolare che calcola il fattoriale di un numero:

Codice:

ulong factorial(ulong n)
{
    if(n < 2)
        return 1;
    else
        return n * factorial(n - 1);
}

Qui, l'uso di statico se, D's in fase di compilazione condizionale costruire, è dimostrato di costruire un modello che esegue lo stesso calcolo utilizzando il codice che è simile a quella della funzione di cui sopra:

Codice:

template Factorial(ulong n)
{
    static if(n < 2)
        const Factorial = 1;
    else
        const Factorial = n * Factorial!(n - 1);
}

n i seguenti due esempi, il modello e la funzione di cui sopra sono utilizzati per calcolare fattoriali. Le tipologie di costanti non devono essere specificati in modo esplicito come il compilatore deduce i tipi dai lati destro di assegnazioni:

Codice:

const fact_7 = Factorial!(7);

Il modello std.metastrings.Format effettua dati printf come la formattazione, e la "msg" pragma visualizza il risultato al momento della compilazione:

Codice:

import std.metastrings;
pragma(msg, Format!("7! = %s", fact_7));
pragma(msg, Format!("9! = %s", fact_9));

Mixin String, combinata con la funzione di esecuzione in fase di compilazione, permettono la generazione di codice D utilizzando operazioni di stringa al momento della compilazione. Questo può essere usato per analizzare linguaggi specifici del dominio al codice D, che saranno compilati come parte del programma:

Codice:

import FooToD; // hypothetical module which contains a function that parses Foo source code
               // and returns equivalent D code
void main()
{
    mixin(fooToD(import("example.foo")));
}

Functional

D 2.0 only.

Codice:

import std.algorithm, std.range, std.stdio;

int main()
{
    int[] a1 = [0,1,2,3,4,5,6,7,8,9];
    int[] a2 = [6,7,8,9];
    immutable pivot = 5; // must be immutable to allow access from inside mysum

    int mysum(int a, int b) pure // pure function
    {
        if (b <= pivot) // ref to enclosing-scope
            return a + b;
        else
            return a;
    }

    auto result = reduce!(mysum)( chain(a1, a2) ); // passing a delegate (closure)
    writeln("Result: ", result); // output is "15"

    return 0;
}

Concurrent

D 2.0 only.

Codice:

import std.concurrency, std.stdio, std.typecons;

int main()
{
    auto tid = spawn(&foo); // create an actor object

    foreach(i; 0 .. 10)
        tid.send(i);    // send some integers
    tid.send(1.0f);     // send a float
    tid.send("hello");  // send a string
    tid.send(thisTid);  // send an object (Tid)

    receive( (int x) {  writeln("Main thread receives message: ", x);  });

    return 0;
}

void foo()
{
    bool cont = true;

    while (cont)
    {
        receive(  // pattern matching
            (int msg)        { writeln("int receive: ", msg); },  // int type
            (Tid sender){ cont = false; sender.send(-1); },  // object type
            (Variant v)       { writeln("huh?"); }  // any type
        );
    }
}

Memory management

La memoria è generalmente gestita con garbage collection, ma determinati oggetti possono essere completate entro immediatamente quando vanno fuori del campo di applicazione. Gestione della memoria esplicita è possibile utilizzare gli operatori di overload new e delete, e semplicemente chiamando C malloc e free direttamente. Garbage Collection può essere controllato: i programmatori possono aggiungere ed escludere gli intervalli di memoria da essere osservato dal collettore, può disabilitare e abilitare il collezionista e forzare una generazionale o di un ciclo completo di raccolta [3]. Il manuale offre molti esempi di come implementare diversi regimi altamente ottimizzato la gestione della memoria per quando è inadeguata raccolta dei rifiuti in un programma.

Interaction with other systems

Interfaccia binaria C (ABI) è supportato oltre che di tutti i tipi fondamentali e derivate di C, che consente l'accesso diretto al codice esistente C e le librerie. Libreria standard C fa parte della serie D. Senza spazi dei nomi molto esplicito può essere un po 'disordinato di accesso, in quanto è diffuso in tutto il modulo D che ne fanno uso: ma la biblioteca puro D standard è solitamente sufficiente, a meno di interfacciamento con il codice C.

C + + 's ABI non è pienamente supportato, anche se D possono accedere a codice C + + che viene scritto l'ABI C. Il parser D comprende uno extern (C + +) convenzione di chiamata per il collegamento limitata a oggetti C + +, ma è implementato solo in D 2.0.

Su Microsoft Windows, D può accedere a COM (Component Object Model) del codice.

Fonte: Wikipedia
Traduttore: by Google

[steve]

Da quello che ho visto sembra molto completo, anche se ho letto che le librerie e il compilatore non sono ancora all'altezza dei concorrenti.

Tuttavia non appare nella classifica dei 20 più usati (dove leggo persino linguaggi tipo nxt-g oppure rpg os/400) e cercando online non si trovano guide (solo piccoli tutorial e pochissimi libri cartacei).

[Chicowolf]

Il D è ancora in sviluppo ed è il successore del c++.
Sarà compatibile con i 128bit.

[steve]

Si propone come successore di c++, ma è tutto da vedere.

Per adesso è alla versione 2.0 (dopo 11 anni che è uscito) e non lo usa praticamente nessuno, supporta la libreria standard del c ma non quella del c++.
Le speranze sono buone, speriamo si evolva bene...