\HeaderA{SimpleList-class}{Simple and Compressed List Classes}{SimpleList.Rdash.class}
\aliasA{\$<-,CompressedList-method}{SimpleList-class}{.Rdol.<.Rdash.,CompressedList.Rdash.method}
\aliasA{\$<-,SimpleList-method}{SimpleList-class}{.Rdol.<.Rdash.,SimpleList.Rdash.method}
\aliasA{aggregate,CompressedList-method}{SimpleList-class}{aggregate,CompressedList.Rdash.method}
\aliasA{aggregate,SimpleList-method}{SimpleList-class}{aggregate,SimpleList.Rdash.method}
\aliasA{as.list,CompressedList-method}{SimpleList-class}{as.list,CompressedList.Rdash.method}
\aliasA{as.list,SimpleList-method}{SimpleList-class}{as.list,SimpleList.Rdash.method}
\aliasA{c,CompressedList-method}{SimpleList-class}{c,CompressedList.Rdash.method}
\aliasA{c,SimpleList-method}{SimpleList-class}{c,SimpleList.Rdash.method}
\aliasA{CompressedList}{SimpleList-class}{CompressedList}
\aliasA{CompressedList-class}{SimpleList-class}{CompressedList.Rdash.class}
\aliasA{endoapply,CompressedList-method}{SimpleList-class}{endoapply,CompressedList.Rdash.method}
\aliasA{endoapply,SimpleList-method}{SimpleList-class}{endoapply,SimpleList.Rdash.method}
\aliasA{isEmpty,CompressedList-method}{SimpleList-class}{isEmpty,CompressedList.Rdash.method}
\aliasA{isEmpty,SimpleList-method}{SimpleList-class}{isEmpty,SimpleList.Rdash.method}
\aliasA{lapply,CompressedList-method}{SimpleList-class}{lapply,CompressedList.Rdash.method}
\aliasA{lapply,SimpleList-method}{SimpleList-class}{lapply,SimpleList.Rdash.method}
\aliasA{length,CompressedList-method}{SimpleList-class}{length,CompressedList.Rdash.method}
\aliasA{length,SimpleList-method}{SimpleList-class}{length,SimpleList.Rdash.method}
\aliasA{mendoapply,CompressedList-method}{SimpleList-class}{mendoapply,CompressedList.Rdash.method}
\aliasA{mendoapply,SimpleList-method}{SimpleList-class}{mendoapply,SimpleList.Rdash.method}
\aliasA{names,CompressedList-method}{SimpleList-class}{names,CompressedList.Rdash.method}
\aliasA{names,SimpleList-method}{SimpleList-class}{names,SimpleList.Rdash.method}
\aliasA{names<-,CompressedList-method}{SimpleList-class}{names<.Rdash.,CompressedList.Rdash.method}
\aliasA{names<-,SimpleList-method}{SimpleList-class}{names<.Rdash.,SimpleList.Rdash.method}
\aliasA{seqselect,CompressedList-method}{SimpleList-class}{seqselect,CompressedList.Rdash.method}
\aliasA{seqselect,SimpleList-method}{SimpleList-class}{seqselect,SimpleList.Rdash.method}
\aliasA{seqselect<-,CompressedList-method}{SimpleList-class}{seqselect<.Rdash.,CompressedList.Rdash.method}
\aliasA{seqselect<-,SimpleList-method}{SimpleList-class}{seqselect<.Rdash.,SimpleList.Rdash.method}
\aliasA{show,CompressedList-method}{SimpleList-class}{show,CompressedList.Rdash.method}
\aliasA{show,SimpleList-method}{SimpleList-class}{show,SimpleList.Rdash.method}
\aliasA{SimpleList}{SimpleList-class}{SimpleList}
\aliasA{unlist,CompressedList-method}{SimpleList-class}{unlist,CompressedList.Rdash.method}
\aliasA{unlist,SimpleList-method}{SimpleList-class}{unlist,SimpleList.Rdash.method}
\aliasA{[,CompressedList-method}{SimpleList-class}{[,CompressedList.Rdash.method}
\aliasA{[,SimpleList-method}{SimpleList-class}{[,SimpleList.Rdash.method}
\aliasA{[[,CompressedList-method}{SimpleList-class}{[[,CompressedList.Rdash.method}
\aliasA{[[,SimpleList-method}{SimpleList-class}{[[,SimpleList.Rdash.method}
\aliasA{[[<-,CompressedList-method}{SimpleList-class}{[[<.Rdash.,CompressedList.Rdash.method}
\aliasA{[[<-,SimpleList-method}{SimpleList-class}{[[<.Rdash.,SimpleList.Rdash.method}
\keyword{methods}{SimpleList-class}
\keyword{classes}{SimpleList-class}
\begin{Description}\relax
The (non-virtual) SimpleList and (virtual) CompressedList classes
extend the \LinkA{Sequence}{Sequence.Rdash.class} virtual class.
\end{Description}
\begin{Details}\relax
The SimpleList and CompressedList classes provide an implementation that
subclasses can easily extend. The underlying storage in a SimpleList
subclass is a list object. The underlying storage in a CompressedList
object is a virtually partitioned vector-like object. For more information
on the available methods, see the \LinkA{Sequence}{Sequence.Rdash.class} man page.
\end{Details}
\begin{Section}{Constructor}
The SimpleList class constructor is used to create SimpleList objects:

\describe{
\item[] \code{SimpleList(...)}: takes possibly named objects as elements
for the new SimpleList object.

}
\end{Section}
\begin{Section}{Coercion}
In the following code snippets, \code{x} is a SimpleList or CompressedList
object.

\describe{
\item[] \code{as.list(x)}: Copies the elements of \code{x} into a new R
list object.

\item[] \code{unlist(x, recursive = TRUE, use.names = TRUE)}: Concatenates
the elements of \code{x} into a single \code{elementType(x)} object.

}
\end{Section}
\begin{Section}{Subsetting}
In the following code snippets, \code{x} is a SimpleList or CompressedList
object.

\describe{
\item[] \code{x[i]}:
In addition to normal usage, the \code{i} parameter can be a
\code{RangesList}, logical \code{RleList}, \code{LogicalList}, or
\code{IntegerList} object to perform subsetting within the list
elements rather than across them.

\item[] \code{x[i] <- value}:
In addition to normal usage, the \code{i} parameter can be a
\code{RangesList}, logical \code{RleList}, \code{LogicalList}, or
\code{IntegerList} object to perform subsetting within the list
elements rather than across them.

\item[] \code{seqselect(x, start=NULL, end=NULL, width=NULL)}:
In addition to normal usage, the \code{start} parameter can be a
\code{RangesList}, logical \code{RleList}, \code{LogicalList}, or
\code{IntegerList} object to perform sequence extraction within the
list elements rather than across them.

\item[] \code{seqselect(x, start=NULL, end=NULL, width=NULL) <- value}:
In addition to normal usage, the \code{start} parameter can be a
\code{RangesList}, logical \code{RleList}, \code{LogicalList}, or
\code{IntegerList} object to perform sequence replacement within the
list elements rather than across them.

}
\end{Section}
\begin{Section}{Looping}
In the following code snippets, \code{x} is a SimpleList or CompressedList
object.

\describe{
\item[] \code{aggregate(x, by, FUN, start = NULL, end = NULL, width = NULL,
                      frequency = NULL, delta = NULL, ..., simplify = TRUE))}:
In addition to normal usage, the \code{by} parameter can be a
\code{RangesList} to aggregate within the list elements rather
than across them. When \code{by} is a \code{RangesList}, the output is
either a \code{SimpleAtomicList} object, if possible, or a
\code{SimpleList} object, if not.

}
\end{Section}
\begin{Author}\relax
P. Aboyoun
\end{Author}
\begin{SeeAlso}\relax
\LinkA{Sequence}{Sequence.Rdash.class},
\LinkA{AtomicList}{AtomicList.Rdash.class} and
\LinkA{RangesList}{RangesList.Rdash.class} for example implementations
\end{SeeAlso}
\begin{Examples}
\begin{ExampleCode}
SimpleList(a = letters, ranges = IRanges(1:10, 1:10))
\end{ExampleCode}
\end{Examples}

