Dao Language

Summary of the recent development of Dao

Sunday,06-Jun-2010 01:41:14 GMT

Summary of the recent development of Dao

Besides many bug fixings and some optimizations, Dao has undergone some interesting developments to support some new features. Here is a brief summary of these features:

Hash data type:
Its type name is the same as map , but it is constructed in the same way as hash in some other popular languages such as Python and JavaScript etc, for example:
h  =  {  'abc'  :  123,  'def'  :  456  }
h  =  {  :  }  # empty hash

Tests show significant speed improvement for insertion and lookup over RB-Tree based map type. Many of the internal key value lookups have been replaced by using hash.
Data construction by array/list/tuple/map{ expression(s) }:
This syntax is support so that it can be used if one wants the type of data is more apparent. The expression(s) inside the braces are the enumerated items or range specifications:
a  =  array{  1,  2,  3  }  # vector
a  =  array{  1  :  3  }  # vector by range
a  =  array{  1  :  2  :  3  }  # vector by range
b  =  array{  1,  2;  3,  4  }  # 2X2 matrix
c  =  list{  1,  2,  3  }
d  =  list{  1  :  2  }  # list by range
e  =  tuple{  123,  'abc'  }
f  =  map{  'BB'  =>  22,  'AA'  =>  11  }  # ordered keys
g  =  map{  'BB'  :  22,  'AA'  :  11  }  # un-ordered keys
Macro support for defining Python style indentation sensitive syntax:
Details can be found in http://daovm.net/space/dao/thread/224 .

An example is available from demo/macro/scoping_by_indentation.dao

Along with this new support, two extra supports are also implemented: one for creating string literal in macros, the other for multiple uses of source patterns in target syntax. These two supports can be used to create a quine program as show in http://daovm.net/space/dao/thread/235 .
More support for operator overloading:
Now the support for operator overloading is nearly complete. Overloaded methods for unary, binary arithmetic or boolean operators must be static methods (namely they need no class instance to invoke).

Unary operators can be overloaded in two ways:
class  Integer
{
    ...
    static  operator  !(  C  :  Integer,  A  :  Integer  ){
        C.value  =  !  A.value;
        return  C;
    }
    static  operator  !(  A  :  Integer  ){
        return  Integer{  !  A.value  };
    }
}
Where the first will be invoked if, in C = !A , C and A have the right type of Integer and C has reference count equal to one (this is to reuse intermediate object and avoid creating new objects). Otherwise, the second will be invoked if A has the right type. In both case, the method has to return a result.

Similarly, binary operator can be overloaded in three ways:
class  Integer
{
    ...
    static  operator  +=(  C  :  Integer,  B  :  Integer  ){
        C.value  +=  B.value;
        return  C;
    }
    static  operator  +(  C  :  Integer,  A  :  Integer,  B  :  Integer  ){
        C.value  =  A.value  +  B.value;
        return  C;
    }
    static  operator  +(  A  :  Integer,  B  :  Integer  ){
        return  Integer{  A.value  +  B.value  };
    }
}
The first will be invoked for C += B or C = C + B . Similar to the case for unary operators, the choose between the second and third method will be based on the availability of C from the stack and its reference count.

Equality and inequality comparison between class instances (or between cdata) will be based on their raw pointers if operator == and != are not overloaded. Comparing by <, <=, >, >= is not allowed for class instances and cdata, unless <, <= or >, >= are overloaded. However inside the overloaded methods, such operations will be based on row pointers of the operand objects, if the operation has the same name as the overloaded operator:
class  Integer
{
    ...
    static  operator  >(  A  :  Integer,  B  :  Integer  ){
        b  =  A  >  B;  # comparison based on the raw pointer of A and B!
        return  Integer{  A.value  >  B.value  };
    }
}
Interface binding:
See http://daovm.net/space/dao/thread/223 for details. Just to point out, interface supports operator overloading, as shown in the following example.

Example:
interface  AA
{
    routine  Meth(  a  =  0  );
    operator[](  index  :  int  )=>int;
    operator.name()=>string;

    routine  __for_iterator__(  iter  :  for_iterator  );
    operator[](  iter  :  for_iterator  );
}
routine  Test(  o  :  AA  )
{
    o.Meth(  123  );
    io.writeln(  o[1]  );
    io.writeln(  o.name  );
    for(  i  in  o  )  io.writeln(i)
}

class  BB
{
    routine  Meth(  a  =  0  ){  io.writeln(  a  )  }
    operator[](  index  :  int  ){  return  index  }
    operator.name(){  return  'BB'  }

    routine  __for_iterator__(  iter  :  for_iterator  ){
        iter.valid  =  1;
        iter.iterator  =  0;
    }
    operator[](  iter  :  for_iterator  ){
        id  =  (int)iter.iterator;
        iter.valid  =  id  +  1  <  5;
        iter.iterator  =  id  +  1;
        return  id;
    }
}
class  CC  :  BB
{
}

bind  AA  to  BB;

Test(  BB()  );
Test(  CC()  );

for(  i  in  CC()  )  io.writeln(i)
This example is available from demo/interface.dao .
Meta fields and prototype-based programming:
Meta fields is supported for array, list, map, tuple, cdata and class instance etc. Such fields can be set and got by meta field operator -> . A special meta field __proto__ can be set to be a map, for delegated field lookup. Meta fields do not subject to static type checking, and do not interfere with the normal fields.
a  =  {  'name'  :  'Test'  }
b  =  a->name;
a->name  =  'New';
io.writeln(  b,  a,  std.about(a)  );

a->meth  =  routine(  self  :  map<string,string>  )
{
        for(  it  in  self  )  io.writeln(  it  )
}
a->meth();

c  =  {  'index'  :  123  }
c->__proto__  =  a;
io.writeln(  c->name,  c  );

class  Test{}
t  =  Test();

t->value  =  123;
io.writeln(  t->value  );

t->__proto__  =  c;

io.writeln(  t->name,  t->index  );
This example is also available from demo/meta_field.dao .
New support for for-in iteration:
Any type has the following methods can be used in for-in loop for interation:
routine  __for_iterator__(  iter  :  for_iterator  );
    operator[](  iter  :  for_iterator  );
where for_iterator is the built-in simple iterator type, which is essential a tuple type defined as tuple<valid:int,iterator:any> . The method __for_iterator__() is called before the loop starts, to initialize the iterator. In each cycle of the loop, the overloaded operator [] is called to obtain an item of the object, and update properly the iterator. When the valid field become zero, the loop will stop. See the above example in Interface binding.

Important internal changes worth mentioning:

DString structure with reduced size and number of allocation operations;
Better handling function call stack;
Field (and other key-value) lookup by hash;
Re-implementation of exception types as cdata;
Deferred member setup for C types;
Better float point exception handling;
Explicit declaration of static methods by keyword static ;
Better handling parameter passing;
Caching type matching results;
Caching results of overloaded function lookup;
Some improvements in the C interfaces of Dao.

Some minor changes:

Direct up-value lookup in closure;
variable := expression as short for variable : any = expression ;
Regex pattern {{text}} to literally matching the text;
String's regex matching method mpack() for packing matched pattern groups as new string(s).
std.setlocale()

Improvements in autobind.dao:

Support C++ namespace;
Support C callbacks;
Support class instance as default parameter;
Better support virtual functions.

A quine program in Dao

Friday,21-May-2010 06:47:28 GMT

A quine program is a program that prints out the source codes of itself. To be more fun, the source codes should not be read from the source file, nor should it be stored in some kind of global variable from which to be accessed. An interesting quine program should reconstruct its source codes programatically in some way. A list of quine programs in other languages can be found one RosettaCode .

A simple quine program in Dao can be produced easily by porting the C implementation in C to Dao. But the more interesting way is to write a quine using Dao macros:

syntax{Quine  $EXP}as{io.writef('syntax{Quine $EXP}as{%s}Quine %s',\'$EXP\',\'$EXP\')}Quine  io.writef('syntax{Quine $EXP}as{%s}Quine %s',\'$EXP\',\'$EXP\')

It works with the development version of Dao available from the mercurial repository of Dao on google code . The idea of this quine program is to use macro to transform the following new syntax:

Quine  io.writef('syntax{Quine $EXP}as{%s}Quine %s',\'$EXP\',\'$EXP\')

into an io expression with the expression itself being "glued" into a string by quoting the macro variable in the target syntax,

\'$EXP\'

This seems to be the simplest quine program that can be written using Dao macro.

New GoogleCode project for Dao

Tuesday,11-May-2010 05:36:48 GMT

With the ideal project name dao :-)
http://dao.googlecode.com

道语言近期开发进展概要

Sunday,06-Jun-2010 07:02:07 GMT

道语言近期开发进展概要

除了不少错误修复和一些优化外，近期的道语言开发实现了一些新语言特性。下面简要地介绍一下这些特性：

基于哈希的关联表：
这种数据类型作为一种关联表，同样使用类型名 map 。哈希表的构造方式跟如python，javascript等其它流行语言里的哈希表／字典类型的构造方式一样，如：
h  =  {  'abc'  :  123,  'def'  :  456  }
h  =  {  :  }  # 空哈希表

测试显示基于哈希的关联表在插入与查找等操作上效率可以显著地高于基于红黑树的关联表。现在道语言虚拟机内部的一些键值查找也改为基于哈希的关联表了。
使用array/list/tuple/map{ expression(s) }构造数据：
使用这种语法可以是被构造数据的类型更加显而易见。花括号里的表达式要么是枚举的数据元素，要么是一组基于初值，增量，元素个数描述的数值：
a  =  array{  1,  2,  3  }  # 向量
a  =  array{  1  :  3  }  # 向量
a  =  array{  1  :  2  :  3  }  # 向量
b  =  array{  1,  2;  3,  4  }  # 2X2矩阵
c  =  list{  1,  2,  3  }
d  =  list{  1  :  2  }  # 数组
e  =  tuple{  123,  'abc'  }
f  =  map{  'BB'  =>  22,  'AA'  =>  11  }  # 有序键值
g  =  map{  'BB'  :  22,  'AA'  :  11  }  # 无序键值
支持定义类似python缩进语法的宏支持
有关细节可在这里找到：http://daovm.net/space/dao/thread/224 。

有关例子在这里找到：demo/macro/scoping_by_indentation.dao 。

随同缩进语法新增的另外两个新特性是：支持在语法宏的目标语法表达式里构造字符串；和支持源语法模式在目标表达式里的多重使用。这两项特性可用来写出一个独特的quine程序（一种重构并输出本身程序的源代码的程序）： http://daovm.net/space/dao/thread/235 。
更完善的运算符重载：
现在道语言对运算符重载的支持比较完整了。需要指出的是，重载单目或双目算术或布尔运算符的方法必须是静态方法，即不需要类实例来调用该方法。

单目运算符的重载有两种方式：
class  Integer
{
    ...
    static  operator  !(  C  :  Integer,  A  :  Integer  ){
        C.value  =  !  A.value;
        return  C;
    }
    static  operator  !(  A  :  Integer  ){
        return  Integer{  !  A.value  };
    }
}
对于 C = !A ，当 C 和 A 的类型都为 Integer 且 C 的引用计数为一时，第一个重载方法将被调用，否则调用第二个重载方法。这样的处理是为了重用临时对象，避免构造新的对象。这两种方法都必须返回结果对象。

类似地，双目运算符的重载方式有三种：
class  Integer
{
    ...
    static  operator  +=(  C  :  Integer,  B  :  Integer  ){
        C.value  +=  B.value;
        return  C;
    }
    static  operator  +(  C  :  Integer,  A  :  Integer,  B  :  Integer  ){
        C.value  =  A.value  +  B.value;
        return  C;
    }
    static  operator  +(  A  :  Integer,  B  :  Integer  ){
        return  Integer{  A.value  +  B.value  };
    }
}
这里的第一种重载方法将被用于 C += B 或 C = C + B 。对于第二和第三种重载方法的调用，情况类似于上面介绍的单目运算符的重载，这两种方法之间的选择将取决于 C 及其引用计数。

类实例或c数据类型的等于和不等于比较将基于两对象的内存地址，除非这两种比较的运算符被重载。类实例或c数据类型一般不支持大于，大于等于或小于，小于等于比较操作，除非这些运算符被重载。不过，在这些重载方法里，跟被重载运算符相同的运算符将使用两对象的内存地址作比较：
class  Integer
{
    ...
    static  operator  >(  A  :  Integer,  B  :  Integer  ){
        b  =  A  >  B;  # 基于A和B内存地址的比较!
        return  Integer{  A.value  >  B.value  };
    }
}
接口绑定：
一个接口类型就是一个成员方法的集合，使用接口类型将方便某些情况下，既可以使用不同类的实例，也可以是不同类型的C数据对象，只要它们兼容同样的接口。接口类型可以绑定到能提供所有接口方法的类或C数据类型。类或C数据类型与接口类型的兼容性的检查，在运行时将基于该类型是否有某接口类型的捆绑。接口类型的捆绑既可以在编译时完成也可在运行时进行。

例子：
interface  AA
{
    routine  Meth(  a  =  0  );
    operator[](  index  :  int  )=>int;
    operator.name()=>string;

    routine  __for_iterator__(  iter  :  for_iterator  );
    operator[](  iter  :  for_iterator  );
}
routine  Test(  o  :  AA  )
{
    o.Meth(  123  );
    io.writeln(  o[1]  );
    io.writeln(  o.name  );
    for(  i  in  o  )  io.writeln(i)
}

class  BB
{
    routine  Meth(  a  =  0  ){  io.writeln(  a  )  }
    operator[](  index  :  int  ){  return  index  }
    operator.name(){  return  'BB'  }

    routine  __for_iterator__(  iter  :  for_iterator  ){
        iter.valid  =  1;
        iter.iterator  =  0;
    }
    operator[](  iter  :  for_iterator  ){
        id  =  (int)iter.iterator;
        iter.valid  =  id  +  1  <  5;
        iter.iterator  =  id  +  1;
        return  id;
    }
}
class  CC  :  BB
{
}

bind  AA  to  BB;

Test(  BB()  );
Test(  CC()  );

for(  i  in  CC()  )  io.writeln(i)
此例子也可在这里找到：demo/interface.dao 。
bind  AA  to  any
将允许接口 AA 在运行时被捆绑到任意兼容的类或C类型上。
Meta fields (元/附加/动态成员?)和基于原型(prototype)的编程：
array, list, map, tuple, cdata 和类实例支持meta成员，这种成员的添加与访问需要使用meta成员访问符 -> 。关联表可以作为名为 __proto__ 的特殊meta成员添加到那些对象里，这样当查找某对象的meta成员时，如果不存在，查找将在其名为 __proto__ 的 meta成员里继续。

meta成员没有静态的类型检查。一个对象的普通成员和meta成员互不干扰。
a  =  {  'name'  :  'Test'  }
b  =  a->name;
a->name  =  'New';
io.writeln(  b,  a,  std.about(a)  );

a->meth  =  routine(  self  :  map<string,string>  )
{
        for(  it  in  self  )  io.writeln(  it  )
}
a->meth();

c  =  {  'index'  :  123  }
c->__proto__  =  a;
io.writeln(  c->name,  c  );

class  Test{}
t  =  Test();

t->value  =  123;
io.writeln(  t->value  );

t->__proto__  =  c;

io.writeln(  t->name,  t->index  );
此例子也可在这里找到：demo/meta_field.dao 。
新的for-in迭代循环支持
任何定义了如下成员方法的类型都可以被用在 for-in 循环里：
routine  __for_iterator__(  iter  :  for_iterator  );
    operator[](  iter  :  for_iterator  );
这里 for_iterator 是一个简单的内置迭代子类型，它本质上是个定义为 tuple<valid:int,iterator:any> 的元组类型。方法 __for_iterator__() 用于循环前初始化迭代子。在每次循环时，重载操作符 [] 将被用来获得与迭代子关联的元素，并且适当地更新迭代子的状态。当迭代子的 valid 成员被置零时，循环将被终止。参考上面接口绑定中的例子。

重要的内部实现更新：

更小的DString结构，减少需要的内存分配次数；
更好的函数调用栈处理；
基于哈希的成员或键值查找；
重新实现异常类为cdata类型；
推迟的C类型的成员设置；
更好的浮点数异常处理；
静态成员方法的显示申明（使用 static 关键词）；
更好的参数传递处理；
类型匹配结果的缓存；
重载函数检查结果的缓存；
改善的道语言C接口。

一些小的改动：

闭包的up-value的直接访问；
variable := expression 作为 variable : any = expression 的简写；
字符串正则表达式模式单元 {{text}} ，用来逐字匹配text；
字符串模式匹配方法 mpack() ，用来将匹配的模式组的子字符串聚合返回；
std.setlocale()

autobind.dao的完善：

支持C++名字空间；
支持C回调函数；
支持使用C++类实例作为缺省参数；
更好的虚函数支持。