ഡി (പ്രോഗ്രാമിങ് ഭാഷ)

ഡിജിറ്റൽ മാർസിന്റെ വാൾട്ടർ ബ്രൈറ്റ് സൃഷ്ടിച്ച ഒരു ഒബ്ജക്റ്റ് ഓറിയെന്റഡ്, ഇംപരേറ്റീവ്, മൾട്ടി പരാഡിഗം സിസ്റ്റം പ്രോഗ്രാമിങ് ഭാഷയാണ് **ഡി**. 2001 ൽ ആന്ദ്രെ അലക്സാണ്ട്രെസ്സ്കു ബ്രൈറ്റ് ഡിസൈൻ ആന്റ് ഡെവലപ്മെന്റ് പ്രയത്നത്തിലും അംഗമായി. സി++ ന്റെ റീ-എഞ്ചിനിയറിംഗ് ആയിരുന്നെങ്കിലും, ഡി വ്യത്യസ്ത ഭാഷയാണ്, ചില പ്രധാന സി++ സവിശേഷതകൾ പുനർരൂപകൽപ്പന ചെയ്തപ്പോൾ മറ്റ് ഭാഷകൾ, പ്രത്യേകിച്ച് ജാവ, പൈത്തൺ, റൂബി, സി#, ഇഫിൽ എന്നിവയിൽ നിന്നുള്ള സവിശേഷതകൾ പങ്കുവെക്കുകയുണ്ടായി.

ആധുനിക ഡൈനാമിക് ഭാഷകളുടെ പ്രകടശേഷി ശക്തി ഉപയോഗിച്ച് കംപൈൽ ചെയ്ത ഭാഷകളുടെ പ്രകടനവും സുരക്ഷയും സമന്വയിപ്പിക്കാൻ ഡി ഡിസൈനിന്റെ ലക്ഷ്യങ്ങൾ ശ്രമിക്കുന്നു. ഐഡമിക്ക് ഡി കോഡ് സാധാരണയായുള്ള സി ++ കോഡാണ്, അത് ചെറിയതും മെമ്മറി സുരക്ഷിതവുമാണെങ്കിലും.

സാധാരണ തരത്തിലുള്ള ടൈപ്പുചെയ്യൽ അനുവാദം, ഓട്ടോമാറ്റിക് മെമ്മറി മാനേജ്മെന്റ്, സിന്തറ്റിക് ഷുഗർ എന്നിവ വേഗതയുള്ള വികസനം അനുവദിക്കുന്നു, ബൗണ്ട് പരിശോധിക്കുന്നു, കരാറിന്റെ സവിശേഷതകൾ രൂപകൽപ്പനയും ഒരു കൺകറൻസി-അവേയർ ടൈപ്പ് സിസ്റ്റം പിന്തുണയും ബഗ്ഗുകൾ ഉണ്ടാകുന്നതിനെ കുറയ്ക്കുന്നു.
## സവിശേഷതകൾ
പൂർണ്ണമായും സൈദ്ധാന്തിക കാഴ്ചപ്പാടിനേക്കാൾ പ്രായോഗിക സി++ ഉപയോഗത്തിൽ നിന്ന് പഠിച്ചിട്ടുള്ള പാഠങ്ങളാണ് ഡി രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്. പല സി, സി++ ആശയങ്ങളും ഇത് ഉപയോഗിക്കുന്നുണ്ടെങ്കിലും ഇത് സി, സി++ സോഴ്സ് കോഡുകളുമായി പൊരുത്തപ്പെടാത്തതാണ്. എന്നിരുന്നാലും, ഡി  ഭരണനിർവഹണത്തിൽ ഡിസൈൻ നിയന്ത്രണം ഉണ്ടായിരുന്നു, സിയിലും ഡിയിലും നിയമാനുസൃതമുള്ള ഏതൊരു കോഡും ഒരേ രീതിയിൽ പ്രവർത്തിക്കണം. സി++ ന് മുമ്പ് ചില സവിശേഷതകൾ നേടി, ഉദാഹരണത്തിന് ക്ലോസ്സേഴ്സ്, അജ്ഞാതമായ പ്രവർത്തനങ്ങൾ, സമയ ഫംഗ്ഷൻ നിർവ്വഹണം സമാഹരിക്കുക. ഡി  കൺട്രോളർ, യൂണിറ്റ് ടെസ്റ്റിംഗ്, ട്രബിൾ മോഡ്യൂൾസ്, ഗാർബേജ് കളക്ഷൻ, ഫസ്റ്റ് ക്ലാസ് അറേസ്, അസോസിയേറ്റ് അറേസ്, ഡൈനാമിക് അറേസ്, അറേ സ്ടൈനിങ്, നെസ്റ്റഡ് ഫംഗ്ഷൻസ്, അലസ മൂല്യനിർണ്ണയം, റീ-എൻജിനീയറിംഗ് ചെയ്ത ടെംപ്ലേറ്റ് സിന്റാക്സ് എന്നിവ ഡിസൈൻ ചെയ്തുകൊണ്ട് സി++ ന്റെ പ്രവർത്തനക്ഷമതയെ കൂട്ടിച്ചേർക്കുന്നു. ഡി നിമ്ന തലത്തിലുള്ള കോഡിംഗ് നടത്തുകയും ഇൻലൈൻ അസംബ്ലർ ചേർക്കാനും ഉള്ള സി++ ന്റെ ശേഷി നിലനിർത്തുന്നു. സി++ ന്റെ അനവധി പാരാമീറ്ററുകൾ ജാവാ ശൈലി ഒറ്റ പൈതൃകം ഉപയോഗിച്ച് ഇൻറർഫേസുകളും മിക്സൈനുമൊക്കെയായി മാറ്റുന്നു. മറുവശത്ത്, ഡി പ്രഖ്യാപനം, സ്റ്റേറ്റ്മെന്റ് ആൻഡ് എക്സ്പ്രഷൻ സിന്റാക്സ് സി++ നോട് ഏറ്റവും യോജിക്കുന്നവയാണ്.

ഡി, ആപ്ലിക്കേഷൻ ഭാഷകളായ ജാവയും സി# ഉം തമ്മിലുള്ള വ്യത്യാസങ്ങൾ ഇൻലൈൻ അസ്സംമ്പ്ലർ സൂചിപ്പിക്കുന്നു. ഇൻലൈൻ അസ്സംബിൾ പ്രോഗ്രാമർമാർക്ക് മെഷീൻ നിർദ്ദിഷ്ട അസ്സംബിളി കോഡ് സാധാരണ ഡി കോഡിനുള്ളിൽ നൽകാം. ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങൾ, ഡിവൈസ് ഡ്രൈവറുകൾ എന്നിവയിൽ നേരിട്ട് ഹാർഡ്വെയറിനൊപ്പം ഇന്റർഫേസ് പ്രോഗ്രാമുകൾ പ്രവർത്തിപ്പിക്കാൻ ആവശ്യമായ പ്രോസസ്സറിന്റെ നിമ്ന തലത്തിലുള്ള സവിശേഷതകളെ കണ്ടെത്താൻ സിസ്റ്റം പ്രോഗ്രാമർമാർ ഇത് ഉപയോഗിക്കുന്നു.

ഡിയുടെ ഡോക്യുമെന്റേഷൻ അഭിപ്രായങ്ങൾക്ക് ബിൽറ്റ്-ഇൻ പിന്തുണ ഉണ്ട്, യാന്ത്രിക ഡോക്യുമെന്റേഷൻ ജനറേഷൻ അനുവദിക്കുന്നു.
## പ്രോഗ്രാമിങ് മാതൃകകൾ
ഡി പ്രധാനപ്പെട്ട അഞ്ച് പ്രോഗ്രാമിങ് ഉദാഹരണങ്ങൾ പിന്തുണയ്ക്കുന്നു: ഇംപെറേറ്റീവ്, ഒബജ്ക്ട് ഓറിയെന്റഡ്, മെറ്റാപ്രോഗ്രാമിംഗ്, ഫങ്ഷണൽ ആൻഡ് കൺകറണ്ട് (ആക്ടർ മോഡൽ).
### ഇംപെറേറ്റീവ്
ഡിയിലെ സമൂലമായ പ്രോഗ്രാമിങ്ങ് സി ഫംഗ്ഷനുകൾക്ക് സമാനമായിരിക്കണം, ഡാറ്റ, സ്റ്റേറ്റ്മെന്റുകൾ, ഡിക്ലറേഷനുകൾ, എക്സ്പ്രഷനുകൾ സി യിൽ തന്നെ പ്രവർത്തിക്കുന്നു, കൂടാതെ സി റൺടൈം ലൈബ്രറിയും നേരിട്ട് ആക്സസ് ചെയ്യാം. മറുവശത്ത്, ഇംപെറേറ്റീവ് പ്രോഗ്രാമിങ് മേഖലയിൽ ഡിയും സിയും തമ്മിലുള്ള ചില ശ്രദ്ധേയമായ വ്യത്യാസങ്ങൾ ഡിയുടെ `foreach` ലൂപ് നിർമ്മാണം, ഒരു ശേഖരത്തിൽ നിന്ന് ലൂപ്പിംഗ് അനുവദിക്കുന്നു, കൂടാതെ നെസ്റ്റഡ് ഫംഗ്ഷനുകൾ എന്നിവയെല്ലാം ഇതിൽ മറ്റൊരിടത്ത് പ്രഖ്യാപിക്കപ്പെടുന്നു, ഒപ്പം എൻക്ലോസ്സിംഗ് ഫംഗ്ഷന്റെ പ്രാദേശിക വേരിയബിളുകളിൽ പ്രവേശിക്കുവാൻ സാധിക്കുകയും ചെയ്യുന്നു.
### ഒബ്ജക്റ്റ് ഓറിയെന്റഡ്
ഡിയിലെ ഒബ്ജക്റ്റ് ഓറിയെന്റഡ് പ്രോഗ്രാമിങ് ഒരു ഇൻഹെറിറ്റൻസ് ശ്രേണിയെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്, ക്ലാസ് ഒബ്ജക്റ്റിൽ നിന്നാണ് എല്ലാ ക്ലാസുകളും ശേഖരിക്കന്നത്. മൾട്ടിപ്പിൾ ഇൻഹെറിറ്റൻസിനെ പിന്തുണയ്ക്കുന്നില്ല; പകരം ഇത് ജാവാ ശൈലിയിലുള്ള ഇൻറർഫേസുകളാണ് ഉപയോഗിക്കുന്നത്, സി++ ന്റെ ശുദ്ധമായ അബ്സ്ട്രാക്റ്റ് ക്ലാസുകളുമായും മിക്സിൻസുകളുമായും ഇത് താരതമ്യപ്പെടുത്തിയിട്ടുണ്ട്, അത് പാരമ്പര്യ ശ്രേണിയിലെ സാധാരണ പ്രവർത്തനത്തെ വേർതിരിക്കുന്നു. ഡി ഫങ്ഷനുകൾക്കും സ്റ്റാറ്റിക് ഫൈനൽ (നോൺ-വിർച്ച്വൽ) രീതികൾ ഇൻറർഫെയിസുകളിൽ അനുവദിക്കുന്നു.
### മെറ്റാപ്രോഗ്രാമിങ്ങ്
മെറ്റാപ്രോഗ്രാമിങ്ങ് ടെംപ്ലേറ്റുകളുടെ കൂട്ടത്തെ പിന്തുണക്കുന്നു, കംപൈൽ ടൈം ഫങ്ഷൻ എക്സിക്യൂഷൻ, ട്യൂപ്പ്സ്, സ്ട്രിംഗ് മിക്സിൻസ് എന്നിവ തയ്യാറാക്കാൻ സഹായിക്കുന്നു. ഇനിപ്പറയുന്ന ഉദാഹരണങ്ങൾ ഡി ന്റെ കംപൈൽ ടൈം ഫീച്ചറുകൾ കാണിക്കുന്നു.
ടെംപ്ലേറ്റുകളിൽ സി++ ഫങ്ഷണൽ ശൈലിയുമായി താരതമ്യം ചെയ്യുമ്പോൾ ഡി ഉള്ളിലെ ടെംപ്ലേറ്റുകൾ കൂടുതൽ ഇംപെറേറ്റീവ് ശൈലിയിൽ എഴുതാം. ഒരു സംഖ്യയുടെ ഫാക്റ്റോറിയൽ കണക്കാക്കുന്ന ഒരു സാധാരണ പ്രവർത്തനമാണ് ഇത്:

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

ഇവിടെ, `static if` ഉപയോഗിക്കുന്നത്, ഡിയുടെ കംപൈൽ സമയത്തെ സോപാധികമായ നിർമ്മിതി, മുകളിൽ പറഞ്ഞ ഫംഗ്ഷനു സമാനമായ കോഡ് ഉപയോഗിക്കുന്ന അതേ കണക്കുകൂട്ടൽ നടത്തുന്ന ഒരു ടെംപ്ലേറ്റ് നിർമ്മിക്കാൻ പ്രദർശിപ്പിച്ചിരിക്കുന്നു:

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

താഴെപ്പറയുന്ന രണ്ട് ഉദാഹരണങ്ങളിൽ, നിർവചിക്കപ്പെട്ടിട്ടുള്ള ടെംപ്ലേറ്റും ഫംഗ്ഷനും ഫാക്റ്റോറിയലുകൾ കണക്കുകൂട്ടാൻ ഉപയോഗിക്കുന്നു. അസൈൻമെൻറുകളുടെ വലതുവശങ്ങളിൽ നിന്ന് കമ്പൈലർ അവരുടെ തരങ്ങളെ ഇൻഫർ ചെയ്ത പോലെ കോൺസ്റ്റൻറുകളുടെ തനിപ്പകർപ്പുകൾ വ്യക്തമായി നൽകണമെന്നില്ല.

```d
enum fact_7 = Factorial!(7);
```

ടൈം ഫങ്ഷൻ എക്സിക്യൂഷൻ കംപൈൽ ചെയ്യുന്നതിനുള്ള ഒരു ഉദാഹരണമാണിത്. ഓർഡിനറി ഫംഗ്ഷനുകൾ ചില മാനദണ്ഡങ്ങൾ പാലിക്കുന്ന സ്ഥിരമായ, കമ്പൈൽ-ടൈം എക്സ്പ്രഷനുകളിൽ ഉപയോഗിക്കാം:

```d
enum fact_9 = factorial(9);
```

`Std.string.format` ഫംഗ്ഷൻ `printf` പോലുള്ള ഡേറ്റാ ഫോർമാറ്റിങ് (കംപൈൽ ടൈം, CTFE വഴി), "msg" പ്രഗ്മ കംപൈൽ സമയത്തുള്ള ഫലങ്ങൾ പ്രദർശിപ്പിക്കും:

```d
import std.string : format;
pragma(msg, format("7! = %s", fact_7));
pragma(msg, format("9! = %s", fact_9));
```

കംപൈൽ ടൈം ഫംഗ്ഷൻ എക്സിക്യൂഷൻ സംയോജിപ്പിച്ച സ്ട്രിംഗ് മിക്സിൻസ്, കംപൈൽ സമയത്തെ സ്ട്രിംഗ് പ്രവർത്തനങ്ങൾ ഉപയോഗിച്ച് ഡി കോഡ് സൃഷ്ടിക്കുന്നത് അനുവദിക്കുന്നു. പ്രോഗ്രാമിന്റെ ഭാഗമായി ഡി-കോഡ് ചെയ്യുന്നതിന് ഡൊമെയ്ൻ-നിർദ്ദിഷ്ട ഭാഷകൾ പാഴ്സ് ചെയ്യുന്നതിന് ഇത് ഉപയോഗിക്കാം:

```d
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")));
}
```

## നിർവ്വഹണപരം
ഫങ്ഷണൽ ലിറ്ററൽ, അടച്ചുപൂട്ടലുകൾ, പുനർക്രമീകരണം-സ്ഥായിയായ വസ്തുക്കൾ, കൂടാതെ ഉയർന്ന-ഓർഡർ ഫംഗ്ഷനുകളുടെ ഉപയോഗം എന്നിവ പോലുള്ള ഫങ്ഷണൽ പ്രോഗ്രാമിങ് സവിശേഷതകൾ ഡി പിന്തുണയ്ക്കുന്നു. അജ്ഞാത പ്രവർത്തനങ്ങക്കായി രണ്ട് വാക്യഘടനകൾ ഉണ്ട്, അവയിൽ ഒന്നിലധികം പ്രസ്താവനകൾക്കും "ഷോർട്ട്ഹാൻഡ്" സിംഗിൾ എക്സ്പ്രഷൻ നോട്ടേഷൻ ഉപയോഗിക്കുന്നു: 


```d
int function(int) g;
g = (x) { return x * x; }; // longhand
g = (x) => x * x;          // shorthand
```

ഫങ്ഷൻ ലിറ്ററുകൾക്കും ഫങ്ഷനുകൾക്കുമായി രണ്ട് ബിൽറ്റ്-ഇൻ `function`ഉണ്ട്. സ്റ്റാക്കിനെ-അനുവദിച്ച ഫങ്ഷൻ  പോയിന്റെ ചുരുക്കമായിരിക്കും ഇത്. ചുറ്റുപാടുമുള്ള  പോയിന്റ് ഉൾപ്പെടുന്ന `delegate` ഒരു അജ്ഞാത ഫംഗ്ഷനൊപ്പം ടൈപ്പുചെയ്യൽ അനുമാനങ്ങൾ ഉപയോഗിക്കാം, അങ്ങനെയെങ്കിൽ ഒരു പരിസ്ഥിതി സൂചിക ആവശ്യമില്ലെന്ന് തെളിയിക്കുന്നില്ലെങ്കിൽ കമ്പൈലർ ഒരു `delegate`സൃഷ്ടിക്കുന്നു. അതുപോലെ തന്നെ, ഒരു സമാരംഭിക്കൽ നടപ്പാക്കാൻ, കമ്പൈലർ ആവശ്യമായ സ്ഥലത്ത് മാത്രം പ്രാദേശിക വേരിയബിളുകൾ ഉൾക്കൊള്ളുന്നു (ഉദാഹരണത്തിന്, ഒരു പ്രവർത്തനം മറ്റൊരു ഫംഗ്ഷൻ ഉപയോഗിച്ച് തിരികെ വരികയാണെങ്കിൽ, ഫങ്ഷൻ സ്കോപ്പ് അവസാനിക്കുന്നു). ടൈപ്പുചെയ്യൽ അനുമാനങ്ങൾ ഉപയോഗിക്കുമ്പോൾ, അത് തെളിയിക്കാനാഗ്രഹിക്കുന്നെങ്കിൽ, ഒരു ഫംഗ്ഷന്റെ തരത്തിലേക്ക് `pure` `nothrow`ആട്രിബ്യൂട്ടുകൾ കൂടി കമ്പൈലർ ചേർക്കും.

കറക്കിങ്, മാപ്പുകൾ, ഫിൽറ്റർ, കുറയ്ക്കുക തുടങ്ങിയ സാധാരണ പ്രവർത്തനങ്ങളായ സ്റ്റാൻഡേർഡ് ലൈബ്രറി മൊഡ്യൂളുകൾ `std.functional` ,`std.galgorith` മുഖേനയുള്ള മറ്റ് പ്രവർത്തന ഫീച്ചറുകൾ ലഭ്യമാണ്.

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

void main()
{
    int[] a1 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
    int[] a2 = [6, 7, 8, 9];

    // must be immutable to allow access from inside a pure function
    immutable pivot = 5;

    int mySum(int a, int b) pure nothrow // pure function
    {
        if (b <= pivot) // ref to enclosing-scope
            return a + b;
        else
            return a;
    }
   
    // passing a delegate (closure)
    auto result = reduce!mySum(chain(a1, a2));
    writeln("Result: ", result); // Result: 15

    // passing a delegate literal
    result = reduce!((a, b) => (b <= pivot) ? a + b : a)(chain(a1, a2));
    writeln("Result: ", result); // Result: 15
}
```

കൂടാതെ, മുകളിൽ പറഞ്ഞ പ്രവർത്തന രചനകൾ യൂണിഫോം ഫംഗ്ഷൻ കോൾ സിന്റാക്സ് (UFCS) ഉപയോഗിച്ച് കൂടുതൽ സ്വാഭാവിക ഇടത്തു നിന്നും വലത്തേക്കുള്ള വായനയ്ക്കായി ഉപയോഗിക്കാം.

```d
auto result = a1.chain(a2).reduce!mySum();
    writeln("Result: ", result);

    result = a1.chain(a2).reduce!((a, b) => (b <= pivot) ? a + b : a)();
    writeln("Result: ", result);
```

## സമാന്തരം

```d
import std.stdio : writeln;
import std.range : iota;
import std.parallelism : parallel;

void main()
{
    foreach (i; iota(11).parallel) {
        // The body of the foreach loop is executed in parallel for each i
        writeln("processing ", i);
    }
}
```

## സമകാലവർത്തിത്വം

```d
import std.stdio, std.concurrency, std.variant;

void foo()
{
    bool cont = true;

    while (cont)
    {
        receive( // delegates are used to match the message type
            (int msg) => writeln("int received: ", msg),
            (Tid sender) { cont = false; sender.send(-1); },
            (Variant v) => writeln("huh?") // Variant matches any type
        );
    }
}

void main()
{
    auto tid = spawn(&foo); // spawn a new thread running foo()

    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 a struct (Tid)

    receive((int x) => writeln("Main thread received message: ", x));
}
```

## മെമ്മറി മാനേജ്മെന്റ്
മെമ്മറി സാധാരണയായി ഗാർബ്ബേജ് ശേഖരത്തിൽ സൂക്ഷിച്ചുവച്ചിട്ടുണ്ട്, പക്ഷേ അവയിൽ നിന്നും പുറത്തുകടക്കുമ്പോൾ പ്രത്യേക വസ്തുക്കൾ ഉടൻ തന്നെ തീർപ്പാക്കപ്പെടാറുണ്ട്. `new` and `delete `ഓവർലോഡുചെയ്ത ഓപ്പറേറ്റർ ഉപയോഗിച്ച് സാധുതയുള്ള മെമ്മറി മാനേജ്മെന്റ് സാധ്യമാണ്, കൂടാതെ സിയുടെ `malloc` കീവേഡിനെ വിളിക്കുകയും നേരിട്ട് പുറത്തു വിടുകയും ചെയ്യുക. ഗാർബേജ് ശേഖരണം നിയന്ത്രിക്കാനാകും: പ്രോഗ്രാമർമാർക്ക് കളക്റ്റർ നിരീക്ഷിക്കുന്നതിൽ നിന്ന് മെമ്മറി ശ്രേണികൾ ചേർക്കുകയോ ഒഴിവാക്കുകയോ  ചെയ്യാവുന്നതാണ്, കളക്ഷനും ശക്തിയും ഉള്ള ഒരു തലമുറയോ പൂർണ്ണമായ ശേഖരമോ ആയ സൈക്കിൾ പ്രവർത്തനരഹിതമാക്കുകയും പ്രാപ്തമാക്കുകയും ചെയ്യാം.ഒരു പ്രോഗ്രാമിലെ ഗാർബ്ബേജ് ശേഖരണം അപര്യാപ്തമാകുമ്പോഴുള്ള വ്യത്യസ്തമായ മെച്ചപ്പെടുത്തിയ മെമ്മറി മാനേജ്മെന്റ് സ്കീമുകൾ എങ്ങനെ നടപ്പാക്കാമെന്നതിന്റെ നിരവധി ഉദാഹരണങ്ങൾ ഈ മാനുവൽ നൽകുന്നു.
## സേഫ്ഡി
ഡി എന്ന ഉപവിഭാഗത്തിൽ നൽകിയിരിക്കുന്ന പേരാണ് സേഫ്ഡി (SafeD)  എന്നത് മെമ്മറി സുരക്ഷിതമാക്കാൻ സഹായിക്കും (മെമ്മറി ഉപയോഗിക്കാതെ അല്ലെങ്കിൽ ഇതിനകം റീസൈക്കിൾ ചെയ്തവ). `@Safe` എന്ന് അടയാളപ്പെടുത്തിയ ഫംഗ്ഷനുകൾ കംപൈൽ സമയം  പരിശോധിക്കുന്നത് പോയിന്റർ അരിത്മെറ്റിക്, പരിശോധിക്കാത്ത കാസ്റ്റുകൾ, പോലുള്ള മെമ്മറി കറപ്ക്ഷൻ(ഡാറ്റയുടെ സംഭരണ സംസ്‌കരണ വിനിമയ സമയങ്ങളിൽ ഡാറ്റയിൽ കടന്ന്‌ കൂടിയേക്കാവുന്ന അനാവശ്യ വ്യതിയാനം) ഉപയോഗിക്കുന്നില്ലെന്ന് ഉറപ്പുവരുത്തുക, കൂടാതെ മറ്റെന്തെങ്കിലും ഫങ്ഷനുകളും `@safe` അല്ലെങ്കിൽ `@trusted` ആയി അടയാളപ്പെടുത്തണം. `@trusted` എന്ന് അടയാളപ്പെടുത്തിയിരിക്കുന്ന  ഒരു സവിശേഷതയുടെ സുരക്ഷിതമായ ഉപയോഗവും മെമ്മറി കറപക്ഷന്റെ സാധ്യതയും തമ്മിലുള്ള വ്യത്യാസങ്ങളെ കമ്പൈലർ വേർതിരിച്ചെടുക്കാൻ കഴിയാത്ത സാഹചര്യങ്ങളിൽ ഫങ്ഷനെ നിയന്ത്രിയ്ക്കാൻ കഴിയും.

## മറ്റ് സംവിധാനങ്ങളുമായുള്ള പാരസ്‌പര്യം
സിയുടെ ആപ്ളിക്കേഷൻ ബൈനറി ഇൻറർഫെയിസ് (ABI) പിന്തുണയ്ക്കുന്നു, കൂടാതെ സിയുടെ അടിസ്ഥാനപരമായതും, ഡിറൈവ് ചെയ്തതുമായ എല്ലാ തരങ്ങളും, നിലവിലുള്ള സി കോഡിലേക്കും ലൈബ്രറികളിലേക്കും നേരിട്ട് പ്രവേശനം സാധ്യമാക്കുന്നു. പല സി ലൈബ്രറികൾക്കായി ഡി ബൈൻഡിംഗ്സ് ലഭ്യമാണ്. കൂടാതെ, സിയുടെ സ്റ്റാൻഡേർഡ് ലൈബ്രറി സ്റ്റാൻഡേർഡ് ഡിയുടെ ഭാഗമാണ്. 

സി++ ന് ഒരു സ്റ്റാൻഡേർഡ് എബിഐ ഇല്ല കാരണം, സി എബിഐയ്ക്ക് എഴുതിയ സി++ കോഡ് പൂർണ്ണമായി മാത്രമേ ആക്സസ് ചെയ്യാൻ കഴിയൂ. ഡി പാർസർ സി++ ഒബ്ജക്റ്റുകളിൽ പരിമിതമായി ബന്ധിപ്പിക്കുന്നതിനായി ബാഹ്യ (സി++) വിളിക്കൽ സമ്പ്രദായം മനസ്സിലാക്കുന്നു.

മൈക്രോസോഫ്ട് വിൻഡോസിൽ, ഡി കോമ്പോണന്റ് ഒബ്ജക്റ്റ് മോഡൽ (കോം) കോഡ് ആക്സസ് ചെയ്യാൻ കഴിയും.
## ചരിത്രം
1999 ൽ വാൾട്ടർ ബ്രൈറ്റ് ഒരു പുതിയ ഭാഷയിൽ പ്രവർത്തിക്കാൻ തീരുമാനിച്ചു. ഡി 2001 ൽ ആണ് ആദ്യം പുറത്തിറങ്ങിയത്,ഭാഷയുടെ ആദ്യത്തെ പതിപ്പ് (ഡി1) സി++ പോലെയുള്ള അനിവാര്യ, ഒബ്ജക്റ്റ് ഓറിയെന്റഡ്, മെറ്റാപ്രോഗ്രാമിംഗ് മാത‌ൃകളിൽ  കേന്ദ്രീകരിച്ചു.

ഫോബോസ്, ഡി'യുടെ ഔദ്യോഗിക സമയദൈർഘ്യവും സാധാരണ ലൈബ്രറിയുമൊക്കെ അസംതൃപ്തിയുണ്ടാക്കി, ഡി കമ്മ്യൂണിറ്റിയിലെ അംഗങ്ങൾ ഒരു ബദൽ റൺടൈമും ടാൻഗോ എന്ന് പേരുള്ള ലൈബ്രറിയും സൃഷ്ടിച്ചു. ഡി 1.0  റിലീസിന്റെ  ദിവസങ്ങളിൽ ആദ്യ പൊതു ടാൻഗോ പ്രഖ്യാപനം വന്നു.OOP ഉം ഉയർന്ന മോഡുലാരിറ്റിയും വ്യത്യസ്ത പ്രോഗ്രാമിങ് ശൈലി സ്വീകരിച്ചു. ഒരു കമ്മ്യൂണിറ്റി നേതൃത്വത്തിലുള്ള പദ്ധതിയായിരുന്നതിനാൽ, ടാൻഗോ സംഭാവനകൾ കൂടുതൽ തുറന്നുകിടന്നു, അത് ഔദ്യോഗിക സ്റ്റാൻഡേർഡ് ലൈബ്രറിയെക്കാൾ വേഗത്തിൽ പുരോഗമിക്കാൻ അനുവദിച്ചു. അക്കാലത്ത് ടാംഗോയും ഫോബോസും വ്യത്യസ്ത റൺടൈം സപ്പോർട്ട് എപിഐ(API)കൾ (ഗാർബ്ബേജ് കളക്ടർ, ത്രെഡ്ഡിംഗ് പിന്തുണ മുതലായവ) തമ്മിൽ പൊരുത്തപ്പെടാത്തവയായിരുന്നു. ഇത് ഒരേ പ്രോജക്ടിൽ ലൈബ്രറികൾ ഉപയോഗിക്കുന്നത് അസാധ്യമാക്കി. രണ്ടു ലൈബ്രറികളും നിലവിലുണ്ടായിരുന്നുവെങ്കിലും, ഫോബോസും മറ്റുള്ളവയും ടാംഗോ ഉപയോഗിച്ചുള്ള ചില പാക്കേജുകൾ മൂലം കാര്യമായ തർക്കം നടന്നിട്ടുണ്ട്.

2007 ജൂണിൽ, ഡി 2 ന്റെ ആദ്യ പതിപ്പ് പുറത്തിറങ്ങി. ഡി 2 ന്റെ വളർച്ചയുടെ തുടക്കം ഡി 1 ന്റെ സ്ഥിരത ഉറപ്പിക്കലാണ്; ഭാഷയുടെ ആദ്യത്തെ പതിപ്പ് പരിപാലനത്തിലും, തിരുത്തലുകളും ബഗ്ഫിക്സിങ്ങ് നടപ്പിലാക്കലുകളും മാത്രമാണ് ലഭിക്കുന്നത്. ഡി 2 ആയിരുന്നു ആദ്യത്തെ പരീക്ഷണാത്മക കോൺസ്റ്റ് സിസ്റ്റം ഉപയോഗിച്ച്, ഭാഷയിലേക്ക് ബ്രേക്കിങ്ങ് മാറ്റങ്ങൾ അവതരിപ്പിക്കുകയായിരുന്നു. പിന്നീട് ഡി2 ക്ലോസ്, ശുദ്ധി, ഫങ്ഷണൽ ആൻഡ് കംപ്യൂട്ടർ പ്രോഗ്രാമിങ് മാതൃകൾക്കുകൾക്കുള്ള പിന്തുണ തുടങ്ങിയ നിരവധി ഭാഷാ സവിശേഷതകൾ കൂട്ടിച്ചേർത്തു. സാധാരണ ലൈബ്രറിയിൽ നിന്ന് റൺടൈം വേർതിരിച്ചുകൊണ്ട് ഡി ലൈബ്രറി പ്രശ്നങ്ങളും പരിഹരിച്ചു. ഒരു ഡി 2 ടാംഗോ പോർട്ട് 2012 ഫെബ്രുവരിയിൽ പ്രഖ്യാപിക്കപ്പെട്ടു. 

2010 ജൂൺ 12 ന് ആന്ദ്രെ അലക്സാന്ദ്രെസ്കുസിന്റെ  ദി ഡി പ്രോഗ്രാമിങ് ഭാഷ എന്ന പുസ്തകം പുറത്തിറക്കിയത് D2 വിന്റെ സ്ഥിരത അടയാളപ്പെടുത്തി, ഇന്ന് അത് സാധാരണയായി "ഡി" എന്നാണ് വിളിക്കുന്നത്.

2011 ജനുവരിയിൽ, ഡവലപ്മെന്റ് ഒരു ബഗ്ഗ് ട്രാക്കർ / പാച്ച്-സമർപ്പണ അടിസ്ഥാനത്തിൽ നിന്ന് ഗിറ്റ്ഹബ്ബ്(GitHub)ലേക്ക് നീക്കി. ഇത് കമ്പൈലർ, റൺടൈം, സ്റ്റാൻഡേർഡ് ലൈബ്രറി എന്നിവയുടെ സംഭാവനകളിൽ ഗണ്യമായ വർദ്ധനവ് കൈവരിച്ചിട്ടുണ്ട്. 

2011 ഡിസംബർ 31-നു ഭാഷയുടെ ആദ്യത്തെ പതിപ്പ് ആൻഡ്രൂ അലക്സാണ്ട്രസ്കു പ്രഖ്യാപിച്ചു,  ഡി 1, 2012 ഡിസംബർ 31-ന് അവസാനിപ്പിക്കപ്പെട്ടു. അവസാന ഡി 1 പതിപ്പ്, ഡി v1.076, 2012 ഡിസംബർ 31 ന് ആയിരുന്നു.

ഔദ്യോഗിക ഡി കംപൈലറിനായുള്ള കോഡ്, വാൾട്ടർ ബ്രൈറ്റ് ഡിജിറ്റൽ മാർസ് ഡി കംപൈലർ, ഒരു ഇച്ഛാനുസൃത ലൈസൻസിനു കീഴിൽ പുറത്തിറങ്ങി, ലഭ്യമായ സ്രോതസ്സായി യോഗ്യരല്ലെങ്കിലും ഓപ്പൺ സോഴ്സ് നിർവ്വചനത്തിനുള്ളിൽ വരുന്നതല്ല.2014-ൽ കമ്പോസ്റ്റ് ഫ്രണ്ട് എൻഡ് ബൂസ്റ്റ് സോഫ്റ്റ്‌വേർ ലൈസൻസിനു കീഴിൽ ഓപ്പൺ സോഴ്സായി വീണ്ടും ലൈസൻസ് ചെയ്തു.ഈ വീണ്ടും ലൈസൻസുള്ള കോഡ് സിമാൻടെക്കിൽ ഭാഗികമായി വികസിപ്പിച്ചെടുത്ത ബാക്ക്എൻഡ്(back-end)ഒഴിവാക്കി. 2017 ഏപ്രിൽ ഏഴിന്, മുഴുവൻ കമ്പൈലറും ബൂസ്റ്റ് ലൈസൻസിനു കീഴിൽ ലഭ്യമാക്കിയിരുന്നു. സിമാൻടെക്ക് വീണ്ടും പിൻവലിക്കാൻ അനുമതി നൽകി. 2017 ജൂൺ 21-ന് ജിസിസിയിൽ(GCC) ഉൾപ്പെടുത്താൻ ഡി ഭാഷ അംഗീകരിക്കപ്പെട്ടു.
## നടപ്പിലാക്കൽ
നിലവിലുള്ള ഡി ഇംപ്ലിമെന്റേഷൻ ഫലപ്രദമായ എക്സിക്യൂഷന് വേണ്ടി യന്ത്രകോഡുകളിലേക്ക് നേരിട്ട് സമാഹരിക്കുന്നു.
* ഡി.എം.ഡി - വാൾട്ടർ ബ്രൈറ്റ് ഡിജിറ്റൽ മാർസ് ഡി കമ്പൈലർ ഔദ്യോഗിക ഡി കമ്പൈലർ ആണ്. ബൂസ്റ്റ് സോഫ്റ്റ്‌വേർ ലൈസൻസിനു കീഴിൽ ഉള്ള തുറന്ന ഉറവിടമാണ് ഇത്.
* ജിഡിസി(GDC) - ഓപ്പൺ ഡി.എം.ഡി കംപൈലർ ഉറവിട കോഡ് ഉപയോഗിച്ച് നിർമ്മിച്ച ജിസിസി ബാക്ക്-എൻഡിനുള്ള ഒരു ഫ്രണ്ട് എൻഡ്.
* എൽ ഡി സി - ഡിഎംഡി ഫ്രണ്ട് എൻഡ് അടിസ്ഥാനമാക്കിയുള്ള കമ്പൈലർ, അതിന്റെ കമ്പൈലർ ബാക്ക്-എൻഡ് ആയി എൽ എൽ വി എം ഉപയോഗിക്കുന്നു. 9 ജനുവരി 2009 ൽ ആദ്യത്തെ റിലീസ്-നിലവാര പതിപ്പ് പ്രസിദ്ധീകരിച്ചു.  ഇത് പതിപ്പ് 2.0 യെ പിന്തുണയ്ക്കുന്നു. 
* ഡി കംപൈലർ .നെറ്റ്(.NET) - ഡി പ്രോഗ്രാമിങ് ഭാഷ 2.0 കമ്പൈലർക്കുള്ള ഒരു ബാക്ക്-എൻഡ്. [മെഷീൻ കോഡിനേക്കാൾ കോമൺ ഇന്റർമീഡിയറ്റ് ലാംഗ്വേജസ് (സിഐഎൽ) യിലേക്ക് കോപ്പി ചെയ്യുന്നു. ഒരു കോമൺ ലാംഗ്വേജ് ഇൻഫ്രാസ്ട്രക്ചർ (CLR) വിർച്ച്വൽ മഷീൻ വഴിയാണ് CIL പ്രവർത്തിപ്പിക്കാൻ കഴിയുന്നത്.
* എസ്ഡിസി(SDC) - ഒരു കംപൈലർ ഒരു ഇച്ഛാനുസൃത ഫ്രണ്ട്-എൻഡ്, എൽഎൽവിഎം(LLVM) അതിന്റെ കമ്പൈലർ ബാക്ക്-എൻഡ് ആയി ഉപയോഗിക്കുന്നു.
## വികസന ഉപകരണങ്ങൾ
എക്ലിപ്സ്(Eclipse), മൈക്രോസോഫ്റ്റ് വിഷ്വൽ സ്റ്റുഡിയോ(Microsoft Visual Studio), സ്ലിക്ക്എഡിറ്റ്(SlickEdit), ഇമാക്സ്(Emacs), വിം(vim), സൈടി(SciTE), സ്മൾട്രോൺ(Smultron), ടെക്സ്റ്റ്മേറ്റ്(TextMate), മോണോഡെവലപ്(MonoDevelop), സെയുസ്(Zeus),   ജീനി മുതലായവ ഡി പിന്തുണയ്ക്കുന്ന എഡിറ്ററുകളാണ്, സംയോജിത വികസന എൻവയൺമെന്റുകളും (IDEs) പിന്തുണക്കുന്നു.
* ഡി-യുടെ എക്ലിപ്സ് പ്ലഗ്-ഇന്നുകൾ ഉൾപ്പെടുന്നു: ഡിഡിടി ഡെസെന്റ് (ഡെഡ് പ്രോജക്റ്റ്). 
* വിഷ്വൽ സ്റ്റുഡിയോ സംയോജനം നൽകുന്നത് വിഷ്വൽ ഡി.
* വിഷ്വൽ സ്റ്റുഡിയോ കോഡ് എക്സ്പ്ലോഷനുകളോടെയുള്ള സംയോജനം ഡിലാങ്-വിഎസ് കോഡ്(Dlang-Vscode) അല്ലെങ്കിൽ കോഡ്-ഡി
* വിം(Vim) സിന്റാക്സ് ഹൈലൈറ്റിംഗും കോഡ് പൂർത്തീകരണവും പിന്തുണയ്ക്കുന്നു
* ടെക്സ്റ്റ്മേറ്റിനായി ഒരു ബണ്ടിൽ ലഭ്യമാണ്, കോഡ് :: ബ്ലോക്ക് ഐഡിഇ(IDE) ഭാഷയിൽ ഭാഗിക പിന്തുണ ഉൾക്കൊള്ളുന്നു. എന്നിരുന്നാലും, കോഡിൻറെ പൂർത്തീകരണം അല്ലെങ്കിൽ റിഫക്റ്റററിംഗ് പോലുള്ള സാധാരണ ഐഡിഇ(IDE) സവിശേഷതകൾ ഇനിയും ലഭ്യമല്ല, എന്നിരുന്നാലും അവ കോഡ് :: ബ്ലോക്കുകളിൽ ഭാഗികമായി പ്രവർത്തിക്കുന്നുണ്ട് (ഡി സിയുടെ ഡി സാദൃശ്യം കാരണം).
* ഡി-ബേസ് പ്രൊജക്റ്റുകൾ വികസനം പ്രാപ്തമാക്കുന്നതിനായി Xcode 3-യ്ക്കുള്ള ഒരു പ്ലഗിൻ, എക്സ്കോഡ(Xcode)യ്ക്ക് ഡിയിൽ ലഭ്യമാണ്. 
* മോണോഡെവലപി(MonoDevelop)ന് വേണ്ടി മോണോ-ഡി എന്ന പേരുള്ള ഒരു AddIn  ലഭ്യമാണ്.
* കെ ഡവലപ്(KDevelop) (അതോടൊപ്പം അതിന്റെ ടെക്സ്റ്റ് എഡിറ്റർ ബാക്കെൻഡും കേറ്റിനും) സ്വയം പൂർത്തിയാക്കൽ പ്ലഗിൻ ലഭ്യമാണ്.
* ഡിയായി സമർപ്പിച്ചിരിക്കുന്ന ഒരു ഓപ്പൺ സോഴ്സ് ഐഡിഇ(IDE) ആയ കോയിഡിറ്റ്(Coedit).
വിൻഡോസിനു വേണ്ടിയുള്ള ഓപ്പൺ സോഴ്സ് ഡി ഐഡികൾ നിലവിലുണ്ട്, പോസിഡോൺ, ഡി-ഐഡി, ഡി എഴുതുന്ന ചിലത്,എന്റൈസ് ഡിസൈനർ തുടങ്ങിയവഡി ആപ്ലിക്കേഷനുകൾ ജിഡിബി അല്ലെങ്കിൽ വിൻഡിബിജി പോലെയുള്ള ഏതെങ്കിലും സി / സി ++ ഡീബഗ്ഗർ ഉപയോഗിച്ച് ഡീബഗ്ഗ് ചെയ്യാവുന്നതാണ്, ഡി-നിർദ്ദിഷ്ട ഭാഷാ ഫീച്ചറുകളുടെ പിന്തുണ വളരെ പരിമിതമാണ്. വിൻഡോസിൽ, Ddbg, അല്ലെങ്കിൽ Microsoft ഡീബഗ്ഗിംഗ് ടൂളുകൾ (WinDBG, Visual Studio) എന്നിവ ഉപയോഗിച്ച് ഡിവിഗ് പ്രോഗ്രാമുകൾ ഡീബഗ്ഗിങ്ങ് ചെയ്യാം, cv2pdb. ഉപയോഗിച്ച് ഡീബഗ് വിവരങ്ങൾ മാറ്റിയ ശേഷം. ലിനക്സിനുള്ള ZeroBUGS  ഡീബഗ്ഗർ ഡി ഭാഷയ്ക്കുള്ള പരീക്ഷണാത്മക പിന്തുണയുണ്ടു്. ഡിബിജി പല ഐഡിഇ അല്ലെങ്കിൽ കമാൻഡ് ലൈനിൽ ഉപയോഗിയ്ക്കാം; സീറോബഗ്ഗ്സ്(ZeroBUGS)ന് സ്വന്തമായി ഗ്രാഫിക്കൽ യൂസർ ഇന്റർഫേസ് (ജിയുഐ) ഉണ്ട്.
## ഉദാഹരണങ്ങൾ
### ഉദാഹരണം 1
ഈ ഉദാഹരണ പ്രോഗ്രാം അതിന്റെ കമാൻഡ് ലൈൻ ആർഗ്യുമെന്റുകൾ പ്രിന്റ് ചെയ്യുന്നു. ഒരു `main` പ്രോഗ്രാമാണ് ഡി പ്രോഗ്രാമിന്റെ എൻട്രി പോയിന്റ്, കൂടാതെ `args` എന്നത് കമാൻഡ് ലൈൻ ആർഗ്യുമെന്റുകൾ പ്രതിനിധീകരിക്കുന്ന സ്ട്രിംഗുകളുടെ ഒരു അറേ ആണ്. ഡിയിൽ ഒരു സ്ട്രിംഗ് എന്നത് `char[]` പ്രതീകങ്ങളുടെ ഒരു നിരയാണ്, ഡി1-ൽ, അല്ലെങ്കിൽ D2 ലെ `immutablechar[]`.


```d
import std.stdio: writefln;

void main(string[] args)
{
    foreach (i, arg; args)
        writefln("args[%d] = '%s'", i, arg);
}
```

`foreach` പ്രസ്താവനയ്ക്ക് ശേഖരണത്തിനുമേൽ ഇറ്ററേറ്റ് ചെയ്യാൻ കഴിയും. ഈ സാഹചര്യത്തിൽ, അറേ നിന്നുള്ള ആർഗുകളിൽ നിന്ന് സൂചികകൾ (`i`), മൂല്യങ്ങൾ (ആർഗുകൾ) ഒരു ശ്രേണിയെ സൃഷ്ടിക്കുന്നു. സൂചിക `i`യും മൂല്യ `arg`അറേ ടൈപ്പുകളിൽ നിന്നും അനുമാനിക്കുന്ന തരത്തിലുള്ളതാണ്.
### ഉദാഹരണം 2
വളരെ ചുരുങ്ങിയ പരിപാടിയിൽ താഴെപറയുന്ന ഡിയുടെ കഴിവുകളും ഡി ഡിസൈൻ ട്രേഡുകളും കാണിക്കുന്നു. ഓരോ വരിയിലും വ്യത്യസ്ത പദങ്ങൾ അടങ്ങിയിട്ടുള്ള, `words.txt` എന്ന് പേരുള്ള ഒരു വാചക ഫയലിന്റെ രൂപത്തിൽ ഇത് മാറുന്നു, മറ്റ് അനായാസ പദങ്ങളും എല്ലാ വാക്കുകളും പ്രിന്റ് ചെയ്യുന്നു.

```d
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;
        signs2words[key] ~= w.idup;
    }

    foreach(words; signs2words)
        if(words.length > 1)
            writefln(words.join(" "));
}
```

#`signs2words` എന്നത് അന്തർനിർമ്മിത അസിസ്റ്റന്റ് അറേയാണ്, അത് `dstrings` ന്റെ അറേകളിലേക്ക് dstring (32-bit / char) കീകൾ. പൈത്തണിലുള്ള `defaultdict(list)` പോലെയാണ് ഇത്.
#`lines(File())` പുതിയ വരിയോടുകൂടിയ മന്ദഗതിയിലുള്ള വരികൾ. അസോസിയേറ്റ് അറേ മൂല്യങ്ങൾക്കായി ഉപയോഗിയ്ക്കുന്ന ഒരു സ്ട്രിംഗ് നേടുന്നതിന് `idup` ഉപയോഗിച്ച് പകർത്താനും (ശ്രേണിയുടെ`idup` പ്രോപ്പർട്ടി അറേയിൽ മാറ്റമില്ലാത്ത തനിപ്പകർപ്പ് നൽകുന്നു, `dstring` തരം യഥാർത്ഥത്തിൽ മാറ്റമില്ലാത്ത ‌`(dchar) []`ആണെന്നതിനാൽ ഇത് ആവശ്യമാണ്.) അന്തർനിർമ്മിത അസോസിയേറ്റ് അറേകൾക്ക് സ്ഥായിയായ കീകൾ ആവശ്യമാണ്.
#`~=` ഓപ്പറേറ്റർ അസോസിയേറ്റ് ഡൈനാമിക് അറേയുടെ മൂല്യങ്ങൾ പുതിയ ഡിസ്ട്രിങ്ങിലേക്ക്(dstring) ചേർക്കുന്നു.
#`toLower`, `join`, `chomp` എന്നിവയാണ് സ്ട്രിംഗ് ഫംഗ്ഷനുകൾ ഡി ഒരു രീതിയിലുള്ള സിന്റാക്സ് ഉപയോഗിച്ചു് അനുവദിയ്ക്കുന്നു. അത്തരം ഫംഗ്ഷനുകളുടെ പേരുകൾ പൈത്തൺ സ്ട്രിംഗ് രീതികൾക്ക് സമാനമാണ്. ഒരു ലോവർ കേസിൽ ഒരു സ്ട്രിംഗ് പരിവർത്തനം ചെയ്യുന്നു, `join ("")` സ്ട്രിംഗുകളുടെ ഒരു ശ്രേണി ഒരൊറ്റ വിഭജനമായി വേർതിരിച്ച് ഒരു സ്ട്രിംഗിലേക്ക് ചേർക്കുന്നു, ഒപ്പം ഒന്നുണ്ടെങ്കിൽ സ്ട്രിംഗ് അവസാനിക്കുമ്പോൾ ഒരു പുതിയ വരിയെ `chomp` നീക്കം ചെയ്യുന്നു.
#`sort` ശ്രേണിയെ സജ്ജമാക്കുന്ന ഒരു std.gorgorm ഫങ്ഷൻ ആണ് ഇത്, പരസ്പരം അനായാസം ആയ വാക്കുകൾക്ക് ഒരു സവിശേഷമായ ഒപ്പ് സൃഷ്ടിക്കുന്നു. `sort()`  ന്റെ റിട്ടേണിലെ `release ()` രീതി ഒറ്റ എക്സപ്രഷനായി കോഡ് സൂക്ഷിക്കുന്നതിന് സഹായകമാണ്.
#രണ്ടാമത്തെ foreach അസോസിയേറ്റ് അറേയുടെ മൂല്യങ്ങൾ ഇറ്ററേറ്റ് ചെയ്യുന്നു, അത് `word` തരം അനുമാനിക്കാൻ കഴിയും.
#`key`ഒരു സ്ഥായിയായ ചരം നൽകിയിരിക്കുന്നു, അതിന്റെ തരം അനുമാനമാണ്.
#സാധാരണ UTF-8 `char[]` ഉപയോഗിക്കുന്നതിന് പകരം UTF-32 `dchar[]` ആണ് ഉപയോഗിക്കുന്നത്, അല്ലാത്തപക്ഷം `sort()` ചെയ്യുന്നത് ഇത് നിരസിക്കില്ല. ഈ പ്രോഗ്രാം എഴുതാൻ കൂടുതൽ കാര്യക്ഷമമായ വഴികൾ ഉണ്ട്, യുടിഎഫ്-8(UTF-8) മാത്രം ഉപയോഗിക്കുക എന്നതാണ്.
## ഉപയോഗങ്ങൾ
ഫേസ്‌ബുക്ക്,  ഈബേ,  , നെറ്റ്ഫ്ലിക്സ് 
എന്നിവ ഉൾക്കൊള്ളുന്ന പ്രോഗ്രാമുകൾക്കായി ഡി പ്രോഗ്രാമിംഗ് ഭാഷ ഉപയോഗിക്കുന്ന ശ്രദ്ധേയമായ സംഘടനകൾ.

എഎഎ(AAA) ഗെയിമുകൾ,  ഒരു ജാവാസ്ക്രിപ്റ്റ് വെർച്വൽ മെഷീൻ, ഒരു ഓപ്പറേറ്റിങ് സിസ്റ്റം കേർണൽ, ജിപിയു പ്രോഗ്രാമിങ്, വെബ് ഡെവലപ്പ്മെന്റ്,  ന്യൂമറിക്കൽ വിശകലനം,   ജിയുഐ ആപ്ളിക്കേഷൻസ്, , പാസഞ്ചർ ഇൻഫർമേഷൻ സിസ്റ്റം എന്നിവയിൽ ഡി ഭാഷ പരീക്ഷിച്ചു വിജയിച്ചിട്ടുണ്ട്.
## ഇതും കാണുക

* Ddoc
* D Language Foundation

## അവലംബം