comparison.dd

Ddoc

$(COMMUNITY D Concepts Overview,

$(P Navigate D's implementation of a few key programming language concepts.)

$(ITEMIZE
        $(A spec/garbage.html, Garbage Collection)
        $(ITEMIZE
            $(REF_ALTTEXT Manual invocation, GC.enable, core,memory),
            $(A spec/function.html#nogc-functions, `@nogc` subset)
        ),
        Functions
        $(ITEMIZE
                $(A spec/function.html#function-overloading, Function Overloading),
                $(A spec/function.html#ref-params, `ref` and `out` function parameters),
                $(A spec/function.html#ref-functions, `ref` functions),
                $(A spec/type.html#delegates, Function Delegates),
                $(A spec/function.html#nested, Nested functions),
                $(A spec/expression.html#FunctionLiteral, Function literals),
                $(A spec/function.html#closures, Closures),
                $(A spec/function.html#variadic, Typesafe variadic arguments),
                $(A lazy-evaluation.html, Lazy function argument evaluation),
                $(A spec/function.html#pseudo-member, Uniform Function Call Syntax)
        ),
        Arrays
        $(ITEMIZE
                $(A spec/arrays.html, Lightweight arrays),
                $(A spec/arrays.html#resize, Resizeable arrays),
                $(A spec/arrays.html#strings, Built-in strings),
                $(A spec/arrays.html#slicing, Array slicing),
                $(A spec/arrays.html#bounds, Array bounds checking),
                $(A spec/expression.html#ArrayLiteral, Array literals),
                $(A spec/statement.html#string-switch, String switches),
                $(A spec/arrays.html#associative, Associative arrays)
        ),
        OOP
        $(ITEMIZE
                $(A spec/class.html, Object Orientation),
                $(A spec/interface.html, Interfaces),
                Single inheritance of implementation/multiple inheritance of interfaces,
                $(A spec/operatoroverloading.html, Operator overloading),
                $(A spec/module.html, Modules),
                No built-in dynamic class loading,
                $(A spec/class.html#nested, Nested classes),
                $(A spec/class.html#nested, Inner (adaptor) classes),
                $(A spec/function.html#covariance, Covariant return types),
                $(A spec/function.html#property-functions, Properties)
        ),
        Performance
        $(ITEMIZE
                $(A spec/iasm.html, Inline assembler),
                Direct access to hardware,
                $(A spec/struct.html, Lightweight objects),
                $(A https://wiki.dlang.org/Memory_Management, Explicit memory allocation control),
                Independent of VM,
                Direct native code gen
        ),
        Generic Programming
        $(ITEMIZE
                $(A spec/declaration.html#AutoDeclaration, Implicit Type Inference),
                $(A spec/statement.html#ForeachStatement, `foreach`),
                $(MREF_ALTTEXT Ranges, std,range),
                $(MREF_ALTTEXT Algorithms, std,algorithm),
                $(A spec/declaration.html#alias, Aliases),
                $(A spec/template.html, Templates)
                $(ITEMIZE
                $(A spec/template.html#aggregate_templates, Aggregate Templates),
                $(A spec/template.html#function-templates, Function Templates),
                $(A spec/template.html#ifti, Implicit Function Template Instantiation),
                $(A spec/template.html#parameters_specialization, Partial and Explicit Template Specialization),
                $(A spec/template.html#template_value_parameter, Value Template Parameters),
                $(A spec/template.html#aliasparameters, Alias Template Parameters),
                $(A articles/variadic-function-templates.html, Variadic Template Parameters),
                $(A articles/constraints.html, Template Constraints)
                )
                $(A spec/expression.html#IsExpression, `is` expressions),
                $(A spec/type.html#Typeof, `typeof`)
        ),
        Metaprogramming
        $(ITEMIZE
                $(A spec/function.html#interpretation, Compile Time Function Evaluation),
                $(A spec/template-mixin.html, Template Mixins),
                $(A articles/mixin.html, String Mixins),
                $(A spec/version.html#staticif, `static if`),
                $(A spec/version.html#staticforeach, `static foreach`)
        ),
        Reliability
        $(ITEMIZE
                $(A spec/contracts.html, Contract Programming),
                $(A spec/unittest.html, Unit testing),
                $(A spec/const3.html, Immutable data),
                $(A spec/function.html#pure-functions, Pure functions),
                $(A spec/module.html#staticorder, Static construction order),
                $(A spec/declaration.html#initialization, Initialization by default),
                $(A spec/glossary.html#raii, RAII (implicit destructor calls)),
                $(A spec/statement.html#TryStatement, Exception handling),
                $(A spec/statement.html#ScopeGuardStatement, Scope guards),
                $(A spec/statement.html#TryStatement, `try`-`catch`-`finally` blocks),
                $(A articles/safed.html, Memory-safe subset)
        ),
        Concurrency & Parallelism
        $(ITEMIZE
                $(MREF_ALTTEXT Concurrency, std,concurrency),
                $(MREF_ALTTEXT Fibers, core,thread,fiber),
                $(REF parallel, std,parallelism),
                $(A articles/migrate-to-shared.html, Thread Local Storage by default),
                $(A spec/const3.html#shared, Shared data),
                $(A spec/statement.html#SynchronizedStatement, Thread synchronization primitives)
        ),
        Types
        $(ITEMIZE
                $(A spec/struct.html, Structs and Unions),
                $(A spec/enum.html, Enumerated types),
                $(A spec/float.html, 80 bit floating point),
                $(A phobos/std_complex.html, Complex and Imaginary),
                $(A spec/type.html#pointers, Pointers),
                $(REF_ALTTEXT Tuples, Tuple, std,typecons),
                $(A spec/struct.html#alias-this, Alias This)
        ),
        Compatibility
        $(ITEMIZE
        C-like syntax,
                $(A spec/type.html, Support for all C types),
                $(A spec/statement.html#NonEmptyStatementNoCaseNoDefault,
                    `if`, `while`, `do`, `for`, `switch`, `goto`),
                $(A spec/attribute.html#linkage, Direct access to C),
                $(A spec/importc.html, Import C code),
                $(A spec/betterc.html, Better C subset),
                Use existing debuggers,
                $(A spec/attribute.html#align, Struct member alignment control),
                Generates standard object files,
                $(A pretod.html, Obviates need for a macro text preprocessor)
        ),
        Other
        $(ITEMIZE
                $(A spec/version.html, Conditional compilation),
                $(A spec/lex.html, Unicode source text),
                $(A spec/statement.html#with-statement, `with` statement),
                $(A spec/attribute.html#UserDefinedAttribute, User-Defined Attributes),
                $(A spec/ddoc.html, Documentation comments),
                $(A spec/ddoc.html#using_ddoc_to_generate_examples, Documented unit tests)
        )
)

)

Macros:
        TITLE=Features Overview