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

Dao 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.
     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
  *  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; 

Visitor Map