Next: Introduction, Previous: (dir), Up: (dir) [Contents][Index]
This is an introduction to the R language, explaining evaluation, parsing, object oriented programming, computing on the language, and so forth.
This manual is for R, version 3.1.1 (2014-07-10).
Copyright © 2000–2013 R Core Team
Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies.
Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided that the entire resulting derived work is distributed under the terms of a permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions, except that this permission notice may be stated in a translation approved by the R Core Team.
R is a system for statistical computation and graphics. It provides, among other things, a programming language, high level graphics, interfaces to other languages and debugging facilities. This manual details and defines the R language.
The R language is a dialect of S which was designed in the 1980s and has been in widespread use in the statistical community since. Its principal designer, John M. Chambers, was awarded the 1998 ACM Software Systems Award for S.
The language syntax has a superficial similarity with C, but the semantics are of the FPL (functional programming language) variety with stronger affinities with Lisp and APL. In particular, it allows “computing on the language”, which in turn makes it possible to write functions that take expressions as input, something that is often useful for statistical modeling and graphics.
It is possible to get quite far using R interactively, executing simple expressions from the command line. Some users may never need to go beyond that level, others will want to write their own functions either in an ad hoc fashion to systematize repetitive work or with the perspective of writing add-on packages for new functionality.
The purpose of this manual is to document the language per se. That is, the objects that it works on, and the details of the expression evaluation process, which are useful to know when programming R functions. Major subsystems for specific tasks, such as graphics, are only briefly described in this manual and will be documented separately.
Although much of the text will equally apply to S, there are also some substantial differences, and in order not to confuse the issue we shall concentrate on describing R.
The design of the language contains a number of fine points and common pitfalls which may surprise the user. Most of these are due to consistency considerations at a deeper level, as we shall explain. There are also a number of useful shortcuts and idioms, which allow the user to express quite complicated operations succinctly. Many of these become natural once one is familiar with the underlying concepts. In some cases, there are multiple ways of performing a task, but some of the techniques will rely on the language implementation, and others work at a higher level of abstraction. In such cases we shall indicate the preferred usage.
Some familiarity with R is assumed. This is not an introduction to R but rather a programmers’ reference manual. Other manuals provide complementary information: in particular Preface in An Introduction to R provides an introduction to R and System and foreign language interfaces in Writing R Extensions details how to extend R using compiled code.
Next: Evaluation of expressions, Previous: Introduction, Up: Top [Contents][Index]
In every computer language variables provide a means of accessing the data stored in memory. R does not provide direct access to the computer’s memory but rather provides a number of specialized data structures we will refer to as objects. These objects are referred to through symbols or variables. In R, however, the symbols are themselves objects and can be manipulated in the same way as any other object. This is different from many other languages and has wide ranging effects.
In this chapter we provide preliminary descriptions of the various data
structures provided in R. More detailed discussions of many of them
will be found in the subsequent chapters. The R specific function
typeof
returns the type of an R object. Note that in the C code
underlying R, all objects are pointers to a structure with typedef
SEXPREC; the different R data types are represented in C by
SEXPTYPE, which determines how the information in the various
parts of the structure is used.
The following table describes the possible values returned by
typeof and what they are.
Users cannot easily get hold of objects of types marked with a ‘***’.
Function mode gives information about the mode of an object
in the sense of Becker, Chambers & Wilks (1988), and is more compatible
with other implementations of the S language.
Finally, the function storage.mode returns the storage mode
of its argument in the sense of Becker et al. (1988). It is generally
used when calling functions written in another language, such as C or
FORTRAN, to ensure that R objects have the data type expected by the
routine being called. (In the S language, vectors with integer or
real values are both of mode "numeric", so their storage modes
need to be distinguished.)
> x <- 1:3 > typeof(x) [1] "integer" > mode(x) [1] "numeric" > storage.mode(x) [1] "integer"
R objects are often coerced to different types during computations. There are also many functions available to perform explicit coercion. When programming in the R language the type of an object generally doesn’t affect the computations, however, when dealing with foreign languages or the operating system it is often necessary to ensure that an object is of the correct type.
| • Basic types: | ||
| • Attributes: | ||
| • Special compound objects: |
Next: Attributes, Previous: Objects, Up: Objects [Contents][Index]
Next: List objects, Previous: Basic types, Up: Basic types [Contents][Index]
Vectors can be thought of as contiguous cells containing data. Cells
are accessed through
indexing operations such as
x[5]. More details are given in Indexing.
R has six basic (‘atomic’) vector types: logical, integer, real, complex, string (or character) and raw. The modes and storage modes for the different vector types are listed in the following table.
typeof mode storage.mode logicallogicallogicalintegernumericintegerdoublenumericdoublecomplexcomplexcomplexcharactercharactercharacterrawrawraw
Single numbers, such as 4.2, and strings, such as "four
point two" are still vectors, of length 1; there are no more basic
types. Vectors with length zero are possible (and useful).
String vectors have mode and storage mode "character". A single
element of a character vector is often referred to as a character
string.
Next: Language objects, Previous: Vector objects, Up: Basic types [Contents][Index]
Lists (“generic vectors”) are another kind of data storage. Lists have elements, each of which can contain any type of R object, i.e. the elements of a list do not have to be of the same type. List elements are accessed through three different indexing operations. These are explained in detail in Indexing.
Lists are vectors, and the basic vector types are referred to as atomic vectors where it is necessary to exclude lists.
Next: Expression objects, Previous: List objects, Up: Basic types [Contents][Index]
There are three types of objects that constitute the R language.
They are calls, expressions, and names.
Since R has objects of type "expression" we will try to avoid
the use of the word expression in other contexts. In particular
syntactically correct expressions will be referred to as
statements.
These objects have modes "call", "expression", and
"name", respectively.
They can be created directly from expressions using the quote
mechanism and converted to and from lists by the as.list and
as.call functions.
Components of the
parse tree can be extracted using the standard
indexing operations.
| • Symbol objects: |
Previous: Language objects, Up: Language objects [Contents][Index]
Symbols refer to R
objects. The
name of any R object is usually a
symbol. Symbols can be created through the functions as.name and
quote.
Symbols have mode "name", storage mode "symbol", and type
"symbol". They can be
coerced to and from character strings
using as.character and as.name.
They naturally appear as atoms of parsed expressions, try e.g.
as.list(quote(x + y)).
Next: Function objects, Previous: Language objects, Up: Basic types [Contents][Index]
In R one can have objects of type "expression". An
expression contains one or more statements. A statement is a
syntactically correct collection of
tokens.
Expression objects are special language objects which contain parsed but
unevaluated R statements. The main difference is that an expression
object can contain several such expressions. Another more subtle
difference is that objects of type "expression" are only
evaluated when
explicitly passed to eval, whereas other language objects may get
evaluated in some unexpected cases.
An expression object behaves much like a list and its components should be accessed in the same way as the components of a list.
Next: NULL object, Previous: Expression objects, Up: Basic types [Contents][Index]
In R functions are objects and can be manipulated in much the same way as any other object. Functions (or more precisely, function closures) have three basic components: a formal argument list, a body and an environment. The argument list is a comma-separated list of arguments. An argument can be a symbol, or a ‘symbol = default’ construct, or the special argument ‘...’. The second form of argument is used to specify a default value for an argument. This value will be used if the function is called without any value specified for that argument. The ‘...’ argument is special and can contain any number of arguments. It is generally used if the number of arguments is unknown or in cases where the arguments will be passed on to another function.
The body i