View source for User:Phoolimin/Dao (programming language)

{{Infobox programming language
| name                   = Dao
| logo                   = NonFreeImageRemoved.svg
| paradigm               = [[Multi-paradigm programming language|Multi-paradigm]]: [[object-oriented programming|object-oriented]], [[scripting language|scripting]]
| year                   = [[2006]]
| designer               = Limin Fu
| latest_release_version = dao-1.2
| latest_release_date    = 2012-07-08
| typing                 = [[Static typing|static]], [[Dynamic typing|dynamic]], [[type inference|inferred]]
| influenced_by          = [[C++]], [[Lua (programming language)|Lua]], [[python language|Python]]
| operating_system       = [[Cross-platform]]
| license                = [[BSD licenses#2-clause license ("Simplified BSD License" or "FreeBSD License")|BSD]]
| website                = http://www.daovm.net
}}
'''Dao''' is an [[object-oriented]] [[scripting language]] with dynamically typed variables supporting complex [[data structures]]. It has text processing abilities, such as [[regular expression]] matching. It provides many built-in numerical datatypes such as [[complex number]]s and multi-dimensional numeric arrays, as well as their corresponding arithmetic operations. Support for [[multi-threaded]] programming is also an integrated part of Dao.
The Dao interpreter is implemented as a lightweight [[virtual machine|virtual]] [[register machine]] (Dao VM) in standard [[C (programming language)|C]]. The Dao VM can be extended with C or C++.

Advanced features of the language include:

* A mixed static and dynamic [[type system]] with automatic [[type inference]] capabilities
* A flexible [[macros|macro]] system that allows definition of new syntax
* [[Concurrent computing|Concurrent]] and [[distributed computing|distributed]] programming with [[message Passing Interface]]s

==Basics==
===Hello World===

The classic [[hello world program]] can be written as follows:

<syntaxhighlight lang="ruby">
io.write( "Hello world!" )
</syntaxhighlight>

Here '''io'''(='''stdio''') is the standard library to handle [[I/O|input and output]]. <!--In Dao, there are no built-in functions; all functions are part of a certain library, such as '''stdio''', '''stdlib''', '''math''', '''coroutine''', '''reflect''', '''mpi''' (message passing interface), '''network''', and '''thread'''.-->

The '''std.listmeth''' routine can be used to display the methods in a library. The methods in '''math''', for example, can be displayed using:
<syntaxhighlight lang="ruby">
std.listmeth( math )
</syntaxhighlight>

===Datatypes===

A Dao variable can be implicitly declared by assigning the result of an expression to a variable name.

<syntaxhighlight lang="ruby">
  a_number = 123
  a_string = "abc"
  a_list = { 1, 2, 3 }
  a_map = { "CD"=>123, "AB"=>456 }
  a_tuple1 = ( 123, "ABC" )
  a_tuple2 = ( index => 123, name => "ABC" ) # tuple with named items
  a_vector = [ 1, 2, 3 ]
  a_matrix = [ 1, 2; 3, 4 ]
</syntaxhighlight>

By default, a variable will have a fixed type that is inferred from the expression that is used to declare the variable; this is called implicit typing. The type of a variable can also be specified explicitly, using the following [[Pascal (programming language)|Pascal-style]] declaration syntax:

<syntaxhighlight lang="ruby">
  var_typed : type
  var_typed : type = value
</syntaxhighlight>

''type'' can be one of the following built-in types: '''int''', '''float''', '''double''', '''string''', '''complex''', '''list''', '''map''', '''tuple''', '''array''', '''buffer''', '''routine''', or some composition of these types.

For example:

<syntaxhighlight lang="ruby">
  a_list2 : list<list<float> >
  a_list3 : list<list<string> > = {}
  a_map2 : map<string,int> = { "ABC"=>123 }
  a_tuple1 : tuple<int,string> = ( 123, "ABC" )
  a_tuple2 : tuple<index:int,name:string> = ( index => 123, name => "ABC" )
</syntaxhighlight>

''type'' can also be a Dao class name or the name of a user-defined C type. Special keywords for typing include: '''any''' for any type<!-- is this comparable to 'var' in C#? -->, '''?''' for undefined types and '''@X''' for a type holder that can be initialized to a certain type in a parameter list.

All typed variables undergo static checking.

===Control flow===

If-Elif-Else:

<syntaxhighlight lang="ruby">
  a = math.rand();
  if( a > 0.75 ){
     a -= 0.75
  }elif( a > 0.5 ){
     a -= 0.5
  }else{
     a -= 0.25
  }
</syntaxhighlight>

While:

<syntaxhighlight lang="ruby">
  i = 0;
  while( i < 10 ) i++
</syntaxhighlight>

For:

<syntaxhighlight lang="ruby">
  for( i=0; i<10; i++ ) io.writeln( i )
  for( i=0 : 9 ) io.writeln( i )
  for( i=0 : 2 : 9 ) io.writeln( i )
</syntaxhighlight>

For-in:

<syntaxhighlight lang="ruby">
  a_list = { 1, 2, 3 }
  for( it in a_list ) io.writeln( it )
  a_list2 = { "a", "b", "c" }
  for( it in a_list; it2 in a_list2 ) io.writeln( it, it2 )
</syntaxhighlight>

For-in also works for hash.

Switch

<syntaxhighlight lang="ruby">
  a = ""
  switch( a ){
    case 1 : a = "1";
    case 2, 3, 4: a = "2,3,4"; # multiple values as case
    case 5 ... 9 : a = "5...9"; # value range as case
    case "abc" : a = "abc"; # string as case
    default : a = "default";
  }
</syntaxhighlight>

==Functions==

The declaration of a basic function (known in Dao as routines) looks like this:

<!-- someone please come up with a less goofy example
  '''routine''' foo( a, b : '''string''', c = 123 ) => '''int'''
  {
     '''return''' 456;
  }
 -->
<!-- maybe a less goofy example-->
<syntaxhighlight lang="ruby">
routine RepeatString( s : string, times = 1 ) => string
{
    rep = '';
    for( i = 1 : times ) rep += s;
    return rep;
}
</syntaxhighlight>

Dao supports [[first-class function]]s. The definition of such functions is identical to that of normal function definition, with the following differences:
* there is no need for a function name, but the created function must be assigned to a variable;
* the default value expressions do not need to be constant expressions, as they are evaluated at run time when the function is created;
* the function body may contain variables defined in the "upper" function that creates it.

<syntaxhighlight lang="ruby">
  a = "ABC";
  rout = routine( x, y : string, z = a+a ){
     a += "_abc";
     io.writeln( "lambda ", a )
     io.writeln( "lambda ", y )
     io.writeln( "lambda ", z )
  }
  rout( 1, "XXX" );
</syntaxhighlight>

==Classes==

<syntaxhighlight lang="ruby">
  class MyNumber
  {
    routine MyNumber( value = 0 ){ Value = value }

    routine setValue( value : int ){ Value = value }
    routine getValue(){ return Value }

    operator .Value=( value : int ){ Value = value } # field set operator
    operator .Value(){ return Value } # field get operator

    private
    var Value = 0; # default value is zero
  }
</syntaxhighlight>

==Macros==

Dao has a unique [[Macro (computer science)|macro]] system where macro is defined in a way similar to writing [[Backus–Naur Form]] (BNF) metasyntax notation.
Such macro is composed of two parts, the first part is the source syntax pattern to be matched, and the second part is the syntax to be applied.
The transformation from the source syntax pattern to the target syntax pattern is controlled by some predefined [[markup language|markups]] (for identifiers, expressions, blocks and their repetitions etc.).

Dao macros are defined in the following way:
<syntaxhighlight lang="ruby">
  syntax{
    source_syntax_pattern
  }as{
    target_syntax_pattern
  }
</syntaxhighlight>

This example enables "while-do-end" without brackets:
<syntaxhighlight lang="ruby">
  syntax{
     while $EXP do \[ $BL \] end
  }as{
     while( $EXP ){ \[ $BL \] }
  }
</syntaxhighlight>

==Functional methods==

Besides the supporting of [[first-class function]], Dao has additional support of
[[functional programming|functional style programming]] by providing a set
of [[higher-order function]]s as built-in methods,
such as [[Map (higher-order function)|map()]], [[Fold (higher-order function)|fold()]]
and [[Unfold (higher-order function)|unfold()]] etc.

The basic syntax for such methods is the following,
<syntaxhighlight lang="ruby">
method( parameter(s) )->|variable(s)|{ inlined_function }
</syntaxhighlight>

Examples,
<syntaxhighlight lang="ruby">
a = { 1, 2, 3 }
b = map( a ) -> { 10*x } # produce { 10, 20, 30 }
b = map( a ) -> |x| { 10*x } # equivalent to above

# map() can take more than one lists as parameters:
b = { 11, 22, 33 }
c = map( a, b ) -> |x,y| { x + y }

# function composition
c = map( a, b )->|x,y|{ x + y, x - y }->|u,v| { u * v }
</syntaxhighlight>

==Concurrent and distributed programming==
===Asynchronous function call===

Probably the simplest way to create multi-threaded programs in Dao is to use asynchronous function calls (AFC). The way of using AFC is almost identical to that of normal function calls, with the exception that the keyword async must follow the call.

<syntaxhighlight lang="ruby">
  myfunc( myparams ) async;
  myobj.mymeth( myparams ) async;
</syntaxhighlight>

Any functions or methods can be invoked in such an asynchronous way.

Normally AFC is executed in a separated native thread, which can be either an idle thread available from the thread pool, or a new thread created on the fly.

===Message Passing Interface===

With [[Message Passing Interface]] APIs provided in library '''mpi''', one can easily do concurrent and distributed programming in Dao. In the MPI library, there are three principal functions: '''spawn()''', '''send()''' and '''receive()'''. With '''spawn()''', one can create lightweight virtual machine processes or real operation system processes, in the local or remote computers; and with '''send()''' and '''receive()''', a process can send messages to or receive messages from other processes.

The process names are of the following form:

  virtual_process@real_process@@hostname

"@real_process@@hostname" identifies an operating system process on host "@@hostname", and "virtual_process@real_process@@hostname" identifies a virtual process within "@real_process@@hostname". Message passing can only happen among virtual processes. Each real process has a main virtual process named "self". Any part can be omitted. For example, when "virtual_process" is omitted, it means the "self" virtual process, and "@@hostname" alone identifies the "self" within the operating system process that binds to port 4115 ( D : 4, A : 1, O : 15 ).

<syntaxhighlight lang="ruby">
  # spawn a real process to run script "mpi_script.dao"
  mpi.spawn( "@pid", "mpi_script.dao" );
  # spawn a virtual process to run function "test"
  mpi.spawn( "vmp@pid", "test" );

  # send message to a real process
  mpi.send( "@pid", "TO MAIN" );

  # print a received message
  io.writeln( mpi.receive() );

  # spawn a real process on "@@localhost" to run script "mpi_script.dao"
  mpi.spawn( "@pid2@@localhost", "mpi_script.dao" );
  # spawn a virtual process on "@pid2@@localhost" to run function "test"
  mpi.spawn( "vmp@pid2@@localhost", "test" );
  # send message to the virtual process "vmp@pid2@@localhost"
  mpi.send( "vmp@pid2@@localhost", "ANOTHER", 123.456 );
</syntaxhighlight>

==External links==
{{Portal|Free software}}
*[http://www.daovm.net Dao Language (official website)]
*[http://dao.googlecode.com Dao Language on Google Code]
*[http://sourceforge.net/projects/daoscript Daoscript] on [[Source Forge]]

{{DEFAULTSORT:Dao (Programming Language)}}
[[:Category:Scripting languages]]
[[:Category:Virtual machines]]
[[:Category:Free compilers and interpreters]]
[[:Category:Free development toolkits and libraries]]

[[ko:다오]]
[[zh:道语言]]