NAME

       cerl_trees - Basic functions on Core Erlang abstract syntax trees.

DESCRIPTION

       Basic functions on Core Erlang abstract syntax trees.

       Syntax trees are defined in the module cerl.

DATA TYPES

         cerl() = cerl:cerl():

EXPORTS

       depth(T::cerl:cerl()) -> non_neg_integer()

              Returns  the  length  of  the  longest  path  in  the  tree.  A leaf node has depth zero, the tree
              representing "{foo, bar}" has depth one, etc.

       fold(F::(cerl:cerl(), term()) -> term(), S::term(), T::cerl:cerl()) -> term()

              Does a fold operation over the nodes of  the  tree.  The  result  is  the  value  of  Function(X1,
              Function(X2,  ...  Function(Xn,  Unit)  ... )), where X1, ..., Xn are the nodes of Tree in a post-
              order traversal.

              See also: mapfold/3.

       free_variables(T::cerl:cerl()) -> [cerl:var_name()]

              Like variables/1, but only includes variables that are free in the tree.

              See also: next_free_variable_name/1, variables/1.

       get_label(T::cerl:cerl()) -> top | integer()

       label(T::cerl:cerl()) -> {cerl:cerl(), integer()}

              Equivalent to label(Tree, 0).

       label(T::cerl:cerl(), N::integer()) -> {cerl:cerl(), integer()}

              Labels each expression in the tree. A term {label, L} is prefixed to the annotation list  of  each
              expression  node,  where  L  is a unique number for every node, except for variables (and function
              name variables) which get the same label if they represent the  same  variable.  Constant  literal
              nodes are not labeled.

              The  returned value is a tuple {NewTree, Max}, where NewTree is the labeled tree and Max is 1 plus
              the largest label value used. All previous annotation terms on the form {label, X} are deleted.

              The values of L used in the tree is a dense range from N to Max -  1,  where  N  =<  Max  =<  N  +
              size(Tree). Note that it is possible that no labels are used at all, i.e., N = Max.

              Note: All instances of free variables will be given distinct labels.

              See also: label/1, size/1.

       map(F::(cerl:cerl()) -> cerl:cerl(), T::cerl:cerl()) -> cerl:cerl()

              Maps  a  function  onto  the nodes of a tree. This replaces each node in the tree by the result of
              applying the given function on the original node, bottom-up.

              See also: mapfold/3.

       mapfold(F::(cerl:cerl(), term()) -> {cerl:cerl(), term()}, S0::term(), T::cerl:cerl())  ->  {cerl:cerl(),
       term()}

              Does  a  combined  map/fold operation on the nodes of the tree. This is similar to map/2, but also
              propagates a value from each application of Function to the next, starting with  the  given  value
              Initial, while doing a post-order traversal of the tree, much like fold/3.

              This is the same as mapfold/4, with an identity function as the pre-operation.

              See also: fold/3, map/2, mapfold/4.

       mapfold(Pre::(cerl:cerl(),  term())  ->  {cerl:cerl(),  term()}  |  skip,  Post::(cerl:cerl(), term()) ->
       {cerl:cerl(), term()}, S00::term(), T0::cerl:cerl()) -> {cerl:cerl(), term()}

              Does a combined map/fold operation on the nodes of the tree. It begins by calling Pre on the tree,
              using the Initial value. Pre must either return a tree with an updated  accumulator  or  the  atom
              skip.

              If  a  tree is returned, this function deconstructs the top node of the returned tree and recurses
              on the children, using the returned value as the new initial and carrying the returned values from
              one call to the next. Finally it reassembles the top node from the children, calls Post on it  and
              returns the result.

              If skip is returned, it returns the tree and accumulator as is.

       next_free_variable_name(T::cerl:cerl()) -> integer()

              Returns a integer variable name higher than any other integer variable name in the syntax tree. An
              exception is thrown if Tree does not represent a well-formed Core Erlang syntax tree.

              See also: free_variables/1, variables/1.

       size(T::cerl:cerl()) -> non_neg_integer()

              Returns the number of nodes in Tree.

       variables(T::cerl:cerl()) -> [cerl:var_name()]

              Returns  an  ordered-set  list  of  the  names of all variables in the syntax tree. (This includes
              function name variables.) An exception is thrown if Tree does not  represent  a  well-formed  Core
              Erlang syntax tree.

              See also: free_variables/1, next_free_variable_name/1.

AUTHORS

       Richard Carlsson <carlsson.richard@gmail.com>

                                                compiler 8.2.6.3                                cerl_trees(3erl)