.. _aterm_list.h:
  
mcrl2/atermpp/aterm_list.h
===============================================================================

Include file: 

.. code-block:: c++ 

   #include "mcrl2/atermpp/aterm_list.h"






Classes
-------

* :cpp:class:`std::hash< atermpp::term_list< Term > >`

* :cpp:class:`atermpp::term_list`

Typedefs
-------------------------------------------------------------------------------

.. cpp:type:: atermpp::aterm_list

  typedef for :cpp:type:`term_list\< aterm >`
  
  A term_list with elements of type aterm. 

  

Functions
-------------------------------------------------------------------------------

.. cpp:function:: std::set<T> atermpp::as_set(const atermpp::term_list< T > &x)
  
  Converts the given term list to a set. 

  

.. cpp:function:: std::vector<T> atermpp::as_vector(const atermpp::term_list< T > &x)
  
  Converts the given term list to a vector. 

  

.. cpp:function:: std::conditional<std::is_convertible<Term2,Term1>::value,term_list<Term1>,term_list<Term2> >::type atermpp::operator+(const term_list< Term1 > &l, const term_list< Term2 > &m)
  
  Returns the concatenation of two lists with convertible element types. 

  The type of the result is either the type of l, if the elements of m can be converted implicitly to the type of the elements of l. Otherwise if the elements of l can be converted implicitly to the type of the elements of m, the result type is that or m. 
  
  **Parameters:**

  * **l** A list. 

  * **m** A list.


The complexity of this operator is linear in the length of l. 
      
  **Returns:** The concatenation of the lists l followed by m. 

.. cpp:function:: term_list<Term> atermpp::push_back(const term_list< Term > &l, const Term &el)
  
  Appends a new element at the end of the list. Note that the complexity of this function is O(n), with n the number of elements in the list!!! 

  
  
  **Parameters:**

  * **l** The list to which the term is appended. 

  * **el** A term. 


      
  **Returns:** The list l with elem appended at the end. 

.. cpp:function:: term_list<Term> atermpp::reverse(const term_list< Term > &l)
  
  Returns the list with the elements in reversed order. 

  
  
  **Parameters:**

  * **l** A list.


This operator is linear in the size of the list. 
      
  **Returns:** The reversed list. 

.. cpp:function:: term_list<Term> atermpp::sort_list(const term_list< Term > &l, const std::function< bool(const Term &, const Term &)> &ordering=[](const Term &t1, const Term &t2){ return t1< t2;})
  
  Returns the list with the elements sorted according to the <-operator on the addresses of terms. 

  
  
  **Parameters:**

  * **l** A list. 

  * **ordering** An total orderings relation on Term, by default the ordering relation on Terms.


This operator has complexity nlog n where n is the size of the list. 
      
  **Returns:** The sorted list. 

Functions
-------------------------------------------------------------------------------

.. cpp:function:: void std::swap(atermpp::term_list< T > &t1, atermpp::term_list< T > &t2) noexcept
  
  Swaps two term_lists. 

  This operation is more efficient than exchanging terms by an assignment, as swapping does not require to change the protection of terms. 
  
  **Parameters:**

  * **t1** The first term 

  * **t2** The second term