Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
erl_syntax(3)		   Erlang Module Definition		 erl_syntax(3)

NAME
       erl_syntax - Abstract Erlang syntax trees.

DESCRIPTION
       Abstract	Erlang syntax trees.

       This  module  defines  an  abstract  data  type for representing	Erlang
       source code as syntax trees, in a way that is backwards compatible with
       the  data structures created by the Erlang standard library parser mod-
       ule erl_parse (often referred to	as "parse trees", which	is a bit of  a
       misnomer).  This	means that all erl_parse trees are valid abstract syn-
       tax trees, but the reverse is not true: abstract	syntax	trees  can  in
       general	not be used as input to	functions expecting an erl_parse tree.
       However,	as long	as an abstract syntax tree represents a	correct	Erlang
       program,	 the  function	revert/1 should	be able	to transform it	to the
       corresponding erl_parse representation.

       A recommended starting point for	the first-time user is the  documenta-
       tion of the syntaxTree()	data type, and the function type/1.

       NOTES:

       This  module  deals with	the composition	and decomposition of syntactic
       entities	(as opposed to semantic	ones); its purpose is to hide all  di-
       rect  references	 to  the data structures used to represent these enti-
       ties. With few exceptions, the functions	in this	module perform no  se-
       mantic  interpretation of their inputs, and in general, the user	is as-
       sumed to	pass type-correct arguments - if this is not done, the effects
       are not defined.

       With  the  exception  of	 the erl_parse() data structures, the internal
       representations of abstract syntax trees	are subject to change  without
       notice,	and should not be documented outside this module. Furthermore,
       we do not give any guarantees on	how an abstract	syntax tree may	or may
       not  be	represented,  with the following exceptions: no	syntax tree is
       represented by a	single atom, such as none, by a	list constructor [X  |
       Y],  or	by the empty list []. This can be relied on when writing func-
       tions that operate on syntax trees.

DATA TYPES
	 annotation_or_location() = erl_anno:anno() | erl_anno:location():

	 encoding() = utf8 | unicode | latin1:

	 erl_parse() = erl_parse:abstract_clause() | erl_parse:abstract_expr()
	 |    erl_parse:abstract_form()	   |	erl_parse:abstract_type()    |
	 erl_parse:form_info()	   |	 erl_parse:af_binelement(term())     |
	 erl_parse:af_generator() | erl_parse:af_remote_function():

	 forms() = syntaxTree()	| [syntaxTree()]:

	 guard() = none	| syntaxTree() | [syntaxTree()]	| [[syntaxTree()]]:

	 padding() = none | integer():

	 syntaxTree() =	tree() | wrapper() | erl_parse():

	 syntaxTreeAttributes()	 =  #attr{pos=term(), ann=[term()], com=none |
	 #com{pre=[syntaxTree()], post=[syntaxTree()]}}:

	 tree()	 =  #tree{type=atom(),	attr=#attr{pos=term(),	 ann=[term()],
	 com=none     |	    #com{pre=[syntaxTree()],	post=[syntaxTree()]}},
	 data=term()}:

	 wrapper()     =     #wrapper{type=atom(),	attr=#attr{pos=term(),
	 ann=[term()],	 com=none   |  #com{pre=[syntaxTree()],	 post=[syntax-
	 Tree()]}}, tree=erl_parse()}:

EXPORTS
       abstract(T::term()) -> syntaxTree()

	      Returns the syntax tree corresponding to an  Erlang  term.  Term
	      must  be	a literal term,	i.e., one that can be represented as a
	      source code literal. Thus, it may	not contain a process  identi-
	      fier,  port, reference or	function value as a subterm. The func-
	      tion recognises printable	strings, in order to get a compact and
	      readable	representation.	Evaluation fails with reason badarg if
	      Term is not a literal term.

	      See also:	concrete/1, is_literal/1.

       add_ann(A::term(), Node::syntaxTree()) -> syntaxTree()

	      Appends the term Annotation to the list of user  annotations  of
	      Node.

	      Note:   this   is	 equivalent  to	 set_ann(Node,	[Annotation  |
	      get_ann(Node)]), but potentially more efficient.

	      See also:	get_ann/1, set_ann/2.

       add_postcomments(Cs::[syntaxTree()],  Node::syntaxTree())  ->   syntax-
       Tree()

	      Appends Comments to the post-comments of Node.

	      Note:  This is equivalent	to set_postcomments(Node, get_postcom-
	      ments(Node) ++ Comments),	but potentially	more efficient.

	      See  also:  add_precomments/2,  comment/2,   get_postcomments/1,
	      join_comments/2, set_postcomments/2.

       add_precomments(Cs::[syntaxTree()], Node::syntaxTree()) -> syntaxTree()

	      Appends Comments to the pre-comments of Node.

	      Note:  This  is  equivalent to set_precomments(Node, get_precom-
	      ments(Node) ++ Comments),	but potentially	more efficient.

	      See  also:  add_postcomments/2,  comment/2,   get_precomments/1,
	      join_comments/2, set_precomments/2.

       annotated_type(Name::syntaxTree(), Type::syntaxTree()) -> syntaxTree()

	      Creates an abstract annotated type expression. The result	repre-
	      sents "Name :: Type".

	      See also:	annotated_type_body/1, annotated_type_name/1.

       annotated_type_body(Node::syntaxTree()) -> syntaxTree()

	      Returns the type subtrees	of an annotated_type node.

	      See also:	annotated_type/2.

       annotated_type_name(Node::syntaxTree()) -> syntaxTree()

	      Returns the name subtree of an annotated_type node.

	      See also:	annotated_type/2.

       application(Operator::syntaxTree(), Arguments::[syntaxTree()]) ->  syn-
       taxTree()

	      Creates  an  abstract  function application expression. If Argu-
	      ments is [A1, ..., An], the result represents "Operator(A1, ...,
	      An)".

	      See   also:   application/3,  application_arguments/1,  applica-
	      tion_operator/1.

       application(Module::none	 |  syntaxTree(),  Name::syntaxTree(),	 Argu-
       ments::[syntaxTree()]) -> syntaxTree()

	      Creates  an  abstract function application expression. If	Module
	      is none, this is call is equivalent to application(Function, Ar-
	      guments),	otherwise it is	equivalent to application(module_qual-
	      ifier(Module, Function), Arguments).

	      (This is a utility function.)

	      See also:	application/2, module_qualifier/2.

       application_arguments(Node::syntaxTree()) -> [syntaxTree()]

	      Returns the list of argument subtrees of an application node.

	      See also:	application/2.

       application_operator(Node::syntaxTree())	-> syntaxTree()

	      Returns the operator subtree of an application node.

	      Note: if Node represents "M:F(...)", then	the result is the sub-
	      tree representing	"M:F".

	      See also:	application/2, module_qualifier/2.

       arity_qualifier(Body::syntaxTree(),   Arity::syntaxTree())  ->  syntax-
       Tree()

	      Creates an  abstract  arity  qualifier.  The  result  represents
	      "Body/Arity".

	      See also:	arity_qualifier_argument/1, arity_qualifier_body/1.

       arity_qualifier_argument(Node::syntaxTree()) -> syntaxTree()

	      Returns  the  argument (the arity) subtree of an arity_qualifier
	      node.

	      See also:	arity_qualifier/2.

       arity_qualifier_body(Node::syntaxTree())	-> syntaxTree()

	      Returns the body subtree of an arity_qualifier node.

	      See also:	arity_qualifier/2.

       atom(Name::atom() | string()) ->	syntaxTree()

	      Creates an abstract atom literal.	The print name of the atom  is
	      the character sequence represented by Name.

	      See    also:    atom_literal/1,	atom_literal/2,	  atom_name/1,
	      atom_value/1, is_atom/2.

       atom_literal(Node::syntaxTree())	-> string()

	      Returns the literal string represented by	an atom	node. This in-
	      cludes surrounding single-quote characters if necessary. Charac-
	      ters beyond 255 will be escaped.

	      Note that	e.g. the result	of atom("x\ny")	represents any and all
	      of `x\ny'', `x\12y'', `x\012y'' and `x\^Jy\''; see string/1.

	      See also:	atom/1,	string/1.

       atom_literal(Node, X2) -> term()

	      Returns the literal string represented by	an atom	node. This in-
	      cludes surrounding single-quote characters if necessary. Depend-
	      ing  on  the  encoding  a	 character  beyond 255 will be escaped
	      (latin1) or copied as is (utf8).

	      See also:	atom/1,	atom_literal/1,	string/1.

       atom_name(Node::syntaxTree()) ->	string()

	      Returns the printname of an atom node.

	      See also:	atom/1.

       atom_value(Node::syntaxTree()) -> atom()

	      Returns the value	represented by an atom node.

	      See also:	atom/1.

       attribute(Name::syntaxTree()) ->	syntaxTree()

	      Equivalent to attribute(Name, none).

       attribute(Name::syntaxTree(), Args::none	| [syntaxTree()])  ->  syntax-
       Tree()

	      Creates an abstract program attribute. If	Arguments is [A1, ...,
	      An], the result represents "-Name(A1, ..., An).".	Otherwise,  if
	      Arguments	 is  none,  the	result represents "-Name.". The	latter
	      form makes it possible to	represent preprocessor directives such
	      as "-endif.". Attributes are source code forms.

	      Note: The	preprocessor macro definition directive	"-define(Name,
	      Body)." has relatively few requirements on the syntactical  form
	      of Body (viewed as a sequence of tokens).	The text node type can
	      be used for a Body that is not a normal Erlang construct.

	      See also:	attribute/1, attribute_arguments/1,  attribute_name/1,
	      is_form/1, text/1.

       attribute_arguments(Node::syntaxTree()) -> none | [syntaxTree()]

	      Returns  the  list of argument subtrees of an attribute node, if
	      any. If Node represents "-Name.",	the result is none. Otherwise,
	      if  Node	represents "-Name(E1, ..., En).", [E1, ..., E1]	is re-
	      turned.

	      See also:	attribute/1.

       attribute_name(Node::syntaxTree()) -> syntaxTree()

	      Returns the name subtree of an attribute node.

	      See also:	attribute/1.

       binary(List::[syntaxTree()]) -> syntaxTree()

	      Creates an abstract binary-object	template. If  Fields  is  [F1,
	      ..., Fn],	the result represents "__F1, ..., Fn__".

	      See also:	binary_field/2,	binary_fields/1.

       binary_comp(Template::syntaxTree(),  Body::[syntaxTree()])  ->  syntax-
       Tree()

	      Creates an abstract binary comprehension.	If Body	is  [E1,  ...,
	      En], the result represents "__Template ||	E1, ..., En__".

	      See  also:  binary_comp_body/1,  binary_comp_template/1, genera-
	      tor/2.

       binary_comp_body(Node::syntaxTree()) -> [syntaxTree()]

	      Returns the list of body subtrees	of a binary_comp node.

	      See also:	binary_comp/2.

       binary_comp_template(Node::syntaxTree())	-> syntaxTree()

	      Returns the template subtree of a	binary_comp node.

	      See also:	binary_comp/2.

       binary_field(Body::syntaxTree())	-> syntaxTree()

	      Equivalent to binary_field(Body, []).

       binary_field(Body::syntaxTree(),	Types::[syntaxTree()]) -> syntaxTree()

	      Creates an abstract binary template field. If Types is the empty
	      list,  the  result simply	represents "Body", otherwise, if Types
	      is [T1, ..., Tn],	the result represents "Body/T1-...-Tn".

	      See  also:   binary/1,   binary_field/1,	 binary_field/3,   bi-
	      nary_field_body/1, binary_field_size/1, binary_field_types/1.

       binary_field(Body::syntaxTree(),	    Size::none	   |	 syntaxTree(),
       Types::[syntaxTree()]) -> syntaxTree()

	      Creates an abstract binary template field. If Size is none, this
	      is  equivalent  to  "binary_field(Body, Types)", otherwise it is
	      equivalent to "binary_field(size_qualifier(Body, Size), Types)".

	      (This is a utility function.)

	      See also:	binary/1, binary_field/2, size_qualifier/2.

       binary_field_body(Node::syntaxTree()) ->	syntaxTree()

	      Returns the body subtree of a binary_field.

	      See also:	binary_field/2.

       binary_field_size(Node::syntaxTree()) ->	none | syntaxTree()

	      Returns the size specifier subtree of a  binary_field  node,  if
	      any.  If Node represents "Body:Size" or "Body:Size/T1, ..., Tn",
	      the result is Size, otherwise none is returned.

	      (This is a utility function.)

	      See also:	binary_field/2,	binary_field/3.

       binary_field_types(Node::syntaxTree()) -> [syntaxTree()]

	      Returns the list of type-specifier subtrees  of  a  binary_field
	      node.  If	 Node represents ".../T1, ..., Tn", the	result is [T1,
	      ..., Tn],	otherwise the result is	the empty list.

	      See also:	binary_field/2.

       binary_fields(Node::syntaxTree()) -> [syntaxTree()]

	      Returns the list of field	subtrees of a binary node.

	      See also:	binary/1, binary_field/2.

       binary_generator(Pattern::syntaxTree(), Body::syntaxTree()) ->  syntax-
       Tree()

	      Creates  an  abstract  binary_generator.	The  result represents
	      "Pattern _- Body".

	      See also:	binary_comp/2, binary_generator_body/1,	binary_genera-
	      tor_pattern/1, list_comp/2.

       binary_generator_body(Node::syntaxTree()) -> syntaxTree()

	      Returns the body subtree of a generator node.

	      See also:	binary_generator/2.

       binary_generator_pattern(Node::syntaxTree()) -> syntaxTree()

	      Returns the pattern subtree of a generator node.

	      See also:	binary_generator/2.

       bitstring_type(M::syntaxTree(), N::syntaxTree())	-> syntaxTree()

	      Creates  an  abstract  bitstring	type.  The  result  represents
	      "___:M, _:_*N__".

	      See also:	bitstring_type_m/1, bitstring_type_n/1.

       bitstring_type_m(Node::syntaxTree()) -> syntaxTree()

	      Returns the number of start bits,	M, of a	bitstring_type node.

	      See also:	bitstring_type/2.

       bitstring_type_n(Node::syntaxTree()) -> syntaxTree()

	      Returns the segment size,	N, of a	bitstring_type node.

	      See also:	bitstring_type/2.

       block_expr(Body::[syntaxTree()])	-> syntaxTree()

	      Creates an abstract block	expression. If Body is [B1, ...,  Bn],
	      the result represents "begin B1, ..., Bn end".

	      See also:	block_expr_body/1.

       block_expr_body(Node::syntaxTree()) -> [syntaxTree()]

	      Returns the list of body subtrees	of a block_expr	node.

	      See also:	block_expr/1.

       case_expr(Argument::syntaxTree(),  Clauses::[syntaxTree()])  -> syntax-
       Tree()

	      Creates an abstract case-expression. If  Clauses	is  [C1,  ...,
	      Cn],  the	 result	represents "case Argument of C1; ...; Cn end".
	      More exactly, if each Ci represents "(Pi)	Gi -_  Bi",  then  the
	      result  represents  "case	Argument of P1 G1 -_ B1; ...; Pn Gn -_
	      Bn end".

	      See also:	case_expr_argument/1,  case_expr_clauses/1,  clause/3,
	      if_expr/1.

       case_expr_argument(Node::syntaxTree()) -> syntaxTree()

	      Returns the argument subtree of a	case_expr node.

	      See also:	case_expr/2.

       case_expr_clauses(Node::syntaxTree()) ->	[syntaxTree()]

	      Returns the list of clause subtrees of a case_expr node.

	      See also:	case_expr/2.

       catch_expr(Expr::syntaxTree()) -> syntaxTree()

	      Creates  an  abstract  catch-expression.	The  result represents
	      "catch Expr".

	      See also:	catch_expr_body/1.

       catch_expr_body(Node::syntaxTree()) -> syntaxTree()

	      Returns the body subtree of a catch_expr node.

	      See also:	catch_expr/1.

       char(Char::char()) -> syntaxTree()

	      Creates an abstract character  literal.  The  result  represents
	      "$Name", where Name corresponds to Value.

	      Note:  the literal corresponding to a particular character value
	      is not uniquely defined. E.g., the character "a" can be  written
	      both  as "$a" and	"$\141", and a Tab character can be written as
	      "$\11", "$\011" or "$\t".

	      See   also:   char_literal/1,   char_literal/2,	 char_value/1,
	      is_char/2.

       char_literal(Node::syntaxTree())	-> nonempty_string()

	      Returns  the literal string represented by a char	node. This in-
	      cludes the leading "$" character.	Characters beyond 255 will  be
	      escaped.

	      See also:	char/1.

       char_literal(Node::syntaxTree(),	X2::encoding())	-> nonempty_string()

	      Returns  the literal string represented by a char	node. This in-
	      cludes the leading "$" character.	Depending on  the  encoding  a
	      character	 beyond	 255  will be escaped (latin1) or copied as is
	      (utf8).

	      See also:	char/1.

       char_value(Node::syntaxTree()) -> char()

	      Returns the value	represented by a char node.

	      See also:	char/1.

       class_qualifier(Class::syntaxTree(),  Body::syntaxTree())  ->   syntax-
       Tree()

	      Creates  an  abstract  class  qualifier.	The  result represents
	      "Class:Body".

	      See  also:  class_qualifier_argument/1,  class_qualifier_body/1,
	      class_qualifier_stacktrace/1, try_expr/4.

       class_qualifier(Class::syntaxTree(),	Body::syntaxTree(),	Stack-
       trace::syntaxTree()) -> syntaxTree()

	      Creates an  abstract  class  qualifier.  The  result  represents
	      "Class:Body:Stacktrace".

	      See  also:  class_qualifier_argument/1,  class_qualifier_body/1,
	      try_expr/4.

       class_qualifier_argument(Node::syntaxTree()) -> syntaxTree()

	      Returns the argument (the	class) subtree	of  a  class_qualifier
	      node.

	      See also:	class_qualifier/2.

       class_qualifier_body(Node::syntaxTree())	-> syntaxTree()

	      Returns the body subtree of a class_qualifier node.

	      See also:	class_qualifier/2.

       class_qualifier_stacktrace(Node::syntaxTree()) -> syntaxTree()

	      Returns the stacktrace subtree of	a class_qualifier node.

	      See also:	class_qualifier/2.

       clause(Guard::guard(), Body::[syntaxTree()]) -> syntaxTree()

	      Equivalent to clause([], Guard, Body).

       clause(Patterns::[syntaxTree()],	 Guard::guard(), Body::[syntaxTree()])
       -> syntaxTree()

	      Creates an abstract clause. If Patterns is  [P1,	...,  Pn]  and
	      Body  is [B1, ..., Bm], then if Guard is none, the result	repre-
	      sents "(P1, ..., Pn) -_ B1, ..., Bm", otherwise, unless Guard is
	      a	 list,	the result represents "(P1, ..., Pn) when Guard	-_ B1,
	      ..., Bm".

	      For simplicity, the Guard	argument may also be any of  the  fol-
	      lowing:

		* An empty list	[]. This is equivalent to passing none.

		* A  nonempty  list  [E1,  ...,	 Ej]  of syntax	trees. This is
		  equivalent to	passing	conjunction([E1, ..., Ej]).

		* A nonempty list  of  lists  of  syntax  trees	 [[E1_1,  ...,
		  E1_k1],  ...,	 [Ej_1,	 ...,  Ej_kj]],	which is equivalent to
		  passing disjunction([conjunction([E1_1, ...,	E1_k1]),  ...,
		  conjunction([Ej_1, ..., Ej_kj])]).

	      See  also:  clause/2, clause_body/1, clause_guard/1, clause_pat-
	      terns/1.

       clause_body(Node::syntaxTree()) -> [syntaxTree()]

	      Return the list of body subtrees of a clause node.

	      See also:	clause/3.

       clause_guard(Node::syntaxTree())	-> none	| syntaxTree()

	      Returns the guard	subtree	of a clause node, if any. If Node rep-
	      resents  "(P1, ..., Pn) when Guard -_ B1,	..., Bm", Guard	is re-
	      turned. Otherwise, the result is none.

	      See also:	clause/3.

       clause_patterns(Node::syntaxTree()) -> [syntaxTree()]

	      Returns the list of pattern subtrees of a	clause node.

	      See also:	clause/3.

       comment(Strings::[string()]) -> syntaxTree()

	      Equivalent to comment(none, Strings).

       comment(Pad::padding(), Strings::[string()]) -> syntaxTree()

	      Creates an abstract comment with the given padding and text.  If
	      Strings  is  a  (possibly	empty) list ["Txt1", ..., "TxtN"], the
	      result represents	the source code	text

		   %Txt1
		   ...
		   %TxtN

	      Padding states the number	of empty character  positions  to  the
	      left  of the comment separating it horizontally from source code
	      on the same line (if any). If Padding is none, a	default	 posi-
	      tive number is used. If Padding is an integer less than 1, there
	      should be	no separating space. Comments are  in  themselves  re-
	      garded as	source program forms.

	      See also:	comment/1, is_form/1.

       comment_padding(Node::syntaxTree()) -> padding()

	      Returns  the  amount of padding before the comment, or none. The
	      latter means that	a default padding may be used.

	      See also:	comment/2.

       comment_text(Node::syntaxTree())	-> [string()]

	      Returns the lines	of text	of the abstract	comment.

	      See also:	comment/2.

       compact_list(Node::syntaxTree())	-> syntaxTree()

	      Yields the most compact form for an abstract list	skeleton.  The
	      result  either  represents "[E1, ..., En | Tail]", where Tail is
	      not a list skeleton, or otherwise	simply "[E1, ..., En]".	 Anno-
	      tations on subtrees of Node that represent list skeletons	may be
	      lost, but	comments will be propagated  to	 the  result.  Returns
	      Node itself if Node does not represent a list skeleton.

	      See also:	list/2,	normalize_list/1.

       concrete(Node::syntaxTree()) -> term()

	      Returns the Erlang term represented by a syntax tree. Evaluation
	      fails with reason	badarg if Node does not	 represent  a  literal
	      term.

	      Note:  Currently,	 the set of syntax trees which have a concrete
	      representation is	larger than the	set  of	 trees	which  can  be
	      built  using the function	abstract/1. An abstract	character will
	      be concretised as	an  integer,  while  abstract/1	 does  not  at
	      present  yield  an  abstract  character  for any input. (Use the
	      char/1 function to explicitly create an abstract character.)

	      Note: arity_qualifier nodes are recognized. This	is  to	follow
	      The  Erlang Parser when it comes to wild attributes: both	{F, A}
	      and F/A are recognized, which makes it possible to turn wild at-
	      tributes	into  recognized  attributes  without at the same time
	      making it	impossible to compile files using the new syntax  with
	      the old version of the Erlang Compiler.

	      See also:	abstract/1, char/1, is_literal/1.

       conjunction(Tests::[syntaxTree()]) -> syntaxTree()

	      Creates  an  abstract conjunction. If List is [E1, ..., En], the
	      result represents	"E1, ..., En".

	      See also:	conjunction_body/1, disjunction/1.

       conjunction_body(Node::syntaxTree()) -> [syntaxTree()]

	      Returns the list of body subtrees	of a conjunction node.

	      See also:	conjunction/1.

       cons(Head::syntaxTree(),	Tail::syntaxTree()) -> syntaxTree()

	      "Optimising" list	skeleton cons operation. Creates  an  abstract
	      list  skeleton whose first element is Head and whose tail	corre-
	      sponds to	Tail. This is similar to  list([Head],	Tail),	except
	      that  Tail  may not be none, and that the	result does not	neces-
	      sarily represent exactly "[Head |	Tail]",	but may	depend on  the
	      Tail  subtree.  E.g.,  if	Tail represents	[X, Y],	the result may
	      represent	"[Head,	X, Y]",	rather than "[Head | [X, Y]]". Annota-
	      tions  on	 Tail  itself  may  be	lost if	Tail represents	a list
	      skeleton,	but comments on	Tail are propagated to the result.

	      See also:	list/2,	list_head/1, list_tail/1.

       constrained_function_type(FunctionType::syntaxTree(),	  FunctionCon-
       straint::[syntaxTree()])	-> syntaxTree()

	      Creates  an  abstract constrained	function type. If FunctionCon-
	      straint is [C1, ..., Cn],	the  result  represents	 "FunctionType
	      when C1, ...Cn".

	      See     also:	constrained_function_type_argument/1,	  con-
	      strained_function_type_body/1.

       constrained_function_type_argument(Node::syntaxTree()) -> syntaxTree()

	      Returns the function constraint subtree of  a  constrained_func-
	      tion_type	node.

	      See also:	constrained_function_type/2.

       constrained_function_type_body(Node::syntaxTree()) -> syntaxTree()

	      Returns the function type	subtree	of a constrained_function_type
	      node.

	      See also:	constrained_function_type/2.

       constraint(Name::syntaxTree(), Types::[syntaxTree()]) ->	syntaxTree()

	      Creates an abstract (subtype) constraint.	The result  represents
	      "Name :: Type".

	      See also:	constraint_argument/1, constraint_body/1.

       constraint_argument(Node::syntaxTree()) -> syntaxTree()

	      Returns the name subtree of a constraint node.

	      See also:	constraint/2.

       constraint_body(Node::syntaxTree()) -> [syntaxTree()]

	      Returns the type subtree of a constraint node.

	      See also:	constraint/2.

       copy_ann(Source::syntaxTree(), Target::syntaxTree()) -> syntaxTree()

	      Copies the list of user annotations from Source to Target.

	      Note:  this  is  equivalent to set_ann(Target, get_ann(Source)),
	      but potentially more efficient.

	      See also:	get_ann/1, set_ann/2.

       copy_attrs(S::syntaxTree(), T::syntaxTree()) -> syntaxTree()

	      Copies the attributes from Source	to Target.

	      Note:  this   is	 equivalent   to   set_attrs(Target,   get_at-
	      trs(Source)), but	potentially more efficient.

	      See also:	get_attrs/1, set_attrs/2.

       copy_comments(Source::syntaxTree(),  Target::syntaxTree())  ->  syntax-
       Tree()

	      Copies the pre- and postcomments from Source to Target.

	      Note:  This  is	equivalent   to	  set_postcomments(set_precom-
	      ments(Target,	  get_precomments(Source)),	  get_postcom-
	      ments(Source)), but potentially more efficient.

	      See  also:  comment/2,  get_postcomments/1,   get_precomments/1,
	      set_postcomments/2, set_precomments/2.

       copy_pos(Source::syntaxTree(), Target::syntaxTree()) -> syntaxTree()

	      Copies the annotation from Source	to Target.

	      This  is equivalent to set_pos(Target, get_pos(Source)), but po-
	      tentially	more efficient.

	      See also:	get_pos/1, set_pos/2.

       data(Tree::syntaxTree())	-> term()

	      For special purposes only. Returns the associated	data of	a syn-
	      tax   tree   node.   Evaluation  fails  with  reason  badarg  if
	      is_tree(Node) does not yield true.

	      See also:	tree/2.

       disjunction(Tests::[syntaxTree()]) -> syntaxTree()

	      Creates an abstract disjunction. If List is [E1, ...,  En],  the
	      result represents	"E1; ...; En".

	      See also:	conjunction/1, disjunction_body/1.

       disjunction_body(Node::syntaxTree()) -> [syntaxTree()]

	      Returns the list of body subtrees	of a disjunction node.

	      See also:	disjunction/1.

       eof_marker() -> syntaxTree()

	      Creates  an abstract end-of-file marker. This represents the end
	      of input when reading a sequence of source code forms.  An  end-
	      of-file marker is	itself regarded	as a source code form (namely,
	      the last in any sequence in which	it occurs). It has no  defined
	      lexical form.

	      Note: this is retained only for backwards	compatibility with ex-
	      isting parsers and tools.

	      See also:	error_marker/1,	is_form/1, warning_marker/1.

       error_marker(Error::term()) -> syntaxTree()

	      Creates an abstract error	marker.	The result represents  an  oc-
	      currence	of an error in the source code,	with an	associated Er-
	      lang I/O ErrorInfo structure given by Error  (see	 module	 io(3)
	      for  details).  Error markers are	regarded as source code	forms,
	      but have no defined lexical form.

	      Note: this is supported only for	backwards  compatibility  with
	      existing parsers and tools.

	      See  also:  eof_marker/0,	 error_marker_info/1, is_form/1, warn-
	      ing_marker/1.

       error_marker_info(Node::syntaxTree()) ->	term()

	      Returns the ErrorInfo structure of an error_marker node.

	      See also:	error_marker/1.

       flatten_form_list(Node::syntaxTree()) ->	syntaxTree()

	      Flattens sublists	of a form_list node.  Returns  Node  with  all
	      subtrees of type form_list recursively expanded, yielding	a sin-
	      gle "flat" abstract form sequence.

	      See also:	form_list/1.

       float(Value::float()) ->	syntaxTree()

	      Creates an abstract floating-point literal. The  lexical	repre-
	      sentation	is the decimal floating-point numeral of Value.

	      See also:	float_literal/1, float_value/1.

       float_literal(Node::syntaxTree()) -> string()

	      Returns the numeral string represented by	a float	node.

	      See also:	float/1.

       float_value(Node::syntaxTree()) -> float()

	      Returns  the value represented by	a float	node. Note that	float-
	      ing-point	values should usually not be compared for equality.

	      See also:	float/1.

       form_list(Forms::[syntaxTree()])	-> syntaxTree()

	      Creates an abstract sequence of "source code forms". If Forms is
	      [F1,  ...,  Fn], where each Fi is	a form (see is_form/1, the re-
	      sult represents

		   F1
		   ...
		   Fn

	      where the	Fi are separated by one	or more	line breaks. A node of
	      type  form_list  is  itself  regarded as a source	code form; see
	      flatten_form_list/1.

	      Note: this is simply a way of grouping source code  forms	 as  a
	      single  syntax  tree,  usually in	order to form an Erlang	module
	      definition.

	      See also:	flatten_form_list/1, form_list_elements/1, is_form/1.

       form_list_elements(Node::syntaxTree()) -> [syntaxTree()]

	      Returns the list of subnodes of a	form_list node.

	      See also:	form_list/1.

       fun_expr(Clauses::[syntaxTree()]) -> syntaxTree()

	      Creates an abstract fun-expression. If Clauses is	[C1, ..., Cn],
	      the  result  represents  "fun C1;	...; Cn	end". More exactly, if
	      each Ci represents "(Pi1,	..., Pim) Gi -_	Bi", then  the	result
	      represents  "fun	(P11, ..., P1m)	G1 -_ B1; ...; (Pn1, ..., Pnm)
	      Gn -_ Bn end".

	      See also:	fun_expr_arity/1, fun_expr_clauses/1.

       fun_expr_arity(Node::syntaxTree()) -> arity()

	      Returns the arity	of a fun_expr node. The	result is  the	number
	      of parameter patterns in the first clause	of the fun-expression;
	      subsequent clauses are ignored.

	      An exception is  thrown  if  fun_expr_clauses(Node)  returns  an
	      empty list, or if	the first element of that list is not a	syntax
	      tree C of	type clause such that clause_patterns(C) is a nonempty
	      list.

	      See     also:	clause/3,    clause_patterns/1,	   fun_expr/1,
	      fun_expr_clauses/1.

       fun_expr_clauses(Node::syntaxTree()) -> [syntaxTree()]

	      Returns the list of clause subtrees of a fun_expr	node.

	      See also:	fun_expr/1.

       fun_type() -> syntaxTree()

	      Creates an abstract fun  of  any	type.  The  result  represents
	      "fun()".

       function(Name::syntaxTree(), Clauses::[syntaxTree()]) ->	syntaxTree()

	      Creates an abstract function definition. If Clauses is [C1, ...,
	      Cn], the result represents "Name C1; ...;	Name  Cn.".  More  ex-
	      actly,  if  each	Ci represents "(Pi1, ..., Pim) Gi -_ Bi", then
	      the result represents  "Name(P11,	 ...,  P1m)  G1	 -_  B1;  ...;
	      Name(Pn1,	 ..., Pnm) Gn -_ Bn.". Function	definitions are	source
	      code forms.

	      See also:	function_arity/1, function_clauses/1, function_name/1,
	      is_form/1.

       function_arity(Node::syntaxTree()) -> arity()

	      Returns  the  arity of a function	node. The result is the	number
	      of parameter patterns in the first clause	of the function;  sub-
	      sequent clauses are ignored.

	      An  exception  is	 thrown	 if  function_clauses(Node) returns an
	      empty list, or if	the first element of that list is not a	syntax
	      tree C of	type clause such that clause_patterns(C) is a nonempty
	      list.

	      See  also:  clause/3,   clause_patterns/1,   function/2,	 func-
	      tion_clauses/1.

       function_clauses(Node::syntaxTree()) -> [syntaxTree()]

	      Returns the list of clause subtrees of a function	node.

	      See also:	function/2.

       function_name(Node::syntaxTree()) -> syntaxTree()

	      Returns the name subtree of a function node.

	      See also:	function/2.

       function_type(Type) -> term()

	      Equivalent to function_type(any_arity, Type).

       function_type(Arguments::any_arity  |  [syntaxTree()],  Return::syntax-
       Tree()) -> syntaxTree()

	      Creates an abstract function type. If  Arguments	is  [T1,  ...,
	      Tn],  then if it occurs within a function	specification, the re-
	      sult represents "(T1, ...Tn) -_ Return"; otherwise it represents
	      "fun((T1,	...Tn) -_ Return)". If Arguments is any_arity, it rep-
	      resents "fun((...) -_ Return)".

	      Note that	the erl_parse representation is	identical  for	"Func-
	      tionType"	and "fun(FunctionType)".

	      See also:	function_type_arguments/1, function_type_return/1.

       function_type_arguments(Node::syntaxTree())  ->	any_arity  |  [syntax-
       Tree()]

	      Returns the argument types subtrees of a function_type node.  If
	      Node  represents	"fun((...) -_ Return)",	any_arity is returned;
	      otherwise,  if  Node  represents	"(T1,  ...Tn)  -_  Return"  or
	      "fun((T1,	...Tn) -_ Return)", [T1, ..., Tn] is returned.

	      See also:	function_type/1, function_type/2.

       function_type_return(Node::syntaxTree())	-> syntaxTree()

	      Returns the return type subtrees of a function_type node.

	      See also:	function_type/1, function_type/2.

       generator(Pattern::syntaxTree(),	Body::syntaxTree()) -> syntaxTree()

	      Creates an abstract generator. The result	represents "Pattern _-
	      Body".

	      See also:	binary_comp/2, generator_body/1,  generator_pattern/1,
	      list_comp/2.

       generator_body(Node::syntaxTree()) -> syntaxTree()

	      Returns the body subtree of a generator node.

	      See also:	generator/2.

       generator_pattern(Node::syntaxTree()) ->	syntaxTree()

	      Returns the pattern subtree of a generator node.

	      See also:	generator/2.

       get_ann(Tree::syntaxTree()) -> [term()]

	      Returns  the  list  of user annotations associated with a	syntax
	      tree node. For a newly created node, this	is the empty list. The
	      annotations may be any terms.

	      See also:	get_attrs/1, set_ann/2.

       get_attrs(Tree::syntaxTree()) ->	syntaxTreeAttributes()

	      Returns  a  representation  of  the attributes associated	with a
	      syntax tree node.	The attributes are all the  extra  information
	      that  can	 be attached to	a node.	Currently, this	includes posi-
	      tion information,	source code comments,  and  user  annotations.
	      The  result  of this function cannot be inspected	directly; only
	      attached to another node (see set_attrs/2).

	      For accessing individual attributes, see	get_pos/1,  get_ann/1,
	      get_precomments/1	and get_postcomments/1.

	      See  also: get_ann/1, get_pos/1, get_postcomments/1, get_precom-
	      ments/1, set_attrs/2.

       get_pos(Tree::syntaxTree()) -> annotation_or_location()

	      Returns the annotation (see erl_anno(3)) associated  with	 Node.
	      By  default,  all	 new tree nodes	have their associated position
	      information set to the integer zero. Use erl_anno:location/1  or
	      erl_anno:line/1 to get the position information.

	      See also:	get_attrs/1, set_pos/2.

       get_postcomments(Tree::syntaxTree()) -> [syntaxTree()]

	      Returns the associated post-comments of a	node. This is a	possi-
	      bly empty	list of	abstract comments, in top-down textual	order.
	      When  the	 code  is  formatted, post-comments are	typically dis-
	      played to	the right of and/or below the node. For	example:

		   {foo, X, Y}	   % Post-comment of tuple

	      If possible, the comment should be moved past any	following sep-
	      arator characters	on the same line, rather than placing the sep-
	      arators on the following line. E.g.:

		   foo([X | Xs], Y) ->
		       foo(Xs, bar(X));	    % Post-comment of 'bar(X)' node
		    ...

	      (where the comment is moved past the rightmost ")" and the ";").

	      See also:	comment/2, get_attrs/1,	 get_precomments/1,  set_post-
	      comments/2.

       get_precomments(Tree::syntaxTree()) -> [syntaxTree()]

	      Returns  the associated pre-comments of a	node. This is a	possi-
	      bly empty	list of	abstract comments, in top-down textual	order.
	      When the code is formatted, pre-comments are typically displayed
	      directly above the node. For example:

		   % Pre-comment of function
		   foo(X) -> {bar, X}.

	      If possible, the comment should be moved	before	any  preceding
	      separator	characters on the same line. E.g.:

		   foo([X | Xs]) ->
		       % Pre-comment of	'bar(X)' node
		       [bar(X) | foo(Xs)];
		   ...

	      (where the comment is moved before the "[").

	      See  also:  comment/2, get_attrs/1, get_postcomments/1, set_pre-
	      comments/2.

       has_comments(Tree::syntaxTree())	-> boolean()

	      Yields false if the node has no associated  comments,  and  true
	      otherwise.

	      Note:  This  is  equivalent to (get_precomments(Node) == []) and
	      (get_postcomments(Node) == []), but potentially more efficient.

	      See  also:  get_postcomments/1,  get_precomments/1,  remove_com-
	      ments/1.

       if_expr(Clauses::[syntaxTree()])	-> syntaxTree()

	      Creates  an abstract if-expression. If Clauses is	[C1, ..., Cn],
	      the result represents "if	C1; ...; Cn  end".  More  exactly,  if
	      each Ci represents "() Gi	-_ Bi",	then the result	represents "if
	      G1 -_ B1;	...; Gn	-_ Bn end".

	      See also:	case_expr/2, clause/3, if_expr_clauses/1.

       if_expr_clauses(Node::syntaxTree()) -> [syntaxTree()]

	      Returns the list of clause subtrees of an	if_expr	node.

	      See also:	if_expr/1.

       implicit_fun(Name::syntaxTree())	-> syntaxTree()

	      Creates an abstract "implicit fun" expression. The result	repre-
	      sents "fun Name".	Name should represent either F/A or M:F/A

	      See also:	arity_qualifier/2, implicit_fun/2, implicit_fun/3, im-
	      plicit_fun_name/1, module_qualifier/2.

       implicit_fun(Name::syntaxTree(),	Arity::none | syntaxTree()) -> syntax-
       Tree()

	      Creates an abstract "implicit fun" expression. If	Arity is none,
	      this is equivalent to implicit_fun(Name),	otherwise it is	equiv-
	      alent to implicit_fun(arity_qualifier(Name, Arity)).

	      (This is a utility function.)

	      See also:	implicit_fun/1,	implicit_fun/3.

       implicit_fun(Module::none   |   syntaxTree(),  Name::syntaxTree(),  Ar-
       ity::syntaxTree()) -> syntaxTree()

	      Creates an abstract module-qualified "implicit fun"  expression.
	      If  Module is none, this is equivalent to	implicit_fun(Name, Ar-
	      ity), otherwise it is equivalent	to  implicit_fun(module_quali-
	      fier(Module, arity_qualifier(Name, Arity)).

	      (This is a utility function.)

	      See also:	implicit_fun/1,	implicit_fun/2.

       implicit_fun_name(Node::syntaxTree()) ->	syntaxTree()

	      Returns the name subtree of an implicit_fun node.

	      Note:  if	Node represents	"fun N/A" or "fun M:N/A", then the re-
	      sult is the subtree representing "N/A" or	"M:N/A", respectively.

	      See also:	arity_qualifier/2, implicit_fun/1, module_qualifier/2.

       infix_expr(Left::syntaxTree(),  Operator::syntaxTree(),	Right::syntax-
       Tree()) -> syntaxTree()

	      Creates an abstract infix	operator expression. The result	repre-
	      sents "Left Operator Right".

	      See   also:   infix_expr_left/1,	 infix_expr_operator/1,	   in-
	      fix_expr_right/1,	prefix_expr/2.

       infix_expr_left(Node::syntaxTree()) -> syntaxTree()

	      Returns the left argument	subtree	of an infix_expr node.

	      See also:	infix_expr/3.

       infix_expr_operator(Node::syntaxTree()) -> syntaxTree()

	      Returns the operator subtree of an infix_expr node.

	      See also:	infix_expr/3.

       infix_expr_right(Node::syntaxTree()) -> syntaxTree()

	      Returns the right	argument subtree of an infix_expr node.

	      See also:	infix_expr/3.

       integer(Value::integer()) -> syntaxTree()

	      Creates  an abstract integer literal. The	lexical	representation
	      is the canonical decimal numeral of Value.

	      See also:	integer_literal/1, integer_value/1, is_integer/2.

       integer_literal(Node::syntaxTree()) -> string()

	      Returns the numeral string represented by	an integer node.

	      See also:	integer/1.

       integer_range_type(Low::syntaxTree(),  High::syntaxTree())  ->  syntax-
       Tree()

	      Creates  an  abstract  range type. The result represents "Low ..
	      High".

	      See also:	integer_range_type_high/1, integer_range_type_low/1.

       integer_range_type_high(Node::syntaxTree()) -> syntaxTree()

	      Returns the high limit of	an integer_range_type node.

	      See also:	integer_range_type/2.

       integer_range_type_low(Node::syntaxTree()) -> syntaxTree()

	      Returns the low limit of an integer_range_type node.

	      See also:	integer_range_type/2.

       integer_value(Node::syntaxTree()) -> integer()

	      Returns the value	represented by an integer node.

	      See also:	integer/1.

       is_atom(Node::syntaxTree(), Value::atom()) -> boolean()

	      Returns true if Node has type atom and represents	Value,	other-
	      wise false.

	      See also:	atom/1.

       is_char(Node::syntaxTree(), Value::char()) -> boolean()

	      Returns  true if Node has	type char and represents Value,	other-
	      wise false.

	      See also:	char/1.

       is_form(Node::syntaxTree()) -> boolean()

	      Returns true if Node is a	syntax tree representing  a  so-called
	      "source code form", otherwise false. Forms are the Erlang	source
	      code units which,	placed in sequence, constitute an Erlang  pro-
	      gram. Current form types are:

	      attribute	comment	error_marker eof_marker
	      form_list	function warning_marker	text

	      See  also: attribute/2, comment/2, eof_marker/0, error_marker/1,
	      form_list/1, function/2, type/1, warning_marker/1.

       is_integer(Node::syntaxTree(), Value::integer())	-> boolean()

	      Returns true if Node has type integer and	represents Value, oth-
	      erwise false.

	      See also:	integer/1.

       is_leaf(Node::syntaxTree()) -> boolean()

	      Returns  true  if	Node is	a leaf node, otherwise false. The cur-
	      rently recognised	leaf node types	are:

	      atom char	comment	eof_marker error_marker
	      float fun_type integer nil operator string
	      text underscore variable warning_marker

	      A	node of	type map_expr is a leaf	node if	and only if it has  no
	      argument	and  no	fields.	A node of type map_type	is a leaf node
	      if and only if it	has no fields (any_size). A node of type tuple
	      is  a leaf node if and only if its arity is zero.	A node of type
	      tuple_type is a leaf node	if and only  if	 it  has  no  elements
	      (any_size).

	      Note: not	all literals are leaf nodes, and vice versa. E.g., tu-
	      ples with	nonzero	arity and nonempty lists may be	literals,  but
	      are not leaf nodes. Variables, on	the other hand,	are leaf nodes
	      but not literals.

	      See also:	is_literal/1, type/1.

       is_list_skeleton(Node::syntaxTree()) -> boolean()

	      Returns true if Node has type list or nil, otherwise false.

	      See also:	list/2,	nil/0.

       is_literal(T::syntaxTree()) -> boolean()

	      Returns true if Node represents a	literal	term, otherwise	false.
	      This  function  returns  true  if	 and only if the value of con-
	      crete(Node) is defined.

	      See also:	abstract/1, concrete/1.

       is_proper_list(Node::syntaxTree()) -> boolean()

	      Returns true if Node represents a	proper list, and false	other-
	      wise.  A	proper list is a list skeleton either on the form "[]"
	      or "[E1, ..., En]", or "[... |  Tail]"  where  recursively  Tail
	      also represents a	proper list.

	      Note:  Since  Node  is a syntax tree, the	actual run-time	values
	      corresponding to its subtrees may	often  be  partially  or  com-
	      pletely  unknown.	 Thus,	if  Node  represents e.g. "[...	| Ns]"
	      (where Ns	is a variable),	then the function will	return	false,
	      because  it  is  not known whether Ns will be bound to a list at
	      run-time.	If Node	instead	represents e.g.	"[1, 2,	3]" or	"[A  |
	      []]", then the function will return true.

	      See also:	list/2.

       is_string(Node::syntaxTree(), Value::string()) -> boolean()

	      Returns  true if Node has	type string and	represents Value, oth-
	      erwise false.

	      See also:	string/1.

       is_tree(Tree::syntaxTree()) -> boolean()

	      For special purposes only. Returns true if Tree is  an  abstract
	      syntax tree and false otherwise.

	      Note:  this function yields false	for all	"old-style" erl_parse-
	      compatible "parse	trees".

	      See also:	tree/2.

       join_comments(Source::syntaxTree(),  Target::syntaxTree())  ->  syntax-
       Tree()

	      Appends  the  comments of	Source to the current comments of Tar-
	      get.

	      Note:  This  is  equivalent   to	 add_postcomments(get_postcom-
	      ments(Source),   add_precomments(get_precomments(Source),	  Tar-
	      get)), but potentially more efficient.

	      See  also:  add_postcomments/2,  add_precomments/2,   comment/2,
	      get_postcomments/1, get_precomments/1.

       list(List::[syntaxTree()]) -> syntaxTree()

	      Equivalent to list(List, none).

       list(Elements::[syntaxTree()],  Tail::none  |  syntaxTree()) -> syntax-
       Tree()

	      Constructs an abstract list skeleton. The	result has  type  list
	      or nil. If List is a nonempty list [E1, ..., En],	the result has
	      type list	and represents either "[E1,  ...,  En]",  if  Tail  is
	      none,  or	otherwise "[E1,	..., En	| Tail]". If List is the empty
	      list, Tail must be none, and in that case	the  result  has  type
	      nil and represents "[]" (see nil/0).

	      The  difference  between	lists as semantic objects (built up of
	      individual "cons"	and "nil" terms)  and  the  various  syntactic
	      forms  for denoting lists	may be bewildering at first. This mod-
	      ule provides functions both for exact control of	the  syntactic
	      representation  as well as for the simple	composition and	decon-
	      struction	in terms of cons and head/tail operations.

	      Note: in list(Elements, none), the "nil" list terminator is  im-
	      plicit  and  has	no  associated	information (see get_attrs/1),
	      while in the seemingly equivalent	list(Elements, Tail) when Tail
	      has type nil, the	list terminator	subtree	Tail may have attached
	      attributes such as position, comments,  and  annotations,	 which
	      will be preserved	in the result.

	      See  also:  compact_list/1,  cons/2, get_attrs/1,	is_list_skele-
	      ton/1, is_proper_list/1, list/1,	list_elements/1,  list_head/1,
	      list_length/1, list_prefix/1, list_suffix/1, list_tail/1,	nil/0,
	      normalize_list/1.

       list_comp(Template::syntaxTree(), Body::[syntaxTree()]) -> syntaxTree()

	      Creates an abstract list comprehension. If  Body	is  [E1,  ...,
	      En], the result represents "[Template || E1, ...,	En]".

	      See also:	generator/2, list_comp_body/1, list_comp_template/1.

       list_comp_body(Node::syntaxTree()) -> [syntaxTree()]

	      Returns the list of body subtrees	of a list_comp node.

	      See also:	list_comp/2.

       list_comp_template(Node::syntaxTree()) -> syntaxTree()

	      Returns the template subtree of a	list_comp node.

	      See also:	list_comp/2.

       list_elements(Node::syntaxTree()) -> [syntaxTree()]

	      Returns  the  list  of element subtrees of a list	skeleton. Node
	      must represent a proper list. E.g., if Node represents "[X1,  X2
	      |	 [X3, X4 | []]", then list_elements(Node) yields the list [X1,
	      X2, X3, X4].

	      See also:	is_proper_list/1, list/2.

       list_head(Node::syntaxTree()) ->	syntaxTree()

	      Returns the head element subtree of a list node. If Node	repre-
	      sents "[Head ...]", the result will represent "Head".

	      See also:	cons/2,	list/2,	list_tail/1.

       list_length(Node::syntaxTree()) -> non_neg_integer()

	      Returns  the number of element subtrees of a list	skeleton. Node
	      must represent a proper list. E.g., if Node  represents  "[X1  |
	      [X2,  X3	|  [X4,	X5, X6]]]", then list_length(Node) returns the
	      integer 6.

	      Note: this is equivalent to length(list_elements(Node)), but po-
	      tentially	more efficient.

	      See also:	is_proper_list/1, list/2, list_elements/1.

       list_prefix(Node::syntaxTree()) -> [syntaxTree()]

	      Returns the prefix element subtrees of a list node. If Node rep-
	      resents "[E1, ..., En]" or "[E1, ..., En | Tail]", the  returned
	      value is [E1, ..., En].

	      See also:	list/2.

       list_suffix(Node::syntaxTree()) -> none | syntaxTree()

	      Returns  the  suffix  subtree  of	a list node, if	one exists. If
	      Node represents "[E1, ..., En | Tail]", the  returned  value  is
	      Tail,  otherwise,	i.e., if Node represents "[E1, ..., En]", none
	      is returned.

	      Note that	even if	this function returns some Tail	 that  is  not
	      none,  the  type	of Tail	can be nil, if the tail	has been given
	      explicitly, and the list skeleton	has not	 been  compacted  (see
	      compact_list/1).

	      See also:	compact_list/1,	list/2,	nil/0.

       list_tail(Node::syntaxTree()) ->	syntaxTree()

	      Returns the tail of a list node. If Node represents a single-el-
	      ement list "[E]",	then the result	 has  type  nil,  representing
	      "[]".  If	Node represents	"[E1, E2 ...]",	the result will	repre-
	      sent "[E2	...]", and if Node represents "[Head | Tail]", the re-
	      sult will	represent "Tail".

	      See also:	cons/2,	list/2,	list_head/1.

       macro(Name::syntaxTree()) -> syntaxTree()

	      Equivalent to macro(Name,	none).

       macro(Name::syntaxTree(),  Arguments::none | [syntaxTree()]) -> syntax-
       Tree()

	      Creates an abstract macro	application. If	Arguments is none, the
	      result  represents "?Name", otherwise, if	Arguments is [A1, ...,
	      An], the result represents "?Name(A1, ..., An)".

	      Notes: if	Arguments is the empty list, the result	will thus rep-
	      resent "?Name()",	including a pair of matching parentheses.

	      The  only	 syntactical limitation	imposed	by the preprocessor on
	      the arguments to a macro application (viewed as sequences	of to-
	      kens) is that they must be balanced with respect to parentheses,
	      brackets,	begin ... end, case ...	end, etc. The text  node  type
	      can  be used to represent	arguments which	are not	regular	Erlang
	      constructs.

	      See also:	macro/1, macro_arguments/1, macro_name/1, text/1.

       macro_arguments(Node::syntaxTree()) -> none | [syntaxTree()]

	      Returns the list of argument subtrees of a macro node,  if  any.
	      If Node represents "?Name", none is returned. Otherwise, if Node
	      represents "?Name(A1, ..., An)", [A1, ..., An] is	returned.

	      See also:	macro/2.

       macro_name(Node::syntaxTree()) -> syntaxTree()

	      Returns the name subtree of a macro node.

	      See also:	macro/2.

       make_tree(X1::atom(), X2::[[syntaxTree()]]) -> syntaxTree()

	      Creates a	syntax tree with the given  type  and  subtrees.  Type
	      must  be	a  node	 type name (see	type/1)	that does not denote a
	      leaf node	type (see is_leaf/1). Groups must be a	nonempty  list
	      of  groups  of syntax trees, representing	the subtrees of	a node
	      of the given type, in left-to-right order	as they	would occur in
	      the  printed  program  text, grouped by category as done by sub-
	      trees/1.

	      The  result  of  copy_attrs(Node,	  make_tree(type(Node),	  sub-
	      trees(Node)))  (see  update_tree/2)  represents  the same	source
	      code text	as the original	 Node,	assuming  that	subtrees(Node)
	      yields  a	 nonempty  list. However, it does not necessarily have
	      the same data representation as Node.

	      See  also:  copy_attrs/2,	 is_leaf/1,  subtrees/1,  type/1,  up-
	      date_tree/2.

       map_expr(Fields::[syntaxTree()])	-> syntaxTree()

	      Equivalent to map_expr(none, Fields).

       map_expr(Argument::none | syntaxTree(), Fields::[syntaxTree()]) -> syn-
       taxTree()

	      Creates an abstract map expression. If Fields is [F1, ...,  Fn],
	      then  if	Argument  is  none,  the result	represents "#{F1, ...,
	      Fn}", otherwise it represents "Argument#{F1, ...,	Fn}".

	      See also:	 map_expr/1,  map_expr_argument/1,  map_expr_fields/1,
	      map_field_assoc/2, map_field_exact/2.

       map_expr_argument(Node::syntaxTree()) ->	none | syntaxTree()

	      Returns the argument subtree of a	map_expr node, if any. If Node
	      represents "#{...}", none	is returned. Otherwise,	if Node	repre-
	      sents "Argument#{...}", Argument is returned.

	      See also:	map_expr/2.

       map_expr_fields(Node::syntaxTree()) -> [syntaxTree()]

	      Returns the list of field	subtrees of a map_expr node.

	      See also:	map_expr/2.

       map_field_assoc(Name::syntaxTree(),   Value::syntaxTree())  ->  syntax-
       Tree()

	      Creates an abstract map assoc field. The result represents "Name
	      =_ Value".

	      See   also:  map_expr/2,	map_field_assoc_name/1,	 map_field_as-
	      soc_value/1.

       map_field_assoc_name(Node::syntaxTree())	-> syntaxTree()

	      Returns the name subtree of a map_field_assoc node.

	      See also:	map_field_assoc/2.

       map_field_assoc_value(Node::syntaxTree()) -> syntaxTree()

	      Returns the value	subtree	of a map_field_assoc node.

	      See also:	map_field_assoc/2.

       map_field_exact(Name::syntaxTree(),  Value::syntaxTree())  ->   syntax-
       Tree()

	      Creates an abstract map exact field. The result represents "Name
	      := Value".

	      See  also:  map_expr/2,  map_field_exact_name/1,	 map_field_ex-
	      act_value/1.

       map_field_exact_name(Node::syntaxTree())	-> syntaxTree()

	      Returns the name subtree of a map_field_exact node.

	      See also:	map_field_exact/2.

       map_field_exact_value(Node::syntaxTree()) -> syntaxTree()

	      Returns the value	subtree	of a map_field_exact node.

	      See also:	map_field_exact/2.

       map_type() -> term()

	      Equivalent to map_type(any_size).

       map_type(Fields::any_size | [syntaxTree()]) -> syntaxTree()

	      Creates  an  abstract  type map. If Fields is [F1, ..., Fn], the
	      result represents	"#{F1, ...,  Fn}";  otherwise,	if  Fields  is
	      any_size,	it represents "map()".

	      See also:	map_type_fields/1.

       map_type_assoc(Name::syntaxTree(), Value::syntaxTree()) -> syntaxTree()

	      Creates  an abstract map type assoc field. The result represents
	      "Name =_ Value".

	      See  also:   map_type/1,	 map_type_assoc_name/1,	  map_type_as-
	      soc_value/1.

       map_type_assoc_name(Node::syntaxTree()) -> syntaxTree()

	      Returns the name subtree of a map_type_assoc node.

	      See also:	map_type_assoc/2.

       map_type_assoc_value(Node::syntaxTree())	-> syntaxTree()

	      Returns the value	subtree	of a map_type_assoc node.

	      See also:	map_type_assoc/2.

       map_type_exact(Name::syntaxTree(), Value::syntaxTree()) -> syntaxTree()

	      Creates  an abstract map type exact field. The result represents
	      "Name := Value".

	      See  also:   map_type/1,	 map_type_exact_name/1,	  map_type_ex-
	      act_value/1.

       map_type_exact_name(Node::syntaxTree()) -> syntaxTree()

	      Returns the name subtree of a map_type_exact node.

	      See also:	map_type_exact/2.

       map_type_exact_value(Node::syntaxTree())	-> syntaxTree()

	      Returns the value	subtree	of a map_type_exact node.

	      See also:	map_type_exact/2.

       map_type_fields(Node::syntaxTree()) -> any_size | [syntaxTree()]

	      Returns  the  list of field subtrees of a	map_type node. If Node
	      represents "map()", any_size is  returned;  otherwise,  if  Node
	      represents "#{F1,	..., Fn}", [F1,	..., Fn] is returned.

	      See also:	map_type/0, map_type/1.

       match_expr(Pattern::syntaxTree(), Body::syntaxTree()) ->	syntaxTree()

	      Creates  an  abstract  match-expression.	The  result represents
	      "Pattern = Body".

	      See also:	match_expr_body/1, match_expr_pattern/1.

       match_expr_body(Node::syntaxTree()) -> syntaxTree()

	      Returns the body subtree of a match_expr node.

	      See also:	match_expr/2.

       match_expr_pattern(Node::syntaxTree()) -> syntaxTree()

	      Returns the pattern subtree of a match_expr node.

	      See also:	match_expr/2.

       meta(T::syntaxTree()) ->	syntaxTree()

	      Creates a	meta-representation of a syntax	tree. The result  rep-
	      resents  an  Erlang  expression  "MetaTree" which, if evaluated,
	      will yield a new syntax tree representing	the same  source  code
	      text  as	Tree  (although	 the actual data representation	may be
	      different). The expression represented by	MetaTree is  implemen-
	      tation  independent  with	 regard	to the data structures used by
	      the abstract syntax tree implementation.	Comments  attached  to
	      nodes of Tree will be preserved, but other attributes are	lost.

	      Any  node	 in Tree whose node type is variable (see type/1), and
	      whose list of annotations	 (see  get_ann/1)  contains  the  atom
	      meta_var,	 will  remain  unchanged in the	resulting tree,	except
	      that exactly one occurrence of meta_var is removed from its  an-
	      notation list.

	      The  main	 use  of  the  function	 meta/1	is to transform	a data
	      structure	Tree, which represents a piece of program code,	into a
	      form that	is representation independent when printed. E.g., sup-
	      pose Tree	represents a variable  named  "V".  Then  (assuming  a
	      function	 print/1   for	 printing  syntax  trees),  evaluating
	      print(abstract(Tree)) - simply using abstract/1 to map  the  ac-
	      tual  data  structure  onto a syntax tree	representation - would
	      output a string that might look something	like "{tree, variable,
	      ..., "V",	...}", which is	obviously dependent on the implementa-
	      tion of the abstract syntax trees. This could e.g. be useful for
	      caching  a  syntax  tree	in a file. However, in some situations
	      like in a	program	generator generator (with two "generator"), it
	      may  be unacceptable. Using print(meta(Tree)) instead would out-
	      put a representation independent syntax tree generating  expres-
	      sion;  in	 the  above  case,  something  like  "erl_syntax:vari-
	      able("V")".

	      See also:	abstract/1, get_ann/1, type/1.

       module_qualifier(Module::syntaxTree(), Body::syntaxTree())  ->  syntax-
       Tree()

	      Creates  an  abstract  module  qualifier.	 The result represents
	      "Module:Body".

	      See also:	module_qualifier_argument/1, module_qualifier_body/1.

       module_qualifier_argument(Node::syntaxTree()) ->	syntaxTree()

	      Returns the argument (the	module)	subtree	of a  module_qualifier
	      node.

	      See also:	module_qualifier/2.

       module_qualifier_body(Node::syntaxTree()) -> syntaxTree()

	      Returns the body subtree of a module_qualifier node.

	      See also:	module_qualifier/2.

       named_fun_expr(Name::syntaxTree(),  Clauses::[syntaxTree()]) -> syntax-
       Tree()

	      Creates an abstract named	fun-expression.	 If  Clauses  is  [C1,
	      ..., Cn],	the result represents "fun Name	C1; ...; Name Cn end".
	      More exactly, if each Ci represents "(Pi1, ..., Pim) Gi -_  Bi",
	      then  the	 result	 represents "fun Name(P11, ...,	P1m) G1	-_ B1;
	      ...; Name(Pn1, ..., Pnm) Gn -_ Bn	end".

	      See  also:   named_fun_expr_arity/1,   named_fun_expr_clauses/1,
	      named_fun_expr_name/1.

       named_fun_expr_arity(Node::syntaxTree())	-> arity()

	      Returns  the  arity  of a	named_fun_expr node. The result	is the
	      number of	parameter patterns in the first	clause	of  the	 named
	      fun-expression; subsequent clauses are ignored.

	      An  exception  is	thrown if named_fun_expr_clauses(Node) returns
	      an empty list, or	if the first element of	that  list  is	not  a
	      syntax  tree  C of type clause such that clause_patterns(C) is a
	      nonempty list.

	      See   also:   clause/3,	clause_patterns/1,   named_fun_expr/2,
	      named_fun_expr_clauses/1.

       named_fun_expr_clauses(Node::syntaxTree()) -> [syntaxTree()]

	      Returns the list of clause subtrees of a named_fun_expr node.

	      See also:	named_fun_expr/2.

       named_fun_expr_name(Node::syntaxTree()) -> syntaxTree()

	      Returns the name subtree of a named_fun_expr node.

	      See also:	named_fun_expr/2.

       nil() ->	syntaxTree()

	      Creates  an abstract empty list. The result represents "[]". The
	      empty list is traditionally called "nil".

	      See also:	is_list_skeleton/1, list/2.

       normalize_list(Node::syntaxTree()) -> syntaxTree()

	      Expands an abstract list skeleton	to its most explicit form.  If
	      Node  represents	"[E1,  ..., En | Tail]", the result represents
	      "[E1 | ... [En | Tail1] ... ]", where Tail1  is  the  result  of
	      normalize_list(Tail).  If	 Node  represents "[E1,	..., En]", the
	      result simply represents "[E1 | ... [En |	[]] ...	 ]".  If  Node
	      does not represent a list	skeleton, Node itself is returned.

	      See also:	compact_list/1,	list/2.

       operator(Name::atom() | string()) -> syntaxTree()

	      Creates  an  abstract  operator. The name	of the operator	is the
	      character	sequence represented by	Name. This is analogous	to the
	      print  name  of an atom, but an operator is never	written	within
	      single-quotes; e.g., the	result	of  operator('++')  represents
	      "++" rather than "'++'".

	      See also:	atom/1,	operator_literal/1, operator_name/1.

       operator_literal(Node::syntaxTree()) -> string()

	      Returns the literal string represented by	an operator node. This
	      is simply	the operator name as a string.

	      See also:	operator/1.

       operator_name(Node::syntaxTree()) -> atom()

	      Returns the name of an operator node. Note that the name is  re-
	      turned as	an atom.

	      See also:	operator/1.

       parentheses(Expr::syntaxTree()) -> syntaxTree()

	      Creates  an abstract parenthesised expression. The result	repre-
	      sents "(Body)", independently of the context.

	      See also:	parentheses_body/1.

       parentheses_body(Node::syntaxTree()) -> syntaxTree()

	      Returns the body subtree of a parentheses	node.

	      See also:	parentheses/1.

       prefix_expr(Operator::syntaxTree(), Argument::syntaxTree()) ->  syntax-
       Tree()

	      Creates  an abstract prefix operator expression. The result rep-
	      resents "Operator	Argument".

	      See also:	infix_expr/3, prefix_expr_argument/1,  prefix_expr_op-
	      erator/1.

       prefix_expr_argument(Node::syntaxTree())	-> syntaxTree()

	      Returns the argument subtree of a	prefix_expr node.

	      See also:	prefix_expr/2.

       prefix_expr_operator(Node::syntaxTree())	-> syntaxTree()

	      Returns the operator subtree of a	prefix_expr node.

	      See also:	prefix_expr/2.

       receive_expr(Clauses::[syntaxTree()]) ->	syntaxTree()

	      Equivalent to receive_expr(Clauses, none,	[]).

       receive_expr(Clauses::[syntaxTree()], Timeout::none | syntaxTree(), Ac-
       tion::[syntaxTree()]) ->	syntaxTree()

	      Creates an abstract receive-expression. If Timeout is none,  the
	      result represents	"receive C1; ...; Cn end" (the Action argument
	      is ignored). Otherwise, if Clauses is [C1, ..., Cn]  and	Action
	      is [A1, ..., Am],	the result represents "receive C1; ...;	Cn af-
	      ter Timeout -_ A1, ..., Am end". More exactly, if	each Ci	repre-
	      sents "(Pi) Gi -_	Bi", then the result represents	"receive P1 G1
	      -_ B1; ...; Pn Gn	-_ Bn ... end".

	      Note that	in Erlang, a receive-expression	must have at least one
	      clause if	no timeout part	is specified.

	      See    also:    case_expr/2,   clause/3,	 receive_expr/1,   re-
	      ceive_expr_action/1, receive_expr_clauses/1,  receive_expr_time-
	      out/1.

       receive_expr_action(Node::syntaxTree()) -> [syntaxTree()]

	      Returns the list of action body subtrees of a receive_expr node.
	      If Node represents "receive C1; ...; Cn end", this is the	 empty
	      list.

	      See also:	receive_expr/3.

       receive_expr_clauses(Node::syntaxTree())	-> [syntaxTree()]

	      Returns the list of clause subtrees of a receive_expr node.

	      See also:	receive_expr/3.

       receive_expr_timeout(Node::syntaxTree())	-> none	| syntaxTree()

	      Returns  the  timeout subtree of a receive_expr node, if any. If
	      Node represents "receive C1; ...;	Cn  end",  none	 is  returned.
	      Otherwise, if Node represents "receive C1; ...; Cn after Timeout
	      -_ ... end", Timeout is returned.

	      See also:	receive_expr/3.

       record_access(Argument::syntaxTree(),  Type::syntaxTree(),  Field::syn-
       taxTree()) -> syntaxTree()

	      Creates  an  abstract record field access	expression. The	result
	      represents "Argument#Type.Field".

	      See   also:   record_access_argument/1,	record_access_field/1,
	      record_access_type/1, record_expr/3.

       record_access_argument(Node::syntaxTree()) -> syntaxTree()

	      Returns the argument subtree of a	record_access node.

	      See also:	record_access/3.

       record_access_field(Node::syntaxTree()) -> syntaxTree()

	      Returns the field	subtree	of a record_access node.

	      See also:	record_access/3.

       record_access_type(Node::syntaxTree()) -> syntaxTree()

	      Returns the type subtree of a record_access node.

	      See also:	record_access/3.

       record_expr(Type::syntaxTree(), Fields::[syntaxTree()]) -> syntaxTree()

	      Equivalent to record_expr(none, Type, Fields).

       record_expr(Argument::none    |	  syntaxTree(),	   Type::syntaxTree(),
       Fields::[syntaxTree()]) -> syntaxTree()

	      Creates an abstract record expression. If	Fields	is  [F1,  ...,
	      Fn],  then if Argument is	none, the result represents "#Type{F1,
	      ..., Fn}", otherwise it represents "Argument#Type{F1, ..., Fn}".

	      See  also:  record_access/3,  record_expr/2,   record_expr_argu-
	      ment/1,	      record_expr_fields/1,	   record_expr_type/1,
	      record_field/2, record_index_expr/2.

       record_expr_argument(Node::syntaxTree())	-> none	| syntaxTree()

	      Returns the argument subtree of a	record_expr node, if  any.  If
	      Node  represents	"#Type{...}",  none is returned. Otherwise, if
	      Node represents "Argument#Type{...}", Argument is	returned.

	      See also:	record_expr/3.

       record_expr_fields(Node::syntaxTree()) -> [syntaxTree()]

	      Returns the list of field	subtrees of a record_expr node.

	      See also:	record_expr/3.

       record_expr_type(Node::syntaxTree()) -> syntaxTree()

	      Returns the type subtree of a record_expr	node.

	      See also:	record_expr/3.

       record_field(Name::syntaxTree())	-> syntaxTree()

	      Equivalent to record_field(Name, none).

       record_field(Name::syntaxTree(),	Value::none | syntaxTree()) -> syntax-
       Tree()

	      Creates  an  abstract  record  field  specification. If Value is
	      none, the	result represents simply "Name", otherwise  it	repre-
	      sents "Name = Value".

	      See	 also:	     record_expr/3,	  record_field_name/1,
	      record_field_value/1.

       record_field_name(Node::syntaxTree()) ->	syntaxTree()

	      Returns the name subtree of a record_field node.

	      See also:	record_field/2.

       record_field_value(Node::syntaxTree()) -> none |	syntaxTree()

	      Returns the value	subtree	of a record_field  node,  if  any.  If
	      Node  represents	"Name",	 none  is returned. Otherwise, if Node
	      represents "Name = Value", Value is returned.

	      See also:	record_field/2.

       record_index_expr(Type::syntaxTree(), Field::syntaxTree())  ->  syntax-
       Tree()

	      Creates  an  abstract  record field index	expression. The	result
	      represents "#Type.Field".

	      (Note: the function name record_index/2 is reserved by  the  Er-
	      lang compiler, which is why that name could not be used for this
	      constructor.)

	      See also:	record_expr/3,	record_index_expr_field/1,  record_in-
	      dex_expr_type/1.

       record_index_expr_field(Node::syntaxTree()) -> syntaxTree()

	      Returns the field	subtree	of a record_index_expr node.

	      See also:	record_index_expr/2.

       record_index_expr_type(Node::syntaxTree()) -> syntaxTree()

	      Returns the type subtree of a record_index_expr node.

	      See also:	record_index_expr/2.

       record_type(Name::syntaxTree(), Fields::[syntaxTree()]) -> syntaxTree()

	      Creates an abstract record type. If Fields is [F1, ..., Fn], the
	      result represents	"#Name{F1, ...,	Fn}".

	      See also:	record_type_fields/1, record_type_name/1.

       record_type_field(Name::syntaxTree(),  Type::syntaxTree())  ->  syntax-
       Tree()

	      Creates  an  abstract  record  type field. The result represents
	      "Name :: Type".

	      See also:	record_type_field_name/1, record_type_field_type/1.

       record_type_field_name(Node::syntaxTree()) -> syntaxTree()

	      Returns the name subtree of a record_type_field node.

	      See also:	record_type_field/2.

       record_type_field_type(Node::syntaxTree()) -> syntaxTree()

	      Returns the type subtree of a record_type_field node.

	      See also:	record_type_field/2.

       record_type_fields(Node::syntaxTree()) -> [syntaxTree()]

	      Returns the fields subtree of a record_type node.

	      See also:	record_type/2.

       record_type_name(Node::syntaxTree()) -> syntaxTree()

	      Returns the name subtree of a record_type	node.

	      See also:	record_type/2.

       remove_comments(Node::syntaxTree()) -> syntaxTree()

	      Clears the associated comments of	Node.

	      Note:  This  is	equivalent   to	  set_precomments(set_postcom-
	      ments(Node, []), []), but	potentially more efficient.

	      See also:	set_postcomments/2, set_precomments/2.

       revert(Node::syntaxTree()) -> syntaxTree()

	      Returns an erl_parse-compatible representation of	a syntax tree,
	      if possible. If Tree represents a	well-formed Erlang program  or
	      expression,  the	conversion should work without problems. Typi-
	      cally, is_tree/1 yields true if conversion failed	(i.e., the re-
	      sult is still an abstract	syntax tree), and false	otherwise.

	      The  is_tree/1  test is not completely foolproof.	For a few spe-
	      cial node	types (e.g. arity_qualifier), if such a	node occurs in
	      a	context	where it is not	expected, it will be left unchanged as
	      a	non-reverted subtree of	the result. This can  only  happen  if
	      Tree does	not actually represent legal Erlang code.

	      See also:	erl_parse(3), revert_forms/1.

       revert_forms(Forms::forms()) -> [erl_parse()]

	      Reverts a	sequence of Erlang source code forms. The sequence can
	      be given either as a form_list syntax tree (possibly nested), or
	      as  a  list  of  "program	form" syntax trees. If successful, the
	      corresponding flat list of erl_parse-compatible syntax trees  is
	      returned	(see  revert/1). If some program form could not	be re-
	      verted, {error, Form} is thrown. Standalone comments in the form
	      sequence are discarded.

	      See also:	form_list/1, is_form/1,	revert/1.

       set_ann(Node::syntaxTree(), As::[term()]) -> syntaxTree()

	      Sets the list of user annotations	of Node	to Annotations.

	      See also:	add_ann/2, copy_ann/2, get_ann/1.

       set_attrs(Node::syntaxTree(),  Attr::syntaxTreeAttributes()) -> syntax-
       Tree()

	      Sets the attributes of Node to Attributes.

	      See also:	copy_attrs/2, get_attrs/1.

       set_pos(Node::syntaxTree(), Pos::annotation_or_location())  ->  syntax-
       Tree()

	      Sets the position	information of Node to Pos.

	      See also:	copy_pos/2, get_pos/1.

       set_postcomments(Node::syntaxTree(),   Cs::[syntaxTree()])  ->  syntax-
       Tree()

	      Sets the post-comments of	Node to	Comments. Comments should be a
	      possibly	empty  list  of	abstract comments, in top-down textual
	      order

	      See  also:   add_postcomments/2,	 comment/2,   copy_comments/2,
	      get_postcomments/1, join_comments/2, remove_comments/1, set_pre-
	      comments/2.

       set_precomments(Node::syntaxTree(), Cs::[syntaxTree()]) -> syntaxTree()

	      Sets the pre-comments of Node to Comments. Comments should be  a
	      possibly	empty  list  of	abstract comments, in top-down textual
	      order.

	      See   also:   add_precomments/2,	 comment/2,   copy_comments/2,
	      get_precomments/1, join_comments/2, remove_comments/1, set_post-
	      comments/2.

       size_qualifier(Body::syntaxTree(), Size::syntaxTree()) -> syntaxTree()

	      Creates  an  abstract  size  qualifier.  The  result  represents
	      "Body:Size".

	      See also:	size_qualifier_argument/1, size_qualifier_body/1.

       size_qualifier_argument(Node::syntaxTree()) -> syntaxTree()

	      Returns  the  argument  subtree  (the  size) of a	size_qualifier
	      node.

	      See also:	size_qualifier/2.

       size_qualifier_body(Node::syntaxTree()) -> syntaxTree()

	      Returns the body subtree of a size_qualifier node.

	      See also:	size_qualifier/2.

       string(String::string())	-> syntaxTree()

	      Creates an abstract string literal. The result represents	"Text"
	      (including  the  surrounding  double-quotes),  where Text	corre-
	      sponds to	the sequence of	characters in Value,  but  not	repre-
	      senting a	specific string	literal.

	      For example, the result of string("x\ny")	represents any and all
	      of "x\ny", "x\12y", "x\012y" and "x\^Jy";	see char/1.

	      See also:	 char/1,  is_string/2,	string_literal/1,  string_lit-
	      eral/2, string_value/1.

       string_literal(Node::syntaxTree()) -> nonempty_string()

	      Returns  the  literal  string represented	by a string node. This
	      includes surrounding double-quote	characters. Characters	beyond
	      255 will be escaped.

	      See also:	string/1.

       string_literal(Node::syntaxTree(), X2::encoding()) -> nonempty_string()

	      Returns  the  literal  string represented	by a string node. This
	      includes surrounding double-quote	characters. Depending  on  the
	      encoding	characters  beyond  255	 will  be  escaped (latin1) or
	      copied as	is (utf8).

	      See also:	string/1.

       string_value(Node::syntaxTree())	-> string()

	      Returns the value	represented by a string	node.

	      See also:	string/1.

       subtrees(T::syntaxTree()) -> [[syntaxTree()]]

	      Returns the grouped list of all subtrees of a  syntax  tree.  If
	      Node  is	a  leaf	 node (see is_leaf/1), this is the empty list,
	      otherwise	the result is always a nonempty	list,  containing  the
	      lists  of	subtrees of Node, in left-to-right order as they occur
	      in the printed program text, and	grouped	 by  category.	Often,
	      each group contains only a single	subtree.

	      Depending	 on  the  type of Node,	the size of some groups	may be
	      variable (e.g., the group	consisting of all the  elements	 of  a
	      tuple),  while others always contain the same number of elements
	      -	usually	exactly	one (e.g., the group containing	 the  argument
	      expression  of a case-expression). Note, however,	that the exact
	      structure	of the returned	list (for a given node type) should in
	      general  not  be	depended  upon,	 since	it might be subject to
	      change without notice.

	      The  function   subtrees/1   and	 the   constructor   functions
	      make_tree/2  and	update_tree/2 can be a great help if one wants
	      to traverse a syntax tree, visiting all its subtrees, but	 treat
	      nodes  of	 the tree in a uniform way in most or all cases. Using
	      these functions makes this simple, and also  assures  that  your
	      code  is	not  overly sensitive to extensions of the syntax tree
	      data type, because any node types	not explicitly handled by your
	      code can be left to a default case.

	      For example:

		   postorder(F,	Tree) ->
		      F(case subtrees(Tree) of
			  [] ->	Tree;
			  List -> update_tree(Tree,
					      [[postorder(F, Subtree)
						|| Subtree <- Group]
					       || Group	<- List])
			end).

	      maps  the	function F on Tree and all its subtrees, doing a post-
	      order traversal of  the  syntax  tree.  (Note  the  use  of  up-
	      date_tree/2  to preserve node attributes.) For a simple function
	      like:

		   f(Node) ->
		      case type(Node) of
			  atom -> atom("a_" ++ atom_name(Node));
			  _ -> Node
		      end.

	      the call postorder(fun f/1, Tree)	will yield a  new  representa-
	      tion of Tree in which all	atom names have	been extended with the
	      prefix "a_", but nothing else (including	comments,  annotations
	      and line numbers)	has been changed.

	      See also:	copy_attrs/2, is_leaf/1, make_tree/2, type/1.

       text(String::string()) -> syntaxTree()

	      Creates an abstract piece	of source code text. The result	repre-
	      sents exactly the	sequence of characters in String. This is use-
	      ful  in  cases when one wants full control of the	resulting out-
	      put, e.g., for the appearance of floating-point numbers or macro
	      definitions.

	      See also:	text_string/1.

       text_string(Node::syntaxTree()) -> string()

	      Returns the character sequence represented by a text node.

	      See also:	text/1.

       tree(Type::atom()) -> tree()

	      Equivalent to tree(Type, []).

       tree(Type::atom(), Data::term())	-> tree()

	      For  special purposes only. Creates an abstract syntax tree node
	      with type	tag Type and associated	data Data.

	      This function and	the related is_tree/1  and  data/1  provide  a
	      uniform way to extend the	set of erl_parse node types. The asso-
	      ciated data is any term, whose format may	 depend	 on  the  type
	      tag.

	      Notes:

		* Any nodes created outside of this module must	have type tags
		  distinct from	those currently	defined	by  this  module;  see
		  type/1 for a complete	list.

		* The  type  tag  of  a	syntax tree node may also be used as a
		  primary tag by the erl_parse representation; in  that	 case,
		  the  selector	 functions for that node type must handle both
		  the abstract syntax tree and the erl_parse form.  The	 func-
		  tion	type(T)	 should	return the correct type	tag regardless
		  of the representation	of T, so that the user sees no differ-
		  ence between erl_syntax and erl_parse	nodes.

	      See also:	data/1,	is_tree/1, type/1.

       try_after_expr(Body::[syntaxTree()],  After::[syntaxTree()]) -> syntax-
       Tree()

	      Equivalent to try_expr(Body, [], [], After).

       try_expr(Body::[syntaxTree()],  Handlers::[syntaxTree()])  ->   syntax-
       Tree()

	      Equivalent to try_expr(Body, [], Handlers).

       try_expr(Body::[syntaxTree()], Clauses::[syntaxTree()], Handlers::[syn-
       taxTree()]) -> syntaxTree()

	      Equivalent to try_expr(Body, Clauses, Handlers, []).

       try_expr(Body::[syntaxTree()], Clauses::[syntaxTree()], Handlers::[syn-
       taxTree()], After::[syntaxTree()]) -> syntaxTree()

	      Creates  an  abstract  try-expression. If	Body is	[B1, ..., Bn],
	      Clauses is [C1, ..., Cj],	Handlers is [H1, ..., Hk],  and	 After
	      is  [A1, ..., Am], the result represents "try B1,	..., Bn	of C1;
	      ...; Cj catch H1;	...; Hk	after A1, ..., Am end".	More  exactly,
	      if each Ci represents "(CPi) CGi -_ CBi",	and each Hi represents
	      "(HPi) HGi -_ HBi", then the result represents "try B1, ...,  Bn
	      of  CP1  CG1  -_	CB1; ...; CPj CGj -_ CBj catch HP1 HG1 -_ HB1;
	      ...; HPk HGk -_ HBk after	A1, ..., Am end"; see case_expr/2.  If
	      Clauses  is  the	empty list, the	of ... section is left out. If
	      After is the empty list, the after ... section is	left  out.  If
	      Handlers is the empty list, and After is nonempty, the catch ...
	      section is left out.

	      See  also:  case_expr/2,	class_qualifier/2,  clause/3,  try_af-
	      ter_expr/2,     try_expr/2,     try_expr/3,    try_expr_after/1,
	      try_expr_body/1, try_expr_clauses/1, try_expr_handlers/1.

       try_expr_after(Node::syntaxTree()) -> [syntaxTree()]

	      Returns the list of "after" subtrees of a	try_expr node.

	      See also:	try_expr/4.

       try_expr_body(Node::syntaxTree()) -> [syntaxTree()]

	      Returns the list of body subtrees	of a try_expr node.

	      See also:	try_expr/4.

       try_expr_clauses(Node::syntaxTree()) -> [syntaxTree()]

	      Returns the list of case-clause subtrees of a try_expr node.  If
	      Node  represents "try Body catch H1; ...;	Hn end", the result is
	      the empty	list.

	      See also:	try_expr/4.

       try_expr_handlers(Node::syntaxTree()) ->	[syntaxTree()]

	      Returns the list of handler-clause subtrees of a try_expr	node.

	      See also:	try_expr/4.

       tuple(List::[syntaxTree()]) -> syntaxTree()

	      Creates an abstract tuple. If Elements is	[X1, ..., Xn], the re-
	      sult represents "{X1, ..., Xn}".

	      Note:  The  Erlang  language has distinct	1-tuples, i.e.,	{X} is
	      always distinct from X itself.

	      See also:	tuple_elements/1, tuple_size/1.

       tuple_elements(Node::syntaxTree()) -> [syntaxTree()]

	      Returns the list of element subtrees of a	tuple node.

	      See also:	tuple/1.

       tuple_size(Node::syntaxTree()) -> non_neg_integer()

	      Returns the number of elements of	a tuple	node.

	      Note: this is equivalent	to  length(tuple_elements(Node)),  but
	      potentially more efficient.

	      See also:	tuple/1, tuple_elements/1.

       tuple_type() -> term()

	      Equivalent to tuple_type(any_size).

       tuple_type(Elements::any_size | [syntaxTree()]) -> syntaxTree()

	      Creates  an  abstract  type tuple. If Elements is	[T1, ..., Tn],
	      the result represents "{T1, ..., Tn}"; otherwise,	if Elements is
	      any_size,	it represents "tuple()".

	      See also:	tuple_type_elements/1.

       tuple_type_elements(Node::syntaxTree()) -> any_size | [syntaxTree()]

	      Returns  the list	of type	element	subtrees of a tuple_type node.
	      If Node represents "tuple()", any_size is	 returned;  otherwise,
	      if Node represents "{T1, ..., Tn}", [T1, ..., Tn]	is returned.

	      See also:	tuple_type/0, tuple_type/1.

       type(Tree::syntaxTree())	-> atom()

	      Returns  the type	tag of Node. If	Node does not represent	a syn-
	      tax tree,	evaluation fails with reason badarg. Node  types  cur-
	      rently defined by	this module are:

	      application annotated_type arity_qualifier atom
	      attribute	binary binary_field bitstring_type
	      block_expr case_expr catch_expr char
	      class_qualifier clause comment conjunction
	      constrained_function_type	constraint disjunction eof_marker
	      error_marker float form_list fun_expr
	      fun_type function	function_type generator
	      if_expr implicit_fun infix_expr integer
	      integer_range_type list list_comp	macro
	      map_expr map_field_assoc map_field_exact map_type
	      map_type_assoc map_type_exact match_expr module_qualifier
	      named_fun_expr nil operator parentheses
	      prefix_expr receive_expr record_access record_expr
	      record_field record_index_expr record_type record_type_field
	      size_qualifier string text try_expr
	      tuple tuple_type typed_record_field type_application
	      type_union underscore user_type_application variable
	      warning_marker

	      The user may (for	special	purposes) create additional nodes with
	      other type tags, using the tree/2	function.

	      Note: The	primary	constructor functions for a node  type	should
	      always have the same name	as the node type itself.

	      See  also:  annotated_type/2,  application/3, arity_qualifier/2,
	      atom/1, attribute/2, binary/1, binary_field/2, bitstring_type/2,
	      block_expr/1,  case_expr/2,  catch_expr/1,  char/1, class_quali-
	      fier/2, clause/3,	 comment/2,  conjunction/1,  constrained_func-
	      tion_type/2,   constraint/2,  disjunction/1,  eof_marker/0,  er-
	      ror_marker/1,  float/1,  form_list/1,  fun_expr/1,   fun_type/0,
	      function/2,   function_type/1,   function_type/2,	  generator/2,
	      if_expr/1,  implicit_fun/2,   infix_expr/3,   integer/1,	 inte-
	      ger_range_type/2,	  list/2,  list_comp/2,	 macro/2,  map_expr/2,
	      map_field_assoc/2,  map_field_exact/2,  map_type/0,  map_type/1,
	      map_type_assoc/2,	 map_type_exact/2, match_expr/2, module_quali-
	      fier/2, named_fun_expr/2,	nil/0, operator/1, parentheses/1, pre-
	      fix_expr/2,   receive_expr/3,   record_access/3,	record_expr/2,
	      record_field/2,	    record_index_expr/2,	record_type/2,
	      record_type_field/2, size_qualifier/2, string/1, text/1, tree/2,
	      try_expr/3, tuple/1, tuple_type/0,  tuple_type/1,	 type_applica-
	      tion/2,	 type_union/1,	 typed_record_field/2,	 underscore/0,
	      user_type_application/2, variable/1, warning_marker/1.

       type_application(TypeName::syntaxTree(),	Arguments::[syntaxTree()])  ->
       syntaxTree()

	      Creates an abstract type application expression. If Arguments is
	      [T1, ...,	Tn], the result	represents "TypeName(T1, ...Tn)".

	      See  also:   type_application/3,	 type_application_arguments/1,
	      type_application_name/1, user_type_application/2.

       type_application(Module::none  |	 syntaxTree(), TypeName::syntaxTree(),
       Arguments::[syntaxTree()]) -> syntaxTree()

	      Creates an abstract type application expression.	If  Module  is
	      none,  this  is call is equivalent to type_application(TypeName,
	      Arguments), otherwise it is equivalent to	 type_application(mod-
	      ule_qualifier(Module, TypeName), Arguments).

	      (This is a utility function.)

	      See also:	module_qualifier/2, type_application/2.

       type_application_arguments(Node::syntaxTree()) -> [syntaxTree()]

	      Returns the arguments subtrees of	a type_application node.

	      See also:	type_application/2.

       type_application_name(Node::syntaxTree()) -> syntaxTree()

	      Returns the type name subtree of a type_application node.

	      See also:	type_application/2.

       type_union(Types::[syntaxTree()]) -> syntaxTree()

	      Creates  an  abstract type union.	If Types is [T1, ..., Tn], the
	      result represents	"T1 | ... | Tn".

	      See also:	type_union_types/1.

       type_union_types(Node::syntaxTree()) -> [syntaxTree()]

	      Returns the list of type subtrees	of a type_union	node.

	      See also:	type_union/1.

       typed_record_field(Field::syntaxTree(), Type::syntaxTree()) ->  syntax-
       Tree()

	      Creates an abstract typed	record field specification. The	result
	      represents "Field	:: Type".

	      See also:	typed_record_field_body/1, typed_record_field_type/1.

       typed_record_field_body(Node::syntaxTree()) -> syntaxTree()

	      Returns the field	subtree	of a typed_record_field	node.

	      See also:	typed_record_field/2.

       typed_record_field_type(Node::syntaxTree()) -> syntaxTree()

	      Returns the type subtree of a typed_record_field node.

	      See also:	typed_record_field/2.

       underscore() -> syntaxTree()

	      Creates an abstract universal pattern ("_"). The lexical	repre-
	      sentation	 is  a	single underscore character. Note that this is
	      not a variable, lexically	speaking.

	      See also:	variable/1.

       update_tree(Node::syntaxTree(),	Groups::[[syntaxTree()]])  ->  syntax-
       Tree()

	      Creates  a  syntax tree with the same type and attributes	as the
	      given   tree.   This   is	  equivalent	to    copy_attrs(Node,
	      make_tree(type(Node), Groups)).

	      See also:	copy_attrs/2, make_tree/2, type/1.

       user_type_application(TypeName::syntaxTree(),	   Arguments::[syntax-
       Tree()])	-> syntaxTree()

	      Creates an abstract user type. If	Arguments is  [T1,  ...,  Tn],
	      the result represents "TypeName(T1, ...Tn)".

	      See also:	type_application/2, user_type_application_arguments/1,
	      user_type_application_name/1.

       user_type_application_arguments(Node::syntaxTree()) -> [syntaxTree()]

	      Returns the arguments subtrees of	a user_type_application	node.

	      See also:	user_type_application/2.

       user_type_application_name(Node::syntaxTree()) -> syntaxTree()

	      Returns the type name subtree of a user_type_application node.

	      See also:	user_type_application/2.

       variable(Name::atom() | string()) -> syntaxTree()

	      Creates an abstract variable with	the given name.	 Name  may  be
	      any  atom	 or  string that represents a lexically	valid variable
	      name, but	not a single underscore	character; see underscore/0.

	      Note: no checking	is done	whether	the character sequence	repre-
	      sents  a	proper	variable  name,	i.e., whether or not its first
	      character	is an uppercase	Erlang character, or whether  it  does
	      not contain control characters, whitespace, etc.

	      See also:	underscore/0, variable_literal/1, variable_name/1.

       variable_literal(Node::syntaxTree()) -> string()

	      Returns the name of a variable node as a string.

	      See also:	variable/1.

       variable_name(Node::syntaxTree()) -> atom()

	      Returns the name of a variable node as an	atom.

	      See also:	variable/1.

       warning_marker(Warning::term()) -> syntaxTree()

	      Creates an abstract warning marker. The result represents	an oc-
	      currence of a possible problem in	the source code, with an asso-
	      ciated Erlang I/O	ErrorInfo structure given by Error (see	module
	      io(3) for	details). Warning markers are regarded as source  code
	      forms, but have no defined lexical form.

	      Note:  this  is  supported only for backwards compatibility with
	      existing parsers and tools.

	      See  also:  eof_marker/0,	  error_marker/1,   is_form/1,	 warn-
	      ing_marker_info/1.

       warning_marker_info(Node::syntaxTree()) -> term()

	      Returns the ErrorInfo structure of a warning_marker node.

	      See also:	warning_marker/1.

AUTHORS
       Richard Carlsson	_carlsson.richard@gmail.com_

			       syntax_tools 2.6			 erl_syntax(3)

NAME | DESCRIPTION | DATA TYPES | EXPORTS | AUTHORS

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=erl_syntax&sektion=3&manpath=FreeBSD+13.0-RELEASE+and+Ports>

home | help