ft: erlang abstrace format抽象描述添加

src/docs/erlang/erlangAbstractFormat.md

@@ -131,79 +131,79 @@
 # 8.5  Clauses
     There are function clauses, if clauses, case clauses, and catch clauses.
     A clause C is one of the following:
-        如果 C 是 case 子句P -> B，其中P是模式，B是主体，则 Rep(C) = {clause,ANNO,[Rep(P)],[],Rep(B)}。
-        如果当 Gs -> B 时C 是 case 子句P，其中P是模式， Gs是保护序列，B是主体，则 Rep(C) = {clause,ANNO,[Rep(P)],Rep (Gs),Rep(B)}。
-        如果 C 是 catch 子句P -> B，其中P是模式，B是主体，则 Rep(C) = {clause,ANNO,[Rep({throw,P,_})],[],Rep (B)}，即带有显式异常类 throw且带有或不带有显式堆栈跟踪变量_的 catch 子句无法与没有显式异常类和显式堆栈跟踪变量的 catch 子句区分开来。
-        如果 C 是 catch 子句X : P -> B，其中X是原子文字或变量模式， P是模式，B是主体，则 Rep(C) = {clause,ANNO,[Rep({ X,P,_})],[],Rep(B)}，即带有显式异常类和显式堆栈跟踪变量_的 catch 子句不能与带有显式异常类且没有显式异常类的 catch 子句区分开来显式堆栈跟踪变量。
-        如果 C 是 catch 子句X : P : S -> B，其中X是原子文字或变量模式， P是模式，S是变量，B 是主体，则 Rep(C) = {clause ,ANNO,[Rep({X,P,S})],[],Rep(B)}。
-        如果Gs -> B 时C 是 catch 子句P，其中P是模式，Gs是保护序列，B是主体，则 Rep(C) = {clause,ANNO,[Rep({throw,P, _})],Rep(Gs),Rep(B)}，即带有显式异常类 throw和带有或不带有显式堆栈跟踪变量_的 catch 子句不能与没有显式异常类的 catch 子句区分开来，并且没有显式的堆栈跟踪变量。
-        如果 C 是 catch 子句X : P when Gs -> B，其中X是原子文字或变量模式， P是模式，Gs是保护序列，B是主体，则 Rep(C) = {子句,ANNO,[Rep({X,P,_})],Rep(Gs),Rep(B)}，即带有显式异常类和显式堆栈跟踪变量_的 catch 子句无法与带有显式异常类且没有显式堆栈跟踪变量的 catch 子句。
-        如果 C 是 catch 子句X : P : S 当 Gs -> B 时，其中X是原子文字或变量模式， P是模式，Gs是保护序列， S是变量，B是主体，然后 Rep(C) = {clause,ANNO,[Rep({X,P,S})],Rep(Gs),Rep(B)}。
-        如果 C 是函数子句( Ps ) -> B，其中Ps是模式序列而B是主体，则 Rep(C) = {clause,ANNO,Rep(Ps),[],Rep(B)}。
-        如果 C 是Gs -> B 时的函数子句( Ps )，其中Ps是模式序列， Gs是保护序列，B是主体，则 Rep(C) = {clause,ANNO,Rep(Ps),Rep (Gs),Rep(B)}。
-        如果 C 是 if 子句Gs -> B，其中Gs是保护序列，B是主体，则 Rep(C) = {clause,ANNO,[],Rep(Gs),Rep(B)}。
+        If C is a case clause P -> B, 其中P是模式，B是主体，则 Rep(C) = {clause,ANNO,[Rep(P)],[],Rep(B)}。
+        If C is a case clause P when Gs -> B, 其中P是模式， Gs是保护序列，B是主体，则 Rep(C) = {clause,ANNO,[Rep(P)],Rep (Gs),Rep(B)}。
+        If C is a catch clause P -> B, 其中P是模式，B是主体，则 Rep(C) = {clause,ANNO,[Rep({throw,P,_})],[],Rep (B)}，即带有显式异常类 throw且带有或不带有显式堆栈跟踪变量_的 catch 子句无法与没有显式异常类和显式堆栈跟踪变量的 catch 子句区分开来。
+        If C is a catch clause X : P -> B, 其中X是原子文字或变量模式， P是模式，B是主体，则 Rep(C) = {clause,ANNO,[Rep({ X,P,_})],[],Rep(B)}，即带有显式异常类和显式堆栈跟踪变量_的 catch 子句不能与带有显式异常类且没有显式异常类的 catch 子句区分开来显式堆栈跟踪变量。
+        If C is a catch clause X : P : S -> B, 其中X是原子文字或变量模式， P是模式，S是变量，B 是主体，则 Rep(C) = {clause ,ANNO,[Rep({X,P,S})],[],Rep(B)}。
+        If C is a catch clause P when Gs -> B, 其中P是模式，Gs是保护序列，B是主体，则 Rep(C) = {clause,ANNO,[Rep({throw,P, _})],Rep(Gs),Rep(B)}，即带有显式异常类 throw和带有或不带有显式堆栈跟踪变量_的 catch 子句不能与没有显式异常类的 catch 子句区分开来，并且没有显式的堆栈跟踪变量。
+        If C is a catch clause X : P when Gs -> B, 其中X是原子文字或变量模式， P是模式，Gs是保护序列，B是主体，则 Rep(C) = {子句,ANNO,[Rep({X,P,_})],Rep(Gs),Rep(B)}，即带有显式异常类和显式堆栈跟踪变量_的 catch 子句无法与带有显式异常类且没有显式堆栈跟踪变量的 catch 子句。
+        If C is a catch clause X : P : S when Gs -> B, 其中X是原子文字或变量模式， P是模式，Gs是保护序列， S是变量，B是主体，然后 Rep(C) = {clause,ANNO,[Rep({X,P,S})],Rep(Gs),Rep(B)}。
+        If C is a function clause ( Ps ) -> B,其中Ps是模式序列而B是主体，则 Rep(C) = {clause,ANNO,Rep(Ps),[],Rep(B)}。
+        If C is a function clause ( Ps ) when Gs -> B, 其中Ps是模式序列， Gs是保护序列，B是主体，则 Rep(C) = {clause,ANNO,Rep(Ps),Rep (Gs),Rep(B)}。
+        If C is an if clause Gs -> B, 其中Gs是保护序列，B是主体，则 Rep(C) = {clause,ANNO,[],Rep(Gs),Rep(B)}。
 
 # 8.6  Guards
     保护序列Gs是保护序列G_1；...; G_k和 Rep(Gs) = [Rep(G_1), ..., Rep(G_k)]。如果保护序列为空，则 Rep(Gs) = []。
     守卫 G 是守卫测试Gt_1, ..., Gt_k和 Rep(G) = [Rep(Gt_1), ..., Rep(Gt_k)]的非空序列 。
     防护测试 Gt 是以下之一：
-        如果 Gt 是原子文字L，则 Rep(Gt) = Rep(L)。
-        如果 Gt 是位串构造函数 <<Gt_1:Size_1/TSL_1, ..., Gt_k:Size_k/TSL_k>>，其中每个Size_i是一个保护测试，每个 TSL_i是一个类型指定列表，那么 Rep(Gt) = {bin ,ANNO,[{bin_element,ANNO,Rep(Gt_1),Rep(Size_1),Rep(TSL_1)}, ..., {bin_element,ANNO,Rep(Gt_k),Rep(Size_k),Rep(TSL_k)}] } . 对于 Rep(TSL)，请参见上文。默认情况下表示省略的Size_i。默认情况下表示省略的TSL_i。
-        如果 Gt 是一个缺点骨架[Gt_h | Gt_t]，然后 Rep(Gt) = {cons,ANNO,Rep(Gt_h),Rep(Gt_t)}。
-        如果 Gt 是一个函数调用A(Gt_1, ..., Gt_k)，其中A是一个原子，那么 Rep(Gt) = {call,ANNO,Rep(A),[Rep(Gt_1), ..., Rep (Gt_k)]}。
-        如果 Gt 是函数调用A_m:A(Gt_1, ..., Gt_k)，其中A_m是原子erlang并且A是原子或运算符，则 Rep(Gt) = {call,ANNO,{remote,ANNO, Rep(A_m),Rep(A)},[Rep(Gt_1), ..., Rep(Gt_k)]} .
-        如果 Gt 是一个映射创建#{A_1, ..., A_k}，其中每个A_i是一个关联Gt_i_1 => Gt_i_2，那么 Rep(Gt) = {map,ANNO,[Rep(A_1), ..., Rep (A_k)]}。对于Rep(A)，见上文。
-        如果 Gt 是地图更新Gt_0#{A_1, ..., A_k}，其中每个A_i是一个关联Gt_i_1 => Gt_i_2 或Gt_i_1 := Gt_i_2，则 Rep(Gt) = {map,ANNO,Rep(Gt_0), [Rep(A_1), ..., Rep(A_k)]} . 对于Rep(A)，见上文。
-        如果 Gt 为零，[]，则 Rep(Gt) = {nil,ANNO}。
-        如果 Gt 是操作员保护测试Gt_1 Op Gt_2，其中Op是除 match operator =之外的二元运算符，则 Rep(Gt) = {op,ANNO,Op,Rep(Gt_1),Rep(Gt_2)}。
-        如果 Gt 是操作员保护测试Op Gt_0，其中Op是一元运算符，则 Rep(Gt) = {op,ANNO,Op,Rep(Gt_0)}。
-        如果 Gt 是括号内的守卫测试( Gt_0 )，那么 Rep(Gt) = Rep(Gt_0)，即括号内的守卫测试无法与其主体区分开来。
-        如果 Gt 是记录创建 #Name{Field_1=Gt_1, ..., Field_k=Gt_k}，其中每个Field_i是一个原子或_，则 Rep(Gt) = {record,ANNO,Name,[{record_field,ANNO, Rep(Field_1),Rep(Gt_1)}, ..., {record_field,ANNO,Rep(Field_k),Rep(Gt_k)}]}。
-        如果 Gt 是记录字段访问Gt_0#Name.Field，其中Field是原子，则 Rep(Gt) = {record_field,ANNO,Rep(Gt_0),Name,Rep(Field)}。
-        如果 Gt 是记录字段索引#Name.Field，其中Field是原子，则 Rep(Gt) = {record_index,ANNO,Name,Rep(Field)}。
-        如果 Gt 是元组骨架{Gt_1, ..., Gt_k}，则 Rep(Gt) = {tuple,ANNO,[Rep(Gt_1), ..., Rep(Gt_k)]}。
-        如果 Gt 是变量模式V，则 Rep(Gt) = {var,ANNO,A}，其中 A 是一个原子，其打印名称由与V相同的字符组成。
+        If Gt is an atomic literal L,则 Rep(Gt) = Rep(L)。
+        If Gt is a bitstring constructor <<Gt_1:Size_1/TSL_1, ..., Gt_k:Size_k/TSL_k>>, 其中每个Size_i是一个保护测试，每个 TSL_i是一个类型指定列表，那么 Rep(Gt) = {bin ,ANNO,[{bin_element,ANNO,Rep(Gt_1),Rep(Size_1),Rep(TSL_1)}, ..., {bin_element,ANNO,Rep(Gt_k),Rep(Size_k),Rep(TSL_k)}] } . 对于 Rep(TSL)，请参见上文。默认情况下表示省略的Size_i。默认情况下表示省略的TSL_i。
+        If Gt is a cons skeleton [Gt_h | Gt_t], 然后 Rep(Gt) = {cons,ANNO,Rep(Gt_h),Rep(Gt_t)}。
+        If Gt is a function call A(Gt_1, ..., Gt_k), 其中A是一个原子，那么 Rep(Gt) = {call,ANNO,Rep(A),[Rep(Gt_1), ..., Rep (Gt_k)]}。
+        If Gt is a function call A_m:A(Gt_1, ..., Gt_k),其中A_m是原子erlang并且A是原子或运算符，则 Rep(Gt) = {call,ANNO,{remote,ANNO, Rep(A_m),Rep(A)},[Rep(Gt_1), ..., Rep(Gt_k)]} .
+        If Gt is a map creation #{A_1, ..., A_k}, 其中每个A_i是一个关联Gt_i_1 => Gt_i_2，那么 Rep(Gt) = {map,ANNO,[Rep(A_1), ..., Rep (A_k)]}。对于Rep(A)，见上文。
+        If Gt is a map update Gt_0#{A_1, ..., A_k}, 其中每个A_i是一个关联Gt_i_1 => Gt_i_2 或Gt_i_1 := Gt_i_2，则 Rep(Gt) = {map,ANNO,Rep(Gt_0), [Rep(A_1), ..., Rep(A_k)]} . 对于Rep(A)，见上文。
+        If Gt is nil, [], 则 Rep(Gt) = {nil,ANNO}。
+        If Gt is an operator guard test Gt_1 Op Gt_2,其中Op是除 match operator =之外的二元运算符，则 Rep(Gt) = {op,ANNO,Op,Rep(Gt_1),Rep(Gt_2)}。
+        If Gt is an operator guard test Op Gt_0, 其中Op是一元运算符，则 Rep(Gt) = {op,ANNO,Op,Rep(Gt_0)}。
+        If Gt is a parenthesized guard test ( Gt_0 ), 那么 Rep(Gt) = Rep(Gt_0)，即括号内的守卫测试无法与其主体区分开来。
+        If Gt is a record creation #Name{Field_1=Gt_1, ..., Field_k=Gt_k},其中每个Field_i是一个原子或_，则 Rep(Gt) = {record,ANNO,Name,[{record_field,ANNO, Rep(Field_1),Rep(Gt_1)}, ..., {record_field,ANNO,Rep(Field_k),Rep(Gt_k)}]}。
+        If Gt is a record field access Gt_0#Name.Field,其中Field是原子，则 Rep(Gt) = {record_field,ANNO,Rep(Gt_0),Name,Rep(Field)}。
+        If Gt is a record field index #Name.Field, 其中Field是原子，则 Rep(Gt) = {record_index,ANNO,Name,Rep(Field)}。
+        If Gt is a tuple skeleton {Gt_1, ..., Gt_k}, 则 Rep(Gt) = {tuple,ANNO,[Rep(Gt_1), ..., Rep(Gt_k)]}。
+        If Gt is a variable pattern V, then Rep(Gt) = {var,ANNO,A}, 其中 A 是一个原子，其打印名称由与V相同的字符组成。
 
     请注意，每个保护测试都与某个表达式具有相同的源形式，并以与相应表达式相同的方式表示。
 
 # 8.7 类型
-    如果 T 是带注释的类型A :: T_0，其中A是变量，则 Rep(T) = {ann_type,ANNO,[Rep(A),Rep(T_0)]}。
-    如果 T 是原子、字符或整数文字 L，则 Rep(T) = Rep(L)。
-    如果 T 是位串类型<<_:M,_:_*N>>，其中M和N是单例整数类型，则 Rep(T) = {type,ANNO,binary,[Rep(M),Rep( N)]}。
-    如果 T 是空列表类型[]，则 Rep(T) = {type,ANNO,nil,[]}，即空列表类型 []无法与预定义类型nil()区分开来 。
-    如果 T 是一个有趣的类型fun()，那么 Rep(T) = {type,ANNO,'fun',[]}。
-    如果 T 是一个有趣的类型fun((...) -> T_0)，那么 Rep(T) = {type,ANNO,'fun',[{type,ANNO,any},Rep(T_0)]}。
-    如果 T 是一个有趣的类型fun(Ft)，其中 Ft是一个函数类型，那么 Rep(T) = Rep(Ft)。对于Rep(Ft)，见下文。
-    如果 T 是整数范围类型L .. H，其中L和H是单例整数类型，则 Rep(T) = {type,ANNO,range,[Rep(L),Rep(H)]}。
-    如果 T 是地图类型map()，则 Rep(T) = {type,ANNO,map,any}。
-    如果 T 是映射类型#{A_1, ..., A_k}，其中每个 A_i是关联类型，则 Rep(T) = {type,ANNO,map,[Rep(A_1), ..., Rep( A_k)]}。对于Rep(A)，见下文。
-    如果 T 是运算符类型T_1 Op T_2，其中Op是二元运算符（这是可以在编译时计算为整数的表达式的出现），则 Rep(T) = {op,ANNO,Op,Rep (T_1),Rep(T_2)} .
-    如果 T 是运算符类型Op T_0，其中Op是一元运算符（这是一个可以在编译时计算为整数的表达式的出现），则 Rep(T) = {op,ANNO,Op,Rep( T_0)}。
-    如果 T 是( T_0 )，则 Rep(T) = Rep(T_0)，即括号中的类型无法与其主体区分开来。
-    如果 T 是预定义（或内置）类型N(T_1, ..., T_k)，则 Rep(T) = {type,ANNO,N,[Rep(T_1), ..., Rep(T_k) ]}。
-    如果 T 是记录类型#Name{F_1, ..., F_k}，其中每个F_i是记录字段类型，则 Rep(T) = {type,ANNO,record,[Rep(Name),Rep(F_1) , ..., Rep(F_k)]}。对于Rep(F)，见下文。
-    如果 T 是远程类型M:N(T_1, ..., T_k)，则 Rep(T) = {remote_type,ANNO,[Rep(M),Rep(N),[Rep(T_1), ... , Rep(T_k)]]}。
-    如果 T 是元组类型tuple()，则 Rep(T) = {type,ANNO,tuple,any}。
-    如果 T 是元组类型{T_1, ..., T_k}，则 Rep(T) = {type,ANNO,tuple,[Rep(T_1), ..., Rep(T_k)]}。
-    如果 T 是类型联合T_1 | ... | T_k，然后 Rep(T) = {type,ANNO,union,[Rep(T_1), ..., Rep(T_k)]}。
-    如果 T 是类型变量V，则 Rep(T) = {var,ANNO,A}，其中A是一个原子，其打印名称由与V相同的字符组成。类型变量是除下划线 ( _ )之外的任何变量。
-    如果 T 是用户定义的类型N(T_1, ..., T_k)，则 Rep(T) = {user_type,ANNO,N,[Rep(T_1), ..., Rep(T_k)]}。
+    If T is an annotated type A :: T_0, 其中A是变量，则 Rep(T) = {ann_type,ANNO,[Rep(A),Rep(T_0)]}。
+    If T is an atom, a character, or an integer literal L,则 Rep(T) = Rep(L)。
+    If T is a bitstring type <<_:M,_:_*N>>,其中M和N是单例整数类型，则 Rep(T) = {type,ANNO,binary,[Rep(M),Rep( N)]}。
+    If T is the empty list type [],则 Rep(T) = {type,ANNO,nil,[]}，即空列表类型 []无法与预定义类型nil()区分开来 。
+    If T is a fun type fun(),那么 Rep(T) = {type,ANNO,'fun',[]}。
+    If T is a fun type fun((...) -> T_0), 那么 Rep(T) = {type,ANNO,'fun',[{type,ANNO,any},Rep(T_0)]}。
+    If T is a fun type fun(Ft),其中 Ft是一个函数类型，那么 Rep(T) = Rep(Ft)。对于Rep(Ft)，见下文。
+    If T is an integer range type L .. H,其中L和H是单例整数类型，则 Rep(T) = {type,ANNO,range,[Rep(L),Rep(H)]}。
+    If T is a map type map(),则 Rep(T) = {type,ANNO,map,any}。
+    If T is a map type #{A_1, ..., A_k},其中每个 A_i是关联类型，则 Rep(T) = {type,ANNO,map,[Rep(A_1), ..., Rep( A_k)]}。对于Rep(A)，见下文。
+    If T is an operator type T_1 Op T_2,其中Op是二元运算符（这是可以在编译时计算为整数的表达式的出现），则 Rep(T) = {op,ANNO,Op,Rep (T_1),Rep(T_2)} .
+    If T is an operator type Op T_0, 其中Op是一元运算符（这是一个可以在编译时计算为整数的表达式的出现），则 Rep(T) = {op,ANNO,Op,Rep( T_0)}。
+    If T is ( T_0 ), 则 Rep(T) = Rep(T_0)，即括号中的类型无法与其主体区分开来。
+    If T is a predefined (or built-in) type N(T_1, ..., T_k), 则 Rep(T) = {type,ANNO,N,[Rep(T_1), ..., Rep(T_k) ]}。
+    If T is a record type #Name{F_1, ..., F_k}, 其中每个F_i是记录字段类型，则 Rep(T) = {type,ANNO,record,[Rep(Name),Rep(F_1) , ..., Rep(F_k)]}。对于Rep(F)，见下文。
+    If T is a remote type M:N(T_1, ..., T_k),则 Rep(T) = {remote_type,ANNO,[Rep(M),Rep(N),[Rep(T_1), ... , Rep(T_k)]]}。
+    If T is a tuple type tuple(), 则 Rep(T) = {type,ANNO,tuple,any}。
+    If T is a tuple type {T_1, ..., T_k},则 Rep(T) = {type,ANNO,tuple,[Rep(T_1), ..., Rep(T_k)]}。
+    If T is a type union T_1 | ... | T_k,然后 Rep(T) = {type,ANNO,union,[Rep(T_1), ..., Rep(T_k)]}。
+    If T is a type variable V, then Rep(T) = {var,ANNO,A}, 其中A是一个原子，其打印名称由与V相同的字符组成。类型变量是除下划线 ( _ )之外的任何变量。
+    If T is a user-defined type N(T_1, ..., T_k), 则 Rep(T) = {user_type,ANNO,N,[Rep(T_1), ..., Rep(T_k)]}。
 
 ## Function Types
     函数类型 Ft 是以下之一：
-        如果 Ft 是Fc 时的约束函数类型Ft_1，其中Ft_1是函数类型而 Fc是函数约束，则 Rep(T) = {type,ANNO,bounded_fun,[Rep(Ft_1),Rep(Fc)]}。对于Rep(Fc)，见下文。
-        如果 Ft 是一个函数类型(T_1, ..., T_n) -> T_0，其中每个T_i都是一个类型，那么 Rep(Ft) = {type,ANNO,'fun',[{type,ANNO,product,[ Rep(T_1), ..., Rep(T_n)]},Rep(T_0)]} .
+        If Ft is a constrained function type Ft_1 when Fc, 其中Ft_1是函数类型而 Fc是函数约束，则 Rep(T) = {type,ANNO,bounded_fun,[Rep(Ft_1),Rep(Fc)]}。对于Rep(Fc)，见下文。
+        If Ft is a function type (T_1, ..., T_n) -> T_0, 其中每个T_i都是一个类型，那么 Rep(Ft) = {type,ANNO,'fun',[{type,ANNO,product,[ Rep(T_1), ..., Rep(T_n)]},Rep(T_0)]} .
 
 ## Function Constraints
     函数约束 Fc 是约束C_1, ..., C_k和 Rep(Fc) = [Rep(C_1), ..., Rep(C_k)]的非空序列 。
-    如果 C 是约束V :: T，其中V是类型变量，T是类型，则 Rep(C) = {type,ANNO,constraint,[{atom,ANNO,is_subtype},[Rep(V),代表(T)]]}。
+        If C is a constraint V :: T,，其中V是类型变量，T是类型，则 Rep(C) = {type,ANNO,constraint,[{atom,ANNO,is_subtype},[Rep(V),代表(T)]]}。
 
 ## Association Types
-    如果 A 是关联类型K => V，其中K和V是类型，则 Rep(A) = {type,ANNO,map_field_assoc,[Rep(K),Rep(V)]}。
-    如果 A 是关联类型K := V，其中K和V是类型，则 Rep(A) = {type,ANNO,map_field_exact,[Rep(K),Rep(V)]}。
+    If A is an association type K => V, 其中K和V是类型，则 Rep(A) = {type,ANNO,map_field_assoc,[Rep(K),Rep(V)]}。
+    If A is an association type K := V, 其中K和V是类型，则 Rep(A) = {type,ANNO,map_field_exact,[Rep(K),Rep(V)]}。
 
 ## Record Field Types
-    如果 F 是记录字段类型Name :: Type，其中Type是类型，则 Rep(F) = {type,ANNO,field_type,[Rep(Name),Rep(Type)]}。
+    If F is a record field type Name :: Type, 其中Type是类型，则 Rep(F) = {type,ANNO,field_type,[Rep(Name),Rep(Type)]}。
 
 # 8.8  The Abstract Format after Preprocessing
     编译选项debug_info可以指定给编译器，以便将抽象代码存储在Beam 文件的abstract_code块中（用于调试）。