

list {base}                                  R Documentation

_L_i_s_t_s _-_- _G_e_n_e_r_i_c _a_n_d _D_o_t_t_e_d _P_a_i_r_s

_D_e_s_c_r_i_p_t_i_o_n_:

     Functions to construct, coerce and check for all kinds
     of R lists.

_U_s_a_g_e_:

     list(...)
     pairlist(...)

     as.list(x)
     as.list.default(x)
     as.pairlist(x)

     is.list(x)
     is.pairlist(x)

     alist(...)

_D_e_t_a_i_l_s_:

     Since version 0.63, most lists in R internally are
     Generic Vectors, whereas traditional dotted pair lists
     (as in LISP) are still available.

     The arguments to `list' or `pairlist' are of the form
     `value' or `tag=value'.  The functions return a list
     composed of its arguments with each value either tagged
     or untagged, depending on how the argument was speci-
     fied.

     `alist' is like `list', except in the handling of
     tagged arguments with no value. These are handled as if
     they described function arguments with no default (cf.
     `formals'), whereas `list' simply ignores them.

     `as.list' attempts to coerce its argument to list type.
     For functions, this returns the concatenation of the
     list of formals arguments and the function body. For
     expressions, the list of constituent calls is returned.

     `is.list' returns `TRUE' iff its argument is a `list'
     or a `pairlist' of `length'> 0, whereas `is.pairlist'
     only returns `TRUE' in the latter case.

     An empty pairlist, `pairlist()' is the same as `NULL'.
     This is different from `list()'.

_S_e_e _A_l_s_o_:

     `vector(., mode="list")', `c', for concatenation; `for-
     mals'.

_E_x_a_m_p_l_e_s_:

     data(cars)
     # create a plotting structure
     pts <- list(x=cars[,1], y=cars[,2])
     plot(pts)

     # Argument lists
     f <- function()x
     # Note the specification of a "..." argument:
     formals(f) <- al <- alist(x=, y=2, ...=)
     f
     str(al)

     str(pl <- as.pairlist(ps.options()))

     ## These are all TRUE:
     is.list(pl) && is.pairlist(pl)
     !is.null(list())
     is.null(pairlist())
     !is.list(NULL)
     is.pairlist(pairlist())
     is.null(as.pairlist(list()))
     is.null(as.pairlist(NULL))

