    By Limin Fu. Released under the GNU Free Documentation License.
    [NAME]
    ALL.dao.feature

    [TITLE]
    Dao Feature Summary

    [DESCRIPTION]

    Key features:
      *  Optional typing with type inference and static type checking:
         Optional typing allows variables to be declared with or without explicit types.
         Types will be inferred and checked whenever necessary and possible to allow early
         detection of bugs. Also explicit and inferred type information could be used do code
         and function specialization to make programs more efficient.
      *  Just-In-Time (JIT) compiling:
         A standard module based on the Low Level Virtual Machine (LLVM) compiler
         infrastructure is provided to support JIT compiling. Currently this JIT compiler
         module is mainly developed for supporting numeric compuations.
      *  Built-in support for concurrent programming:
         Concurrent programming is made simple by a number of concurrent code section methods
         and asynchronous classes. The basic concurrent computational unit is a tasklet which
         consists of a virtual machine process (context) and a future value (handle). A
         tasklet is mapped to a native thread only when it becomes active. Tasklets can
         communicate and synchronize with each other by channels. Concurrent garbage
         collection is supported by the virtual machine to make concurrent program safe.
      *  Transparent C programming interfaces:
         The C programming interfaces of the virtual machine are specifically designed for
         easy embedding and extending. With the support of explicit type specification in
         function parameter list, boilerplate codes for checking and converting parameter
         values from Dao data types to C/C++ data types can be easily avoided. This means
         writing Dao wrapper functions is significantly simpler than writing wrapper
         functions for other languages without explict typing in parameter list.
      *  ClangDao for automatic wrapping of C/C++ libraries:
         ClangDao uses the C/C++ frontend of Clang to parse C/C++ header files and generates
         proper wrapping codes for Dao. It has been used successfully to generate a number of
         bindings for Dao.

    Other interesting features:
      *  Syntax macro:
         Dao supports user-defined syntax by syntax macros, which can be expressed in a form
         similar to Backus-Naur Form (BNF). Dao allows syntax macros to be attached with
         "language" names, and provides a mechanism to avoid unexpected interference with the
         standard syntax.
      *  Object-Oriented Programming (OOP):
         Object-Oriented Programming support in Dao is class based. Dao classes are similar
         to C++ classes in several ways with a few new features.
      *  Abstract interface:
         An abstract interface is type that defines a set of abstract methods for static type
         checking. A combination of interfaces and classes could support more flexible
         software design by both compositions and inheritances.
      *  Deferred block and exception handling by defer-recover:
         Deferred block is a code block whose execution is deferred to the time when the
         function exits. Defer-recover is a mechanism to handle exceptions in deferred
         blocks.
      *  Code section methods:
         Code section/block method is an alternative to functional methods in other languages
         such as Python. It is syntactically similar to Ruby Code Block.
      *  Typed function decorator:
         Function decorators are functions that modify the behavior of other functions. Dao
         function decorators support static type checking.
      *  Anonymous function:
         Anonymous functions and closures can be created anywhere in a program. Their
         definition is very similar to the normal functions.
      *  Mixin class, class decorator and aspect class:
         Mixin class supports composing new classes without inheritance. Class decorator
         supports compiling time modification of classes, and support Aspect-Orient
         Programming through automatic application of class decorators.
      *  Enum/flag/symbol type:
         The enum type in Dao is more or less a combination C++ enum and Ruby symbol. It has
         the advantage of both, and can be used in situations where C++ enum or Ruby symbol
         are typically used.
      *  Variant or disjoint union type:
         Variant type is a combination of two or more types. A variant variable can hold a
         value of any of the combined types.
      *  Coroutine and generator:
         Module support for coroutine makes collaborative multithreading simple, and allows
         static type checking across the yielding and resuming boundary.
      *  Auxiliary methods:
         Any type can be attached with auxiliary methods that do not actually belong to the
         type, but can be invoked as its member methods.
      *  Built-in multi-dimensional numeric array;
      *  Built-in support for string pattern matching;
      *  Built-in hash map type;
      *  Template-like C data type;
      *  Standard help system;
      *  Data serialization;
      *  Mixed programming with embedded C/C++ codes;