[NAME]
ALL.dao.type.list.method

[TITLE]
列表方法

[DESCRIPTION]


     
   1  list<@T=any>( count: int )[index: int => @T] => list<@T>
   2  list<@T=any>( count: int, init: @T )[index: int, prev: @T => @T] => list<@T>
   3  
   4  clear( self: list<@T> )
   5  size( invar self: list<@T> )=>int
   6  resize( self: list<@T<int|float|double|complex|string|enum>>, size: int )
   7  resize( self: list<@T>, value: @T, size: int )
   8  
   9  max( invar self: list<@T<int|float|double|complex|string|enum>> ) => tuple<@T,int>
  10  min( invar self: list<@T<int|float|double|complex|string|enum>> ) => tuple<@T,int>
  11  sum( invar self: list<@T<int|float|double|complex|string|enum>> ) => @T
  12  
  13  insert( self: list<@T>, item: @T, pos = 0 ) => list<@T>
  14  erase( self: list<@T>, start = 0, count = 1 ) => list<@T>
  15  join( self: list<@T>, other: list<@T>, ... : list<@T> ) => list<@T>
  16  append( self: list<@T>, item: @T, ... : @T ) => list<@T>
  17  push( self: list<@T>, item: @T, to: enum<front, back> = $back ) => list<@T>
  18  pop( self: list<@T>, from: enum<front,back> = $back ) => @T
  19  front( invar self: list<@T> ) => @T
  20  back( invar self: list<@T> ) => @T
  21  
  22  collect( invar self: list<@T>, direction: enum<forward,backward> = $forward )
  23      [item: @T, index: int => none|@V] => list<@V>
  24  collect( invar self: list<@T>, invar other: list<@S>, 
  25      direction: enum<forward,backward> = $forward )
  26      [item: @T, item2: @S, index: int => none|@V] => list<@V>
  27  associate( invar self: list<@T>, hashing = 0 )
  28      [item: invar<@T>, index: int => none|tuple<@K,@V>] => map<@K,@V>
  29  associate( invar self: list<@T>, invar other: list<@S>, hashing = 0 )
  30      [item: invar<@T>, item2: invar<@S>, index: int => none|tuple<@K,@V>]
  31      => map<@K,@V>
  32  reduce( invar self: list<@T>, direction: enum<forward,backward> = $forward )
  33      [item: invar<@T>, value: @T, index: int => @T] => @T|none
  34  reduce( invar self: list<@T>, init: @V,
  35      direction: enum<forward,backward> = $forward )
  36      [item: invar<@T>, value: @V, index: int => @V] => @V
  37  find( invar self: list<@T>, direction: enum<forward,backward> = $forward )
  38      [item: invar<@T>, index: int => int] => tuple<index:int,value:@T> | none
  39  iterate( invar self: list<@T>, direction: enum<forward,backward> = $forward )
  40      [item: invar<@T>, index: int]
  41  iterate( self: list<@T>, direction: enum<forward,backward> = $forward )
  42      [item: @T, index: int]
  43  
  44  sort( self: list<@T>, order: enum<ascend,descend> = $ascend, part = 0 ) => list<@T>
  45  sort( self: list<@T>, part = 0 )[X: @T, Y: @T => int] => list<@T>
  46  apply( self: list<@T>, direction: enum<forward,backward> = $forward )
  47      [item: @T, index: int => @T] => list<@T>
     


 0.1   Methods  


 0.1.1   list<@T=any>(count:int)[index:int=>@T]=>list<@T>  
     
   1  list<@T=any>( count: int )[index: int => @T] => list<@T>
     


 0.1.2   list<@T=any>(count:int,init:@T)[index:int,prev:@T=>@T]=>list<@T>  
     
   1  list<@T=any>( count: int, init: @T )[index: int, prev: @T => @T] => list<@T>
     


 0.1.3   clear(self:list<@T>)  
     
   1  clear( self: list<@T> )
     
清空列表里的元素。

 0.1.4   size(invar self:list<@T>)=>int  
     
   1  size( invar self: list<@T> )=>int
     
返回列表的长度。

 0.1.5   resize(self:list<@T<int|float|double|complex|string|enum>>,size:int)  
     
   1  resize( self: list<@T<int|float|double|complex|string|enum>>, size: int )
     
将列表改变成长度为"size"。 此方法仅适用于元素类型为基本类型的列表。

 0.1.6   resize(self:list<@T>,value:@T,size:int)  
     
   1  resize( self: list<@T>, value: @T, size: int )
     
将列表改变成长度为"size"，并使用"value"作为新元素值。

 0.1.7   max(invar self:list<@T<int|float|double|complex|string|enum>>)=>tuple<@T,int>  
     
   1  max( invar self: list<@T<int|float|double|complex|string|enum>> ) => tuple<@T,int>
     
返回列表里的最大值及其下标。 只有元素类型为基本类型的列表才能用此方法。 如果元素类型为复数，
复数大小的比较将先比较其实部，再比较其虚部。

 0.1.8   min(invar self:list<@T<int|float|double|complex|string|enum>>)=>tuple<@T,int>  
     
   1  min( invar self: list<@T<int|float|double|complex|string|enum>> ) => tuple<@T,int>
     
返回列表里的最小值及其下标。

 0.1.9   sum(invar self:list<@T<int|float|double|complex|string|enum>>)=>@T  
     
   1  sum( invar self: list<@T<int|float|double|complex|string|enum>> ) => @T
     
返回列表元素的和。

 0.1.10   insert(self:list<@T>,item:@T,pos=0)=>list<@T>  
     
   1  insert( self: list<@T>, item: @T, pos = 0 ) => list<@T>
     
将值"item"插入列表里下标"pos"所指的位置。 返回该列表本身。

 0.1.11   erase(self:list<@T>,start=0,count=1)=>list<@T>  
     
   1  erase( self: list<@T>, start = 0, count = 1 ) => list<@T>
     
从列表的"start"位置开始删除"count"个元素。 返回该列表本身。

 0.1.12   join(self:list<@T>,other:list<@T>,...:list<@T>)=>list<@T>  
     
   1  join( self: list<@T>, other: list<@T>, ... : list<@T> ) => list<@T>
     
将一个或多个列表附加到列表尾部。 返回该列表本身。

 0.1.13   append(self:list<@T>,item:@T,...:@T)=>list<@T>  
     
   1  append( self: list<@T>, item: @T, ... : @T ) => list<@T>
     
将元素附加到列表尾部。 返回该列表本身。

 0.1.14   push(self:list<@T>,item:@T,to:enum<front,back>=$back)=>list<@T>  
     
   1  push( self: list<@T>, item: @T, to: enum<front, back> = $back ) => list<@T>
     
将元素推入列表首部或尾部。 返回该列表本身。

 0.1.15   pop(self:list<@T>,from:enum<front,back>=$back)=>@T  
     
   1  pop( self: list<@T>, from: enum<front,back> = $back ) => @T
     
将元素从列表的首部或尾部删除。 返回删除的元素。

 0.1.16   front(invar self:list<@T>)=>@T  
     
   1  front( invar self: list<@T> ) => @T
     
返回列表最前面的元素。

 0.1.17   back(invar self:list<@T>)=>@T  
     
   1  back( invar self: list<@T> ) => @T
     
返回列表最后面的元素。

 0.1.18   collect(invar self:list<@T>,direction:enum...)[...=>none|@V]=>list<@V>  
     
   1  collect( invar self: list<@T>, direction: enum<forward,backward> = $forward )
   2      [item: @T, index: int => none|@V] => list<@V>
     
历遍列表并对其每个元素执行相应的代码块。 代码块返回的非none值将用来构造一个新的类表并返回。

历遍方向由"direction"参数控制。

 0.1.19   collect(invar self:list<@T>,invar other:list<@S>,...)[...=>none|@V]=>list<@V>  
     
   1  collect( invar self: list<@T>, invar other: list<@S>, 
   2      direction: enum<forward,backward> = $forward )
   3      [item: @T, item2: @S, index: int => none|@V] => list<@V>
     
同时历遍两个列表并对其对应的元素执行相应的代码块。 代码块返回的非none值将用来构造一个新的类
表并返回。
历遍方向由"direction"参数控制。

 0.1.20   associate(invar self:list<@T>,hashing=0)[...=>none|tuple<@K,@V>]=>map<@K,@V>  
     
   1  associate( invar self: list<@T>, hashing = 0 )
   2      [item: invar<@T>, index: int => none|tuple<@K,@V>] => map<@K,@V>
     
历遍列表并对其每个元素执行相应的代码块。 该代码块既可返回一个空值none，也可放回一个键值元组
。 这些返回的键值元组将用来构造并返回一个新的关联表。
此方法的最后的可选参数"hashing"可取如下值：
-- 零: 表示被构造的关联表将是有序的；
-- 一: 表示被构造的关联表将是一个带缺省哈希种子的哈希表；
-- 二: 表示被构造的关联表将是一个带随机哈希种子的哈希表；
-- 其他整数: 表示被构造的关联表将是一个哈希表，并以  "hashing"为哈希种子;

 0.1.21   associate(invar self:list<@T>,invar other:list<@S>,hashing=0)[...]=>map<@K,@V> 
 
     
   1  associate( invar self: list<@T>, invar other: list<@S>, hashing = 0 )
   2      [item: invar<@T>, item2: invar<@S>, index: int => none|tuple<@K,@V>]
   3      => map<@K,@V>
     
与上述方法一样，只不过此方法同时历遍两个列表。

 0.1.22   reduce(invar self:list<@T>,direction:enum...)[...=>@T]=>@T|none  
     
   1  reduce( invar self: list<@T>, direction: enum<forward,backward> = $forward )
   2      [item: invar<@T>, value: @T, index: int => @T] => @T|none
     
化简列表里的元素。
其基本过程如下：
1. 取列表的第一元素为初始当前值；
2. 从第二个元素开始，每个元素的值和当前值都被传入相应的代码块，  代码块执行后返回的值将变成
新的当前值；
3. 当所有元素都被处理后，最后的当前值将被返回。
历遍方向由"direction"参数控制。 如果列表为空，空值none将被返回。

 0.1.23   reduce(invar self:list<@T>,init:@V,direction:enum...)[...=>@V]=>@V  
     
   1  reduce( invar self: list<@T>, init: @V, direction: enum<forward,backward>
   2      = $forward ) [item: invar<@T>, value: @V, index: int => @V] => @V
     
化简列表里的元素。
其基本过程与上面的方法基本一直。只不过这里初始当前值是由方法参数指定， 并且历遍是从列表的第
一元素开始。而且当前值的类型也不必和列表元素的类型一致。

 0.1.24   find(invar self:list<@T>,direction:...)[...]=>tuple<index:int,value:@T>|none  
     
   1  find( invar self: list<@T>, direction: enum<forward,backward> = $forward )
   2      [item: invar<@T>, index: int => int] => tuple<index:int,value:@T> | none
     
查找列表里第一个满足代码块所表示的条件。 代码块返回非零整数表示条件满足。 历遍方向由"direct
ion"参数控制。

 0.1.25   iterate(invar self:list<@T>,direction:enum...)[item:invar<@T>,index:int]  
     
   1  iterate( invar self: list<@T>, direction: enum<forward,backward> = $forward )
   2      [item: invar<@T>, index: int]
     
历遍列表并对其每个元素执行代码块。 历遍方向由"direction"参数控制。

 0.1.26   iterate(self:list<@T>,direction:enum...)[item:@T,index:int]  
     
   1  iterate( self: list<@T>, direction: enum<forward,backward> = $forward )
   2      [item: @T, index: int]
     
历遍列表并对其每个元素执行代码块。 历遍方向由"direction"参数控制。 此方法与前面方法的不同之
处在于前面的方法只能历遍常量列表。

 0.1.27   sort(self:list<@T>,order:enum<ascend,descend>=$ascend,part=0)=>list<@T>  
     
   1  sort( self: list<@T>, order: enum<ascend,descend> = $ascend, part = 0 )
   2      => list<@T>
     
按升序或降序排序列表。如果"part"参数非零，排序将只把最大的（降序）或最小 的（升序）"part"个元素
正确排好即可。

 0.1.28   sort(self:list<@T>,part=0)[X:@T,Y:@T=>int]=>list<@T>  
     
   1  sort( self: list<@T>, part = 0 )[X: @T, Y: @T => int] => list<@T>
     
排序列表。列表元素的大小关系将由代码块确定。 排序时，列表中的两个元素将被传递给代码块作比较，
如果代码块的结果为非零值，这将表示作为第一个参数的元素 小于作为第二个参数的元素。 参数"part
"的含义与上面的方法一致。

 0.1.29   apply(self:list<@T>,direction:enum...)[item:@T,index:int=>@T]=>list<@T>  
     
   1  apply( self: list<@T>, direction: enum<forward,backward> = $forward )
   2      [item: @T, index: int => @T] => list<@T>
     
历遍列表并对其每个元素执行代码块。 然后将该元素的值替换为代码块的结果值。 历遍方向由"direct
ion"参数控制。