\HeaderA{slot}{The Slots in an Object from a Formal Class}{slot}
\aliasA{.slotNames}{slot}{.slotNames}
\aliasA{@<\Rdash}{slot}{@<.Rdash.}
\aliasA{getSlots}{slot}{getSlots}
\aliasA{slot<\Rdash}{slot}{slot<.Rdash.}
\aliasA{slotNames}{slot}{slotNames}
\keyword{programming}{slot}
\keyword{classes}{slot}
\begin{Description}\relax
These functions return or set information about the individual slots
in an object.
\end{Description}
\begin{Usage}
\begin{verbatim}
object@name
object@name <- value

slot(object, name)
slot(object, name, check = TRUE) <- value

slotNames(x)
getSlots(x)

\end{verbatim}
\end{Usage}
\begin{Arguments}
\begin{ldescription}
\item[\code{object}] An object from a formally defined class.
\item[\code{name}] The name of the slot. The operator
takes a fixed name, which can be unquoted if it is syntactically a
name in the language.  A slot name can be any non-empty string, but
if the name is not made up of letters, numbers, and \code{.}, it
needs to be quoted (by backticks or single or double quotes).


In the case of the \code{slot} function, \code{name} can be any
expression that evaluates to a valid slot in the class definition.
Generally, the only reason to use the functional form rather than
the simpler operator is \emph{because} the slot name has to be computed.

\item[\code{value}] A new value for the named slot.  The value must be
valid for this slot in this object's class.
\item[\code{check}] In the replacement version of \code{slot}, a flag.  If \code{TRUE}, check the assigned value for validity
as the value of this slot.  User's coded should not set this to
\code{FALSE} in normal use, since the resulting object can be invalid.

\item[\code{x}] Either the name of a class or a class definition.
If given an argument that is neither a character string nor a
class definition, \code{slotNames} (only) uses \code{class(x)} instead.
\end{ldescription}
\end{Arguments}
\begin{Details}\relax
The definition of the class specifies all slots directly
and indirectly defined for that class.  Each slot has a name and an associated
class.  Extracting a slot returns an object from that class.  Setting
a slot first coerces the value to the specified slot and then stores
it.

Unlike general attributes, slots are not partially matched, and asking for (or
trying to set) a slot with an invalid name for that class generates an
error.

The \code{\LinkA{@}{@}} extraction operator and \code{slot}
function themselves do no checking against the class definition,
simply matching the name in the object itself.
The replacement forms do check (except for \code{slot} in the case
\code{check=FALSE}).  So long as slots are set without cheating, the
extracted slots will be valid.

Be aware that there are two ways to cheat, both to be avoided but
with no guarantees.  The obvious way is to assign a slot with
\code{check=FALSE}.  Also, slots in \R{} are implemented as
attributes, for the sake of some back compatibility.  The current
implementation does not prevent attributes being assigned, via
\code{\LinkA{attr<\Rdash}{attr<.Rdash.}}, and such assignments are not checked for
legitimate slot names.
\end{Details}
\begin{Value}
The \code{"@"} operator and the \code{slot} function extract or
replace the formally defined slots for the object.  

Functions \code{slotNames} and \code{getSlots} return respectively the
names of the slots and the classes associated with the slots in the
specified class definition.  Except for its extended interpretation of
\code{x} (above), \code{slotNames(x)} is just \code{names(getSlots(x))}.
\end{Value}
\begin{References}\relax
Chambers, John M. (2008)
\emph{Software for Data Analysis: Programming with R}
Springer.  (For the R version.)

Chambers, John M. (1998)
\emph{Programming with Data}
Springer (For the original S4 version.)
\end{References}
\begin{SeeAlso}\relax
\code{\LinkA{@}{@}},
\code{\LinkA{Classes}{Classes}},
\code{\LinkA{Methods}{Methods}},
\code{\LinkA{getClass}{getClass}}
\end{SeeAlso}
\begin{Examples}
\begin{ExampleCode}


setClass("track", representation(x="numeric", y="numeric"))
myTrack <- new("track", x = -4:4, y = exp(-4:4))
slot(myTrack, "x")
slot(myTrack, "y") <- log(slot(myTrack, "y"))
utils::str(myTrack)

getSlots("track") # or
getSlots(getClass("track"))
slotNames(class(myTrack)) # is the same as
slotNames(myTrack)


\end{ExampleCode}
\end{Examples}

