By Limin Fu. Released under the GNU Free Documentation License.

Feature Summary


Key features:
  *  Optional typing with type inference and static type checking:
     Optional typing allows variables to be declared with or without explicit types. Type
     s will be inferred and checked whenever necessary and possible to allow early detect
     ion of bugs. Also explicit and inferred type information could be used do code and f
     unction specialization to make programs more efficient.
  *  Just-In-Time (JIT) compiling:
     A standard module based on the Low Level Virtual Machine (LLVM) compiler infrastruct
     ure is provided to support JIT compiling. Currently this JIT compiler module is main
     ly 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 taskl
     et is mapped to a native thread only when it becomes active. Tasklets can communicat
     e and synchronize with each other by channels. Concurrent garbage collection is supp
     orted 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 ea
     sy embedding and extending. With the support of explicit type specification in funct
     ion parameter list, boilerplate codes for checking and converting parameter values f
     rom 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 "lan
     guage" names, and provides a mechanism to avoid unexpected interference with the sta
     ndard syntax.
  *  Object-Oriented Programming (OOP):
     Object-Oriented Programming support in Dao is class based. Dao classes are similar t
     o 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 softwa
     re 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 func
     tion 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 f
     unction decorators support static type checking.
  *  Anonymous function:
     Anonymous functions and closures can be created anywhere in a program. Their definit
     ion is very similar to the normal functions.
  *  Mixin class, class decorator and aspect class:
     Mixin class supports composing new classes without inheritance. Class decorator supp
     orts compiling time modification of classes, and support Aspect-Orient Programming t
     hrough 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 a
     re typically used.
  *  Variant or disjoint union type:
     Variant type is a combination of two or more types. A variant variable can hold a va
     lue of any of the combined types.
  *  Invariable (immutable variable):
     Invariable can be declared with the invar keyword, as parameters, local variables, g
     lobal variables and field variables.
  *  Coroutine and generator:
     Module support for coroutine makes collaborative multithreading simple, and allows s
     tatic 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 t
     ype, but can be invoked as its member methods. --Customized for-in iteration; 
  *  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;