File: lists.html

package info (click to toggle)
erlang-doc-html 1%3A11.b.2-1
links: PTS
area: main
in suites: etch, etch-m68k
size: 23,284 kB
ctags: 10,724
sloc: erlang: 505; ansic: 323; makefile: 62; perl: 61; sh: 45
file content (1482 lines) | stat: -rw-r--r-- 42,330 bytes
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<!-- This document was generated using DocBuilder 3.3.3 -->
<HTML>
<HEAD>
  <TITLE>lists</TITLE>
  <SCRIPT type="text/javascript" src="../../../../doc/erlresolvelinks.js">
</SCRIPT>
  <STYLE TYPE="text/css">
<!--
    .REFBODY     { margin-left: 13mm }
    .REFTYPES    { margin-left: 8mm }
-->
  </STYLE>
</HEAD>
<BODY BGCOLOR="#FFFFFF" TEXT="#000000" LINK="#0000FF" VLINK="#FF00FF"
      ALINK="#FF0000">
<!-- refpage -->
<CENTER>
<A HREF="http://www.erlang.se">
  <IMG BORDER=0 ALT="[Ericsson AB]" SRC="min_head.gif">
</A>
<H1>lists</H1>
</CENTER>

<H3>MODULE</H3>
<DIV CLASS=REFBODY>
lists
</DIV>

<H3>MODULE SUMMARY</H3>
<DIV CLASS=REFBODY>
List Processing Functions
</DIV>

<H3>DESCRIPTION</H3>
<DIV CLASS=REFBODY>

<P>This module contains functions for list processing. The functions
are organized in two groups: those in the first group perform a
particular operation on one or more lists, whereas those in the
second group are higher-order functions, using a fun as argument
to perform an operation on one list.
<P>Unless otherwise stated, all functions assume that position
numbering starts at 1. That is, the first element of a list is at
position 1.
</DIV>

<H3>EXPORTS</H3>

<P><A NAME="append/1"><STRONG><CODE>append(ListOfLists) -&#62; List1</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>ListOfLists = [List]</CODE></STRONG><BR>
<STRONG><CODE>List = List1 = [term()]</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Returns a list in which all the sub-lists of
         <CODE>ListOfLists</CODE> have been appended. For example:
<PRE>
&#62; <STRONG>lists:append([[1, 2, 3], [a, b], [4, 5, 6]]).</STRONG>
[1,2,3,a,b,4,5,6]
        
</PRE>

</DIV>

<P><A NAME="append/2"><STRONG><CODE>append(List1, List2) -&#62; List3</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>List1 = List2 = List3 = [term()]</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Returns a new list <CODE>List3</CODE> which is made from
         the elements of <CODE>List1</CODE> followed by the elements of
         <CODE>List2</CODE>. For example:
<PRE>
&#62; <STRONG>lists:append(&#34;abc&#34;, &#34;def&#34;).</STRONG>
&#34;abcdef&#34;
        
</PRE>

<P><CODE>lists:append(A, B)</CODE> is equivalent to <CODE>A ++ B</CODE>.
</DIV>

<P><A NAME="concat/1"><STRONG><CODE>concat(Things) -&#62; string()</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>Things = [Thing]</CODE></STRONG><BR>
<STRONG><CODE>Thing = atom() | integer() | float() | string()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Concatenates the text representation of the elements
of <CODE>Things</CODE>. The elements of <CODE>Things</CODE> can be atoms,
integers, floats or strings.
<PRE>
&#62; <STRONG>lists:concat([doc, '/', file, '.', 3]).</STRONG>
&#34;doc/file.3&#34;
        
</PRE>

</DIV>

<P><A NAME="delete/2"><STRONG><CODE>delete(Elem, List1) -&#62; List2</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>Elem = term()</CODE></STRONG><BR>
<STRONG><CODE>List1 = List2 = [term()]</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Returns a copy of <CODE>List1</CODE> where the first occurrence of
<CODE>Elem</CODE>, if present, is deleted.
</DIV>

<P><A NAME="duplicate/2"><STRONG><CODE>duplicate(N, Elem) -&#62; List</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>N = int()</CODE></STRONG><BR>
<STRONG><CODE>Elem = term()</CODE></STRONG><BR>
<STRONG><CODE>List = [term()]</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Returns a list which contains N copies of the term
<CODE>Elem</CODE>. For example:
<PRE>
&#62; <STRONG>lists:duplicate(5, xx).</STRONG>
[xx,xx,xx,xx,xx]
        
</PRE>

</DIV>

<P><A NAME="flatlength/1"><STRONG><CODE>flatlength(DeepList) -&#62; int()</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>DeepList = [term() | DeepList]</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Equivalent to <CODE>length(flatten(DeepList))</CODE>, but more
efficient.
</DIV>

<P><A NAME="flatten/1"><STRONG><CODE>flatten(DeepList) -&#62; List</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>DeepList = [term() | DeepList]</CODE></STRONG><BR>
<STRONG><CODE>List = [term()]</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Returns a flattened version of <CODE>DeepList</CODE>.
</DIV>

<P><A NAME="flatten/2"><STRONG><CODE>flatten(DeepList, Tail) -&#62; List</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>DeepList = [term() | DeepList]</CODE></STRONG><BR>
<STRONG><CODE>Tail = List = [term()]</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Returns a flattened version of <CODE>DeepList</CODE> with the tail
         <CODE>Tail</CODE> appended.
</DIV>

<P><A NAME="keydelete/3"><STRONG><CODE>keydelete(Key, N, TupleList1) -&#62; TupleList2</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>Key = term()</CODE></STRONG><BR>
<STRONG><CODE>N = 1..size(Tuple)</CODE></STRONG><BR>
<STRONG><CODE>TupleList1 = TupleList2 = [Tuple]</CODE></STRONG><BR>
<STRONG><CODE>Tuple = tuple()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Returns a copy of <CODE>TupleList1</CODE> where the first
         occurrence of a tuple whose Nth element is <CODE>Key</CODE> is
         deleted, if present.
</DIV>

<P><A NAME="keymember/3"><STRONG><CODE>keymember(Key, N, TupleList) -&#62; bool()</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>Key = term()</CODE></STRONG><BR>
<STRONG><CODE>N = 1..size(Tuple)</CODE></STRONG><BR>
<STRONG><CODE>TupleList = [Tuple]</CODE></STRONG><BR>
<STRONG><CODE>Tuple = tuple()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Returns <CODE>true</CODE> if there is a tuple in <CODE>TupleList</CODE>
         whose Nth element is <CODE>Key</CODE>, otherwise <CODE>false</CODE>.
</DIV>

<P><A NAME="keymerge/3"><STRONG><CODE>keymerge(N, TupleList1, TupleList2) -&#62; TupleList3</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>N = 1..size(Tuple)</CODE></STRONG><BR>
<STRONG><CODE>TupleList1 = TupleList2 = TupleList3 = [Tuple]</CODE></STRONG><BR>
<STRONG><CODE>Tuple = tuple()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Returns the sorted list formed by merging <CODE>TupleList1</CODE>
         and <CODE>TupleList2</CODE>. The sorting is performed on
         the Nth element of each tuple. Both <CODE>TupleList1</CODE> and
         <CODE>TupleList2</CODE> must be key-sorted prior to evaluating this
         function. When two keys are equal, elements from
         <CODE>TupleList1</CODE> are picked before elements from
         <CODE>TupleList2</CODE>.
</DIV>

<P><A NAME="keyreplace/4"><STRONG><CODE>keyreplace(Key, N, TupleList1, NewTuple) -&#62; TupleList2
</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>Key = term()</CODE></STRONG><BR>
<STRONG><CODE>N = 1..size(Tuple)</CODE></STRONG><BR>
<STRONG><CODE>TupleList1 = TupleList2 = [Tuple]</CODE></STRONG><BR>
<STRONG><CODE>NewTuple = Tuple = tuple()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Returns a copy of <CODE>TupleList1</CODE>, where the first
         occurrence of a tuple whose Nth element is <CODE>Key</CODE>, if
         present, is replaced with <CODE>NewTuple</CODE>.
</DIV>

<P><A NAME="keysearch/3"><STRONG><CODE>keysearch(Key, N, TupleList) -&#62; {value, Tuple} | false
</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>Key = term()</CODE></STRONG><BR>
<STRONG><CODE>N = 1..size(Tuple)</CODE></STRONG><BR>
<STRONG><CODE>TupleList = [Tuple]</CODE></STRONG><BR>
<STRONG><CODE>Tuple = tuple()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Searches the list of the tuples <CODE>TupleList</CODE> for a
         tuple whose <CODE>N</CODE>th element is <CODE>Key</CODE>. Returns
         <CODE>{value, Tuple}</CODE> if such a tuple is found, or
         <CODE>false</CODE> otherwise.
</DIV>

<P><A NAME="keysort/2"><STRONG><CODE>keysort(N, TupleList1) -&#62; TupleList2</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>N = 1..size(Tuple)</CODE></STRONG><BR>
<STRONG><CODE>TupleList1 = TupleList2 = [Tuple]</CODE></STRONG><BR>
<STRONG><CODE>Tuple = tuple()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Returns a list containing the sorted elements of
<CODE>TupleList1</CODE>. Sorting is performed on the Nth element of
         the tuples.
</DIV>

<P><A NAME="last/1"><STRONG><CODE>last(List) -&#62; Last</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>List = [term()], length(List)&#62;0</CODE></STRONG><BR>
<STRONG><CODE>Last = term()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Returns the last element in <CODE>List</CODE>.
</DIV>

<P><A NAME="max/1"><STRONG><CODE>max(List) -&#62; Max</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>List = [term()], length(List)&#62;0</CODE></STRONG><BR>
<STRONG><CODE>Max = term()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Returns the maximum element of <CODE>List</CODE>.
</DIV>

<P><A NAME="member/2"><STRONG><CODE>member(Elem, List) -&#62; bool()</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>Elem = term()</CODE></STRONG><BR>
<STRONG><CODE>List = [term()]</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Returns <CODE>true</CODE> if <CODE>Elem</CODE> is an element of
         <CODE>List</CODE>, otherwise <CODE>false</CODE>.
</DIV>

<P><A NAME="merge/1"><STRONG><CODE>merge(ListOfLists) -&#62; List1</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>ListOfLists = [List]</CODE></STRONG><BR>
<STRONG><CODE>List = List1 = [term()]</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Returns the sorted list formed by merging all the sub-lists
         of <CODE>ListOfLists</CODE>. All sub-lists must be sorted prior to 
         evaluating this function.
</DIV>

<P><A NAME="merge/2"><STRONG><CODE>merge(List1, List2) -&#62; List3</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>List1 = List2 = List3 = [term()]</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Returns the sorted list formed by merging <CODE>List1</CODE> and
<CODE>List2</CODE>. Both <CODE>List1</CODE> and <CODE>List2</CODE> must be
sorted prior to evaluating this function.
</DIV>

<P><A NAME="merge/3"><STRONG><CODE>merge(Fun, List1, List2) -&#62; List3</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>Fun = fun(A, B) -&#62; bool()</CODE></STRONG><BR>
<STRONG><CODE>List1 = [A]</CODE></STRONG><BR>
<STRONG><CODE>List2 = [B]</CODE></STRONG><BR>
<STRONG><CODE>List3 = [A | B]</CODE></STRONG><BR>
<STRONG><CODE>A = B = term()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Returns the sorted list formed by merging <CODE>List1</CODE> and
<CODE>List2</CODE>. Both <CODE>List1</CODE> and <CODE>List2</CODE> must be
sorted according to the ordering function <CODE>Fun</CODE> prior
to evaluating this function. <CODE>Fun(A, B)</CODE> should return
<CODE>true</CODE> if <CODE>A</CODE> comes before <CODE>B</CODE> in the ordering,
         <CODE>false</CODE> otherwise.
</DIV>

<P><A NAME="merge3/3"><STRONG><CODE>merge3(List1, List2, List3) -&#62; List4</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>List1 = List2 = List3 = List4 = [term()]</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Returns the sorted list formed by merging <CODE>List1</CODE>, 
         <CODE>List2</CODE> and <CODE>List3</CODE>. All of <CODE>List1</CODE>,
         <CODE>List2</CODE> and <CODE>List3</CODE> must be sorted prior to
         evaluating this function.
</DIV>

<P><A NAME="min/1"><STRONG><CODE>min(List) -&#62; Min</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>List = [term()], length(List)&#62;0</CODE></STRONG><BR>
<STRONG><CODE>Min = term()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Returns the minimum element of <CODE>List</CODE>.
</DIV>

<P><A NAME="nth/2"><STRONG><CODE>nth(N, List) -&#62; Elem</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>N = 1..length(List)</CODE></STRONG><BR>
<STRONG><CODE>List = [term()]</CODE></STRONG><BR>
<STRONG><CODE>Elem = term()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Returns the Nth element of <CODE>List</CODE>. For example:
<PRE>
&#62; <STRONG>lists:nth(3, [a, b, c, d, e]).</STRONG>
c
        
</PRE>

</DIV>

<P><A NAME="nthtail/2"><STRONG><CODE>nthtail(N, List1) -&#62; Tail</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>N = 0..length(List1)</CODE></STRONG><BR>
<STRONG><CODE>List1 = Tail = [term()]</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Returns the Nth tail of <CODE>List</CODE>, that is, the sublist of
         <CODE>List</CODE> starting at <CODE>N+1</CODE> and continuing up to
         the end of the list. For example:
<PRE>
&#62; <STRONG>lists:nthtail(3, [a, b, c, d, e]).</STRONG>
[d,e]
&#62; <STRONG>tl(tl(tl([a, b, c, d, e]))).</STRONG>
[d,e]
&#62; <STRONG>lists:nthtail(0, [a, b, c, d, e]).</STRONG>
[a,b,c,d,e]
&#62; <STRONG>lists:nthtail(5, [a, b, c, d, e]).</STRONG>
[]
        
</PRE>

</DIV>

<P><A NAME="prefix/2"><STRONG><CODE>prefix(List1, List2) -&#62; bool()</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>List1 = List2 = [term()]</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Returns <CODE>true</CODE> if <CODE>List1</CODE> is a prefix of
<CODE>List2</CODE>, otherwise <CODE>false</CODE>.
</DIV>

<P><A NAME="reverse/1"><STRONG><CODE>reverse(List1) -&#62; List2</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>List1 = List2 = [term()]</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Returns a list with the top level elements in <CODE>List1</CODE>
in reverse order.
</DIV>

<P><A NAME="reverse/2"><STRONG><CODE>reverse(List1, Tail) -&#62; List2</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>List1 = Tail = List2 = [term()]</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Returns a list with the top level elements in <CODE>List1</CODE>
         in reverse order, with the tail <CODE>Tail</CODE> appended. For
         example:
<PRE>
&#62; <STRONG>lists:reverse([1, 2, 3, 4], [a, b, c]).</STRONG>
[4,3,2,1,a,b,c]
        
</PRE>

</DIV>

<P><A NAME="seq/2"><STRONG><CODE>seq(From, To) -&#62; Seq</CODE></STRONG></A><BR>
<A NAME="seq/3"><STRONG><CODE>seq(From, To, Incr) -&#62; Seq</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>From = To = Incr = int()</CODE></STRONG><BR>
<STRONG><CODE>Seq = [int()]</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Returns a sequence of integers which starts with <CODE>From</CODE>
         and contains the successive results of adding <CODE>Incr</CODE> to
         the previous element, until <CODE>To</CODE> has been reached or
         passed (in the latter case, <CODE>To</CODE> is not an element of
         the sequence). <CODE>Incr</CODE> defaults to 1.
<P>Failure: If <CODE>To&#60;From</CODE> and <CODE>Incr</CODE> is positive, or
         if <CODE>To&#62;From</CODE> and <CODE>Incr</CODE> is negative, or if
         <CODE>Incr==0</CODE> and <CODE>From/=To</CODE>.
<P>Examples:
<PRE>
&#62; <STRONG>lists:seq(1, 10).</STRONG>
[1,2,3,4,5,6,7,8,9,10]
&#62; <STRONG>lists:seq(1, 20, 3).</STRONG>
[1,4,7,10,13,16,19]
&#62; <STRONG>lists:seq(1, 1, 0).</STRONG>
[1]
        
</PRE>

</DIV>

<P><A NAME="sort/1"><STRONG><CODE>sort(List1) -&#62; List2</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>List1 = List2 = [term()]</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Returns a list containing the sorted elements of
         <CODE>List1</CODE>.
</DIV>

<P><A NAME="sort/2"><STRONG><CODE>sort(Fun, List1) -&#62; List2</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>Fun = fun(Elem1, Elem2) -&#62; bool()</CODE></STRONG><BR>
<STRONG><CODE>Elem1 = Elem2 = term()</CODE></STRONG><BR>
<STRONG><CODE>List1 = List2 = [term()]</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Returns a list containing the sorted elements of
         <CODE>List1</CODE>, according to the ordering function <CODE>Fun</CODE>.
         <CODE>Fun(A, B)</CODE> should return <CODE>true</CODE> if <CODE>A</CODE> comes
         before <CODE>B</CODE> in the ordering, <CODE>false</CODE> otherwise.
</DIV>

<P><A NAME="split/2"><STRONG><CODE>split(N, List1) -&#62; {List2, List3}</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>N = 0..length(List1)</CODE></STRONG><BR>
<STRONG><CODE>List1 = List2 = List3 = [term()]</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Splits <CODE>List1</CODE> into <CODE>List2</CODE> and <CODE>List3</CODE>.
         <CODE>List2</CODE> contains the first <CODE>N</CODE> elements and
         <CODE>List3</CODE> the rest of the elements (the Nth tail).
</DIV>

<P><A NAME="sublist/2"><STRONG><CODE>sublist(List1, Len) -&#62; List2</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>List1 = List2 = [term()]</CODE></STRONG><BR>
<STRONG><CODE>Len = int()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Returns the sub-list of <CODE>List1</CODE> starting at position 1
         and with (max) <CODE>Len</CODE> elements. It is not an error for
         <CODE>Len</CODE> to exceed the length of the list -- in that case
         the whole list is returned.
</DIV>

<P><A NAME="sublist/3"><STRONG><CODE>sublist(List1, Start, Len) -&#62; List2</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>List1 = List2 = [term()]</CODE></STRONG><BR>
<STRONG><CODE>Start = 1..(length(List1)+1)</CODE></STRONG><BR>
<STRONG><CODE>Len = int()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Returns the sub-list of <CODE>List1</CODE> starting at <CODE>Start</CODE>
and with (max) <CODE>Len</CODE> elements. It is not an error for
         <CODE>Start+Len</CODE> to exceed the length of the list.
<PRE>
&#62; <STRONG>lists:sublist([1,2,3,4], 2, 2).</STRONG>
[2,3]
&#62; <STRONG>lists:sublist([1,2,3,4], 2, 5).</STRONG>
[2,3,4]
&#62; <STRONG>lists:sublist([1,2,3,4], 5, 2).</STRONG>
[]
        
</PRE>

</DIV>

<P><A NAME="subtract/2"><STRONG><CODE>subtract(List1, List2) -&#62; List3</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>List1 = List2 = List3 = [term()]</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Returns a new list <CODE>List3</CODE> which is a copy of
         <CODE>List1</CODE>, subjected to the following procedure: for each
         element in <CODE>List2</CODE>, its first occurrence in <CODE>List1</CODE>
         is removed. For example:
<PRE>
&#62; <STRONG>lists:subtract(&#34;123212&#34;, &#34;212&#34;).</STRONG>
&#34;312&#34;.
        
</PRE>

<P><CODE>lists:subtract(A,B)</CODE> is equivalent to <CODE>A -- B</CODE>.
        
</DIV>

<P><A NAME="suffix/2"><STRONG><CODE>suffix(List1, List2) -&#62; bool()</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY>

<P>Returns <CODE>true</CODE> if <CODE>List1</CODE> is a suffix of
<CODE>List2</CODE>, otherwise <CODE>false</CODE>.
</DIV>

<P><A NAME="sum/1"><STRONG><CODE>sum(List) -&#62; number()</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>List = [number()]</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Returns the sum of the elements in <CODE>List</CODE>.
</DIV>

<P><A NAME="ukeymerge/3"><STRONG><CODE>ukeymerge(N, TupleList1, TupleList2) -&#62; TupleList3</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>N = 1..size(Tuple)</CODE></STRONG><BR>
<STRONG><CODE>TupleList1 = TupleList2 = TupleList3 = [Tuple]</CODE></STRONG><BR>
<STRONG><CODE>Tuple = tuple()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Returns the sorted list formed by merging <CODE>TupleList1</CODE>
and <CODE>TupleList2</CODE> while removing consecutive duplicate
keys. The merge is performed on the <CODE>N</CODE>th element of
each tuple. Both <CODE>TupleList1</CODE> and <CODE>TupleList2</CODE>
must be key-sorted without duplicates prior to evaluating
this function. When elements in the input lists compare
equal, elements from <CODE>TupleList1</CODE> are picked.
</DIV>

<P><A NAME="ukeysort/2"><STRONG><CODE>ukeysort(N, TupleList1) -&#62; TupleList2</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>N = 1..size(Tuple)</CODE></STRONG><BR>
<STRONG><CODE>TupleList1 = TupleList2 = [Tuple]</CODE></STRONG><BR>
<STRONG><CODE>Tuple = tuple()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Returns a list containing the sorted elements of
<CODE>TupleList1</CODE> where all but the first element of the
elements comparing equal have been removed. Sorting is
performed on the Nth element of the tuples.
</DIV>

<P><A NAME="umerge/1"><STRONG><CODE>umerge(ListOfLists) -&#62; List1</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>ListOfLists = [List]</CODE></STRONG><BR>
<STRONG><CODE>List = List1 = [term()]</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Returns the sorted list formed by merging all the sub-lists
         of <CODE>ListOfLists</CODE> while removing duplicates. All sub-lists
         must be sorted and contain no duplicates prior to evaluating
         this function.
</DIV>

<P><A NAME="umerge/2"><STRONG><CODE>umerge(List1, List2) -&#62; List3</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>List1 = List2 = List3 = [term()]</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Returns the sorted list formed by merging <CODE>List1</CODE> and
<CODE>List2</CODE> while removing duplicates. Both <CODE>List1</CODE>
and <CODE>List2</CODE> must be sorted and contain no duplicates
prior to evaluating this function.
</DIV>

<P><A NAME="umerge/3"><STRONG><CODE>umerge(Fun, List1, List2) -&#62; List3</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>Fun = fun(A, B) -&#62; bool()</CODE></STRONG><BR>
<STRONG><CODE>List1 = [A]</CODE></STRONG><BR>
<STRONG><CODE>List2 = [B]</CODE></STRONG><BR>
<STRONG><CODE>List3 = [A | B]</CODE></STRONG><BR>
<STRONG><CODE>A = B = term()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Returns the sorted list formed by merging <CODE>List1</CODE> and
<CODE>List2</CODE> while removing consecutive duplicates. Both
         <CODE>List1</CODE> and <CODE>List2</CODE> must be sorted according to
         the ordering function <CODE>Fun</CODE> and contain no duplicates
         prior to evaluating this function. <CODE>Fun(A, B)</CODE> should
         return <CODE>true</CODE> if <CODE>A</CODE> equals or comes before <CODE>B</CODE>
         in the ordering, <CODE>false</CODE> otherwise.
</DIV>

<P><A NAME="umerge3/3"><STRONG><CODE>umerge3(List1, List2, List3) -&#62; List4</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>List1 = List2 = List3 = List4 = [term()]</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Returns the sorted list formed by merging <CODE>List1</CODE>,
         <CODE>List2</CODE> and <CODE>List3</CODE> while removing duplicates. All
         of <CODE>List1</CODE>, <CODE>List2</CODE> and <CODE>List3</CODE> must be
         sorted and contain no duplicates prior to evaluating this
         function.
</DIV>

<P><A NAME="unzip/1"><STRONG><CODE>unzip(List1) -&#62; {List2, List3}</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>List1 = [{X, Y}]</CODE></STRONG><BR>
<STRONG><CODE>List2 = [X]</CODE></STRONG><BR>
<STRONG><CODE>List3 = [Y]</CODE></STRONG><BR>
<STRONG><CODE>X = Y = term()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>&#34;Unzips&#34; a list of two-tuples into two lists, where the first
         list contains the first element of each tuple, and the second
         list contains the second element of each tuple.
</DIV>

<P><A NAME="unzip3/1"><STRONG><CODE>unzip3(List1) -&#62; {List2, List3, List4}</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>List1 = [{X, Y, Z}]</CODE></STRONG><BR>
<STRONG><CODE>List2 = [X]</CODE></STRONG><BR>
<STRONG><CODE>List3 = [Y]</CODE></STRONG><BR>
<STRONG><CODE>List4 = [Z]</CODE></STRONG><BR>
<STRONG><CODE>X = Y = Z = term()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>&#34;Unzips&#34; a list of three-tuples into three lists, where
         the first list contains the first element of each tuple,
         the second list contains the second element of each tuple, and
         the third list contains the third element of each tuple.
</DIV>

<P><A NAME="usort/1"><STRONG><CODE>usort(List1) -&#62; List2</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>List1 = List2 = [term()]</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Returns a list containing the sorted elements of <CODE>List1</CODE>
         without duplicates.
</DIV>

<P><A NAME="usort/2"><STRONG><CODE>usort(Fun, List1) -&#62; List2</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>Fun = fun(Elem1, Elem2) -&#62; bool()</CODE></STRONG><BR>
<STRONG><CODE>Elem1 = Elem2 = term()</CODE></STRONG><BR>
<STRONG><CODE>List1 = List2 = [term()]</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Returns a list which contains the sorted elements of
<CODE>List1</CODE> where all but the first element of the elements
comparing equal according to the ordering function
<CODE>Fun</CODE> have been removed.<CODE>Fun(A, B)</CODE> should return
<CODE>true</CODE> if <CODE>A</CODE> equals or comes before <CODE>B</CODE> in
the ordering, <CODE>false</CODE> otherwise.
</DIV>

<P><A NAME="zip/2"><STRONG><CODE>zip(List1, List2) -&#62; List3</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>List1 = [X]</CODE></STRONG><BR>
<STRONG><CODE>List2 = [Y]</CODE></STRONG><BR>
<STRONG><CODE>List3 = [{X, Y}]</CODE></STRONG><BR>
<STRONG><CODE>X = Y = term()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>&#34;Zips&#34; two lists of equal length into one list of two-tuples,
         where the first element of each tuple is taken from the first
         list and the second element is taken from corresponding
         element in the second list.
</DIV>

<P><A NAME="zip3/3"><STRONG><CODE>zip3(List1, List2, List3) -&#62; List4</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>List1 = [X]</CODE></STRONG><BR>
<STRONG><CODE>List2 = [Y]</CODE></STRONG><BR>
<STRONG><CODE>List3 = [Z]</CODE></STRONG><BR>
<STRONG><CODE>List3 = [{X, Y, Z}]</CODE></STRONG><BR>
<STRONG><CODE>X = Y = Z = term()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>&#34;Zips&#34; three lists of equal length into one list of
         three-tuples, where the first element of each tuple is taken
         from the first list, the second element is taken from
         corresponding element in the second list, and the third
         element is taken from the corresponding element in the third
         list.
</DIV>

<P><A NAME="zipwith/3"><STRONG><CODE>zipwith(Combine, List1, List2) -&#62; List3</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>Combine = fun(X, Y) -&#62; T</CODE></STRONG><BR>
<STRONG><CODE>List1 = [X]</CODE></STRONG><BR>
<STRONG><CODE>List2 = [Y]</CODE></STRONG><BR>
<STRONG><CODE>List3 = [T]</CODE></STRONG><BR>
<STRONG><CODE>X = Y = T = term()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Combine the elements of two lists of equal length into one
         list. For each pair <CODE>X, Y</CODE> of list elements from the two
         lists, the element in the result list will be
         <CODE>Combine(X, Y)</CODE>.
<P><CODE>zipwith(fun(X, Y) -&#62; {X,Y} end, List1, List2)</CODE> is
         equivalent to <CODE>zip(List1, List2)</CODE>.
<P>Examples:
<PRE>
&#62; <STRONG>lists:zipwith(fun(X, Y) -&#62; X+Y end, [1,2,3], [4,5,6]).</STRONG>
[5,7,9]
        
</PRE>

</DIV>

<P><A NAME="zipwith3/4"><STRONG><CODE>zipwith3(Combine, List1, List2, List3) -&#62; List4</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>Combine = fun(X, Y, Z) -&#62; T</CODE></STRONG><BR>
<STRONG><CODE>List1 = [X]</CODE></STRONG><BR>
<STRONG><CODE>List2 = [Y]</CODE></STRONG><BR>
<STRONG><CODE>List3 = [Z]</CODE></STRONG><BR>
<STRONG><CODE>List4 = [T]</CODE></STRONG><BR>
<STRONG><CODE>X = Y = Z = T = term()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Combine the elements of three lists of equal length into one
         list. For each triple <CODE>X, Y, Z</CODE> of list elements from
         the three lists, the element in the result list will be
         <CODE>Combine(X, Y, Z)</CODE>.
<P><CODE>zipwith3(fun(X, Y, Z) -&#62; {X,Y,Z} end, List1, List2,
         List3)</CODE> is equivalent to <CODE>zip3(List1, List2,
         List3)</CODE>.
<P>Examples:
<PRE>
&#62; <STRONG>lists:zipwith3(fun(X, Y, Z) -&#62; X+Y+Z end, [1,2,3], [4,5,6], [7,8,9]).</STRONG>
[12,15,18]
&#62; <STRONG>lists:zipwith3(fun(X, Y, Z) -&#62; [X,Y,Z] end, [a,b,c], [x,y,z], [1,2,3]).</STRONG>
[[a,x,1],[b,y,2],[c,z,3]]
        
</PRE>

</DIV>

<P><A NAME="all/2"><STRONG><CODE>all(Pred, List) -&#62; bool()</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>Pred = fun(Elem) -&#62; bool()</CODE></STRONG><BR>
<STRONG><CODE>Elem = term()</CODE></STRONG><BR>
<STRONG><CODE>List = [term()]</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Returns <CODE>true</CODE> if <CODE>Pred(Elem)</CODE> returns
         <CODE>true</CODE> for all elements <CODE>Elem</CODE> in <CODE>List</CODE>,
         otherwise <CODE>false</CODE>.
</DIV>

<P><A NAME="any/2"><STRONG><CODE>any(Pred, List) -&#62; bool()</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>Pred = fun(Elem) -&#62; bool()</CODE></STRONG><BR>
<STRONG><CODE>Elem = term()</CODE></STRONG><BR>
<STRONG><CODE>List = [term()]</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Returns <CODE>true</CODE> if <CODE>Pred(Elem)</CODE> returns
         <CODE>true</CODE> for at least one element <CODE>Elem</CODE> in
         <CODE>List</CODE>.
</DIV>

<P><A NAME="dropwhile/2"><STRONG><CODE>dropwhile(Pred, List1) -&#62; List2</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>Pred = fun(Elem) -&#62; bool()</CODE></STRONG><BR>
<STRONG><CODE>Elem = term()</CODE></STRONG><BR>
<STRONG><CODE>List1 = List2 = [term()]</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Drops elements <CODE>Elem</CODE> from <CODE>List1</CODE> while
         <CODE>Pred(Elem)</CODE> returns <CODE>true</CODE> and returns
         the remaining list.
</DIV>

<P><A NAME="filter/2"><STRONG><CODE>filter(Pred, List1) -&#62; List2</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>Pred = fun(Elem) -&#62; bool()</CODE></STRONG><BR>
<STRONG><CODE>Elem = term()</CODE></STRONG><BR>
<STRONG><CODE>List1 = List2 = [term()]</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P><CODE>List2</CODE> is a list of all elements <CODE>Elem</CODE> in
<CODE>List1</CODE> for which <CODE>Pred(Elem)</CODE> returns
         <CODE>true</CODE>.
</DIV>

<P><A NAME="flatmap/2"><STRONG><CODE>flatmap(Fun, List1) -&#62; List2</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>Fun = fun(A) -&#62; [B]</CODE></STRONG><BR>
<STRONG><CODE>List1 = [A]</CODE></STRONG><BR>
<STRONG><CODE>List2 = [B]</CODE></STRONG><BR>
<STRONG><CODE>A = B = term()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Takes a function from <CODE>A</CODE>s to lists of <CODE>B</CODE>s, and a
         list of <CODE>A</CODE>s (<CODE>List1</CODE>) and produces a list of
         <CODE>B</CODE>s by applying the function to every element in
         <CODE>List1</CODE> and appending the resulting lists.
<P>That is, <CODE>flatmap</CODE> behaves as if it had been defined as
         follows:
<PRE>
flatmap(Fun, List1) -&#62;
    append(map(Fun, List1))
        
</PRE>

<P>Example:
<PRE>
&#62; <STRONG>lists:flatmap(fun(X)-&#62;[X,X] end, [a,b,c]).</STRONG>
[a,a,b,b,c,c]
</PRE>

</DIV>

<P><A NAME="foldl/3"><STRONG><CODE>foldl(Fun, Acc0, List) -&#62; Acc1</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>Fun = fun(Elem, AccIn) -&#62; AccOut</CODE></STRONG><BR>
<STRONG><CODE>Elem = term()</CODE></STRONG><BR>
<STRONG><CODE>Acc0 = Acc1 = AccIn = AccOut = term()</CODE></STRONG><BR>
<STRONG><CODE>List = [term()]</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Calls <CODE>Fun(Elem, AccIn)</CODE> on successive elements <CODE>A</CODE>
         of <CODE>List</CODE>, starting with <CODE>AccIn == Acc0</CODE>.
         <CODE>Fun/2</CODE> must return a new accumulator which is passed to
         the next call. The function returns the final value of
         the accumulator. <CODE>Acc0</CODE> is returned if the list is empty.
         For example:
<PRE>
&#62; <STRONG>lists:foldl(fun(X, Sum) -&#62; X + Sum end, 0, [1,2,3,4,5]).</STRONG>
15
&#62; <STRONG>lists:foldl(fun(X, Prod) -&#62; X * Prod end, 1, [1,2,3,4,5]).</STRONG>
120
        
</PRE>

</DIV>

<P><A NAME="foldr/3"><STRONG><CODE>foldr(Fun, Acc0, List) -&#62; Acc1</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>Fun = fun(Elem, AccIn) -&#62; AccOut</CODE></STRONG><BR>
<STRONG><CODE>Elem = term()</CODE></STRONG><BR>
<STRONG><CODE>Acc0 = Acc1 = AccIn = AccOut = term()</CODE></STRONG><BR>
<STRONG><CODE>List = [term()]</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Like <CODE>foldl/3</CODE>, but the list is traversed from right to
         left. For example:
<PRE>
&#62; <STRONG>P = fun(A, AccIn) -&#62; io:format(&#34;~p &#34;, [A]), AccIn end.</STRONG>
#Fun&#60;erl_eval.12.2225172&#62;
&#62; <STRONG>lists:foldl(P, void, [1,2,3]).</STRONG>
1 2 3 void
&#62; <STRONG>lists:foldr(P, void, [1,2,3]).</STRONG>
3 2 1 void
        
</PRE>

<P><CODE>foldl/3</CODE> is tail recursive and would usually be
         preferred to <CODE>foldr/3</CODE>.
</DIV>

<P><A NAME="foreach/2"><STRONG><CODE>foreach(Fun, List) -&#62; void()</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>Fun = fun(Elem) -&#62; void()</CODE></STRONG><BR>
<STRONG><CODE>Elem = term()</CODE></STRONG><BR>
<STRONG><CODE>List = [term()]</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Calls <CODE>Fun(Elem)</CODE> for each element <CODE>Elem</CODE> in
         <CODE>List</CODE>. This function is used for its side effects and
         the evaluation order is defined to be the same as the order
         of the elements in the list.
</DIV>

<P><A NAME="keymap/3"><STRONG><CODE>keymap(Fun, N, TupleList1) -&#62; TupleList2</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>Fun = fun(Term1) -&#62; Term2</CODE></STRONG><BR>
<STRONG><CODE>Term1 = Term2 = term()</CODE></STRONG><BR>
<STRONG><CODE>N = 1..size(Tuple)</CODE></STRONG><BR>
<STRONG><CODE>TupleList1 = TupleList2 = [tuple()]</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Returns a list of tuples where, for each tuple in
         <CODE>TupleList1</CODE>, the Nth element <CODE>Term1</CODE> of the tuple
         has been replaced with the result of calling
         <CODE>Fun(Term1)</CODE>.
<P>Examples:
<PRE>
&#62; <STRONG>Fun = fun(Atom) -&#62; atom_to_list(Atom) end.</STRONG>
#Fun&#60;erl_eval.6.10732646&#62;
2&#62; <STRONG>lists:keymap(Fun, 2, [{name,jane,22},{name,lizzie,20},{name,lydia,15}]).</STRONG>
[{name,&#34;jane&#34;,22},{name,&#34;lizzie&#34;,20},{name,&#34;lydia&#34;,15}]

        
</PRE>

</DIV>

<P><A NAME="map/2"><STRONG><CODE>map(Fun, List1) -&#62; List2</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>Fun = fun(A) -&#62; B</CODE></STRONG><BR>
<STRONG><CODE>List1 = [A]</CODE></STRONG><BR>
<STRONG><CODE>List2 = [B]</CODE></STRONG><BR>
<STRONG><CODE>A = B = term()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Takes a function from <CODE>A</CODE>s to <CODE>B</CODE>s, and a list of
         <CODE>A</CODE>s and produces a list of <CODE>B</CODE>s by applying
         the function to every element in the list. This function is
         used to obtain the return values. The evaluation order is
         implementation dependent.
</DIV>

<P><A NAME="mapfoldl/3"><STRONG><CODE>mapfoldl(Fun, Acc0, List1) -&#62; {List2, Acc1}</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>Fun = fun(A, AccIn) -&#62; {B, AccOut}</CODE></STRONG><BR>
<STRONG><CODE>Acc0 = Acc1 = AccIn = AccOut = term()</CODE></STRONG><BR>
<STRONG><CODE>List1 = [A]</CODE></STRONG><BR>
<STRONG><CODE>List2 = [B]</CODE></STRONG><BR>
<STRONG><CODE>A = B = term()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P><CODE>mapfold</CODE> combines the operations of <CODE>map/2</CODE> and
<CODE>foldl/3</CODE> into one pass. An example, summing
         the elements in a list and double them at the same time:
<PRE>
 
&#62; <STRONG>lists:mapfoldl(fun(X, Sum) -&#62; {2*X, X+Sum} end,</STRONG>
  <STRONG> 0, [1,2,3,4,5]).</STRONG>
{[2,4,6,8,10],15}
        
</PRE>

</DIV>

<P><A NAME="mapfoldr/3"><STRONG><CODE>mapfoldr(Fun, Acc0, List1) -&#62; {List2, Acc1}</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>Fun = fun(A, AccIn) -&#62; {B, AccOut}</CODE></STRONG><BR>
<STRONG><CODE>Acc0 = Acc1 = AccIn = AccOut = term()</CODE></STRONG><BR>
<STRONG><CODE>List1 = [A]</CODE></STRONG><BR>
<STRONG><CODE>List2 = [B]</CODE></STRONG><BR>
<STRONG><CODE>A = B = term()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P><CODE>mapfold</CODE> combines the operations of <CODE>map/2</CODE> and
<CODE>foldr/3</CODE> into one pass.
</DIV>

<P><A NAME="partition/2"><STRONG><CODE>partition(Pred, List) -&#62; {Satisfying, NonSatisfying}</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>Pred = fun(Elem) -&#62; bool()</CODE></STRONG><BR>
<STRONG><CODE>Elem = term()</CODE></STRONG><BR>
<STRONG><CODE>List = Satisfying = NonSatisfying = [term()]</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Partitions <CODE>List</CODE> into two lists, where the first list
         contains all elements for which <CODE>Pred(Elem)</CODE> returns
         <CODE>true</CODE>, and the second list contains all elements for
         which <CODE>Pred(Elem)</CODE> returns <CODE>false</CODE>.
<P>Examples:
<PRE>
&#62; <STRONG>lists:partition(fun(A) -&#62; A rem 2 == 1 end, [1,2,3,4,5,6,7]).</STRONG>
{[1,3,5,7],[2,4,6]}
&#62; <STRONG>lists:partition(fun(A) -&#62; is_atom(A) end, [a,b,1,c,d,2,3,4,e]).</STRONG>
{[a,b,c,d,e],[1,2,3,4]}
        
</PRE>

<P>See also <CODE>splitwith/2</CODE> for a different way to partition
         a list.
</DIV>

<P><A NAME="splitwith/2"><STRONG><CODE>splitwith(Pred, List) -&#62; {List1, List2}</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>Pred = fun(Elem) -&#62; bool()</CODE></STRONG><BR>
<STRONG><CODE>Elem = term()</CODE></STRONG><BR>
<STRONG><CODE>List = List1 = List2 = [term()]</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Partitions <CODE>List</CODE> into two lists according to
         <CODE>Pred</CODE>. <CODE>splitwith/2</CODE> behaves as if it is defined
         as follows:
<PRE>
splitwith(Pred, List) -&#62; 
    {takewhile(Pred, List), dropwhile(Pred, List)}.
        
</PRE>

<P>Examples:
<PRE>
&#62; <STRONG>lists:splitwith(fun(A) -&#62; A rem 2 == 1 end, [1,2,3,4,5,6,7]).</STRONG>
{[1],[2,3,4,5,6,7]}
&#62; <STRONG>lists:splitwith(fun(A) -&#62; is_atom(A) end, [a,b,1,c,d,2,3,4,e]).</STRONG>
{[a,b],[1,c,d,2,3,4,e]}
        
</PRE>

<P>See also <CODE>partition/2</CODE> for a different way to partition
         a list.
</DIV>

<P><A NAME="takewhile/2"><STRONG><CODE>takewhile(Pred, List1) -&#62; List2</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>Pred = fun(Elem) -&#62; bool()</CODE></STRONG><BR>
<STRONG><CODE>Elem = term()</CODE></STRONG><BR>
<STRONG><CODE>List1 = List2 = [term()]</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Takes elements <CODE>Elem</CODE> from <CODE>List1</CODE> while
         <CODE>Pred(Elem)</CODE> returns <CODE>true</CODE>, that is,
         the function returns the longest prefix of the list for which
         all elements satisfy the predicate.
</DIV>

<H3>AUTHORS</H3>
<DIV CLASS=REFBODY>
Joe Armstrong - support@erlang.ericsson.se<BR>
Robert Virding - support@erlang.ericsson.se<BR>

</DIV>
<CENTER>
<HR>
<SMALL>stdlib 1.14.2<BR>
Copyright &copy; 1991-2006
<A HREF="http://www.erlang.se">Ericsson AB</A><BR>
</SMALL>
</CENTER>
</BODY>
</HTML>