R object catalogue

A list of equal-length columns presented as a table. Almost everything rectangular in R inherits from it, which is why the class column so often has more than one entry.

Built asNamed runs, side by side

A data.frame with a key. The key is a sort order held with the table, and it is what makes joins and lookups fast, so it survives being saved and describes the file rather than a session. Loaded from an rda its internal self-reference is stale, so the first assignment by reference warns unless the package calls setalloccol() when it loads.

Built asNamed runs, side by side

A tibble carrying a grouping, so later operations run once per group. The grouping survives being saved, which means it describes the file rather than a session.

Built asNamed runs, side by side

The container everything else is built on. What matters about a stored list is usually what is inside it, since a list of three elements can hold thousands of rows.

Built asA list that need not line up

Not readeach element's own length is not recorded separately, only the range across all of them

A tibble. It is a data.frame with different defaults. It never converts strings to factors, never adds row names, and prints a few rows rather than all of them. A column of it can itself hold a list, which is how nested tables are stored.

Built asNamed runs, side by side

A tibble marked so that later operations run one row at a time. It uses the grouping machinery with no grouping variables, which is why its group count matches its row count.

Built asNamed runs, side by side

Not readthe rowwise state is not detected, so it reports as an ordinary tibble whose group count happens to equal its row count

Bioconductor's DataFrame, which unlike a data.frame can hold S4 columns such as run-length encodings or genomic ranges. That flexibility is why its columns sit in a listData slot rather than where a data.frame's do.

Built asSlots the reader does not open

Not readthe column list is in a slot the frame reader does not reach, so there are no column names, types or profiles

The newest of R's object systems, meant to succeed both S3 and S4. An instance is stored under its own class name rather than under S7_object, and its properties are ordinary attributes, so they are listed by name with their values unread.

Stored asthe user's own class name, stored with an S7 prefix

Built asSlots the reader does not open

Not readthe class definition travels inside the saved object and is matched on but never opened, so the declared property names and types are dropped; property values are listed by name only, so an S7 object holding a table records neither its shape nor its fingerprint

A data.frame with a second frame describing what its columns mean, used for the sample and feature annotation of an ExpressionSet.

Superseded byS4Vectors::DFrame

Built asSlots the reader does not open

A set of biological sequences held in a compact shared buffer rather than as R character vectors, which is what makes whole-genome work fit in memory.

Built asA recipe instead of the cells

The container Bioconductor used for assay data before SummarizedExperiment, and still common in older data packages. Its assayData is an environment rather than a slot holding a matrix. The matrix is in the file and loads intact. This reader does not descend into environments, so nothing about its shape is recovered. Unreached rather than absent.

Superseded bySummarizedExperiment::SummarizedExperiment

Built asSlots the reader does not open

Integer intervals, given as a start and a width. The base class underneath GRanges and most of Bioconductor's range arithmetic.

Built asA recipe instead of the cells

A run-length encoding: values and how many times each repeats. Genomic coverage is mostly long runs of the same number, so this is often orders of magnitude smaller than the vector it stands for.

Built asA recipe instead of the cells

Not a class a package author writes, but what R stores when a vector can be described instead of listed. A compact sequence keeps a start, a length and a step. A deferred string keeps the vector it will be converted from, and a wrapper keeps the thing it wraps plus what is known about it. All travel the same way and all expand on being changed.

Stored asan integer vector

Built asA recipe instead of the cells

A calendar day, stored as the number of days since 1970. Arithmetic on it is arithmetic on that number, which is why subtracting two of them gives a difftime measured in days.

Built asThe same run, read differently

An elapsed time with its unit attached. The unit is chosen when the difference is taken, so the same interval can arrive as days here and as hours in the next column.

Built asThe same run, read differently

A length of time in seconds exactly, with no calendar in it. The counterpart to Period, and the difference between them is the whole of why both exist.

Built asThe same run, read differently

A vector of codes with a level for each. The codes are what is stored. The levels give them meaning and fix the order they sort and plot in. Profiled by the same reader that profiles a factor column, so a factor stored on its own carries everything one inside a table does.

Built asThe same run, read differently

A time of day, stored as seconds since midnight with a units attribute. It is a difftime underneath, which is why it prints as a duration.

Built asThe same run, read differently

A Date stored as an integer rather than a double. Same meaning, half the memory, and it sorts and subtracts identically, which is why data.table uses it by default when reading dates.

Built asThe same run, read differently

A factor whose levels are ranked, so a comparison between two of them means something. The ranking is the declared order of the levels, which is stored separately from the counts.

Built asThe same run, read differently

An instant, stored as seconds since 1970 with a time zone attached. The zone is not decoration. The same number prints as two different local times without it.

Built asThe same run, read differently

A numeric vector that knows what it measures. Arithmetic on it converts and checks units, so adding metres to seconds is an error rather than a number.

Built asThe same run, read differently

A bare atomic vector with no class attribute: numeric, integer, character, logical, complex or raw. It profiles through the same reader as a column of a table, so a character vector reports its distinct count and its shortest and longest strings, and a logical its true, false and missing counts. The type is reported rather than the class, because there is no class to report.

Built asA run of cells

A vector of binary blobs, one raw vector per element. What a database driver returns for a BLOB column, and what R has no other natural type for.

Built asA list that need not line up

Not readeach element is a raw vector whose bytes are not kept, so there is a length and no content

A vector of codes with labels attached, which is how SPSS, Stata and SAS represent a categorical. R would use a factor. This keeps the original codes so a round trip is possible.

Built asThe same run, read differently

Not readthe value labels are not read, so a column of codes has no key to what the codes mean

A 64 bit integer, which base R does not have. The bits are carried in a double, so anything reading it without bit64 sees meaningless floating point numbers.

Built asThe same run, read differently

Not readstored as doubles with a class attribute, so the values are summarised as the doubles they are bit for bit rather than as the integers they represent

A span with a start and an end rather than only a length, so it knows which stretch of time it covers.

Built asThe same run, read differently

Not readthe start instant is an attribute and is not read, so an interval reports a span with no position in time

A time of day as seconds since midnight, held as an integer. The companion to IDate.

Built asThe same run, read differently

Not readread as the integer count of seconds it is stored as, so a time of day prints as a number

A length of time in calendar units, where a month is a month whatever its length. Adding one to a date lands on the same day of the next month rather than a fixed number of seconds later.

Built asParallel runs under one name

Not readthe month, day and year components are separate attributes and are not combined, so the period is not rendered

A timestamp broken into its parts as a list of parallel vectors, named the way R names them: sec, min, hour, mday, mon, year and so on. POSIXct is the same instant as one number, and is what almost everything stores.

Built asParallel runs under one name

Not readread as the eleven-element list it is stored as, so its length reports the fields rather than the timestamps

A survival outcome, carried as one column of a data frame and physically a matrix of times and status codes. Without its type attribute the numbers are just numbers, and the censoring is what gives them meaning.

Built asA run with a dim

Not readthe type attribute saying whether the times are right censored, interval censored or a counting process is not read; a multi-state object's states attribute is likewise unread

A vector whose elements have several parts, stored as parallel fields under one class. clock's calendar types and ivs's intervals are built on it, and read without vctrs it looks like a short list.

Built asParallel runs under one name

Not reada record vector is a list of parallel fields and reads as that list, so its length is the number of fields rather than the number of records

A matrix of more than two dimensions. R treats a matrix as the two-dimensional case of the same thing, and the values are summarised the same way, flattened to one vector, which is what summary() on an array does too.

Built asA run with a dim

Not readnrow and ncol are left unset beyond two dimensions, so the browse table shows a dash where the dim vector has the answer

A diagonal matrix. Only the diagonal is stored, so an n by n identity costs n numbers rather than n squared.

Built asA recipe instead of the cells

A general sparse matrix in compressed column form, which is the format most of R's sparse linear algebra expects. What reaches the disk is the recipe rather than the cells: the row indices i, the column pointers p, the values x and a Dim. Only the stored entries are kept, so a summary of its values is a summary of those and not of every cell.

Built asA recipe instead of the cells

A dense matrix carried by Matrix rather than by base R, so it can meet a sparse one in the same arithmetic without either being converted first.

Built asA run with a dim

A general sparse matrix compressed by row rather than by column. Less common than the column form, which is what most of R's sparse solvers expect.

Built asA recipe instead of the cells

A general sparse matrix in triplet form: row, column and value kept as three parallel vectors. Easy to build one entry at a time and converted to compressed form for arithmetic.

Built asA recipe instead of the cells

A symmetric sparse matrix. Only one triangle is stored, with the other half implied by the symmetry, which is why it holds fewer entries than it has non-zero cells.

Built asA recipe instead of the cells

A triangular sparse matrix. Half the matrix is known to be zero from the shape, so it is not stored, and a solver can skip the back substitution it would otherwise do.

Built asA recipe instead of the cells

A sparse matrix of logicals. Used for adjacency and incidence, where the question is whether a cell is set rather than by how much.

Built asA recipe instead of the cells

One vector with a dim attribute. Everything in it shares a type, which is the difference between a matrix and a data.frame that happens to be all numeric.

Built asA run with a dim

Not readsummarised across every cell as one vector, so there are no per-row or per-column figures

A contingency table: counts in an array whose dimnames carry both the categories and the variables they came from. The variable names are what make it readable as a cross-tabulation rather than as a bare matrix.

Built asA run with a dim

Not readsummarised across every cell, so no per-margin totals

A distance matrix stored as its own lower triangle in one vector. Everything that takes one, from hclust to cmdscale, reads that layout directly.

Built asA recipe instead of the cells

Not readread as the flat vector it is stored as, so the number of objects it compares is not recovered from its Size attribute

A contingency table flattened for printing, with several classifying variables laid along the rows and the rest along the columns.

Built asA run with a dim

Not readthe row and column variable assignment that distinguishes a flat table from the array it came from is not read

A pattern matrix: which cells are non-zero, with no values at all. The sparsity pattern is the data, which is what a graph or a design structure often needs.

Built asA recipe instead of the cells

Not readthere are no values to summarise, so the profile carries a density and no distribution

An index matrix: each row has exactly one entry set. A one-hot encoding is one of these, and like a permutation it is stored as the indices rather than as cells.

Built asA recipe instead of the cells

Not readthe index vector is the object and is not read; there are no values to summarise, by construction

A permutation matrix, stored as the permutation itself rather than as cells. Multiplying by one reorders rows or columns, which is why it needs no values at all.

Built asA recipe instead of the cells

Not readthe permutation vector is the object and is not read, so nothing says what the reordering is; there are no values to summarise, by construction

A sparse vector rather than a sparse matrix. It stores positions and values with no dim slot, so none of the matrix readers apply to it and it comes back as a class name.

Built asA recipe instead of the cells

Several regular series over one index, stored as a matrix with a column per series. Everything true of ts is true of it, including that it cannot represent a gap.

Built asA run with an index

Base R's regular time series: a vector plus a tsp attribute holding a start, an end and a frequency, with every observation assumed evenly spaced. It cannot represent a gap, which is what zoo and xts were written for.

Built asA run with an index

A zoo series whose index is always a date or a time, which is why it carries a time zone. It is a matrix underneath, so it can hold several series over one index.

Built asA run with an index

A series in index order, with the index stored explicitly, so the observations can be irregular and the index can be any type that sorts rather than only a number.

Built asA run with an index

A zoo series that also declares a frequency, so it can say it is regular rather than leaving a reader to infer it from the spacing.

Built asA run with an index

A tibble that names one column as its time index and others as the keys identifying each series. Those declarations are the whole difference from a plain tibble, and they are what is not read.

Built asNamed runs, side by side

Not readthe index and key attributes that make it a tsibble are not read, so which column is time and which identify a series are unknown; its ordered attribute is picked up by the data.table index reader and reported as an index name

The series class from the Rmetrics family, matrix-backed with its timestamps in a slot rather than in an index attribute.

Built asA run with an index

Not readthe positions slot carrying the timestamps is not read, so the series has no span and no index class

A calendar month as a single number, the year plus the month as a twelfth. It sorts and subtracts like a number because that is what it is.

Built asThe same run, read differently

Not readstored as a fractional year and read as a number, so the range prints as 2020.0 rather than as Jan 2020

A calendar quarter as a single number, the year plus the quarter as a fourth. The sibling of yearmon.

Built asThe same run, read differently

Not readstored as a fractional year and read as a number, so the range prints as 2020.0 rather than as 2020 Q1

A data.frame with a geometry column. Every other column is ordinary data about the feature in the same row, which is why the attribute columns profile exactly as a plain table's do.

Built asA table with the shapes beside it

Not readthe coordinates themselves are not summarised

The geometry column of an sf table. Each element is one feature's shape, and the column as a whole carries the coordinate reference system and the bounding box. This is where R's vector spatial work has been since sf replaced sp.

Built asA table with the shapes beside it

Not readthe coordinates themselves are not summarised, so there is no vertex count and no measure of geometry complexity

Lines with a table of attributes, from sp. The geometry sits in a slot of nested lists, one per feature, which is why the shape reported is the attribute table's rather than the geometry's.

Superseded bysf

Built asA table with the shapes beside it

Not readthe lines slot is not walked, so there is no vertex or part count

Points with a table of attributes, from the package that carried R's vector GIS before sf. The projection libraries it depended on have since been retired.

Superseded bysf

Built asA table with the shapes beside it

Not readthe coordinates are in a slot the reader does not open, so there is no point count independent of the attribute table

The S4 spatial classes that carried R's vector GIS work before sf. The attribute table sits in a data slot and the shapes in a polygons slot beside it, rather than in one column of one table. Reading one today needs sp installed, and the packages it depended on for projections and geometry operations have been retired.

Superseded bysf

Built asA table with the shapes beside it

Not readthe geometry slot is not walked, so there is no feature count and no geometry type

Polygons with no attribute table, which is the geometry half of a SpatialPolygonsDataFrame. With no table there is no shape to report, so it comes back as an extent and nothing else.

Superseded bysf

Built asA table with the shapes beside it

Not readno feature count and no vertex count, because the polygons slot is not walked

terra's vector counterpart to SpatRaster, and the modern replacement for sp's Spatial classes. Like a SpatRaster it holds a pointer and has to go through terra::wrap() before it can be saved.

Stored asPackedSpatVector wrapped before saving

Built asA table with the shapes beside it

Not readthe packed form falls through to the assay-matrix reader, which reports the coordinate matrix as the object's shape and tags it s4-assay-dims; no geometry type, no feature count, no CRS and no extent

A multi-layer grid from the raster package. raster was the standard for gridded work in R for over a decade, and its author's successor package terra now does the same job faster and with a simpler set of classes.

Superseded byterra::SpatRaster

Built asA grid with a coordinate system

A single-layer grid from the raster package. A RasterBrick or RasterStack is the same thing carrying several layers over one geometry.

Superseded byterra::SpatRaster

Built asA grid with a coordinate system

Several grids treated as one object. Unlike a brick it keeps a separate raster per layer rather than one block of values, which is why a brick is read in full and a stack is not.

Superseded byterra::SpatRaster

Built asA grid with a coordinate system

Not readthe layers slot holds a raster object per layer and is not walked, so there are no layer names, no per-layer ranges and no values at all; a stack can reference layers held in separate files, and those are not followed

A regular grid with a value table, from sp. The rows are cells rather than features, which is why its shape reads as a long thin table rather than as the grid it is.

Superseded byterra::SpatRaster

Built asA grid with a coordinate system

Not readthe grid topology slot holding the cell size and the origin is not read, so there is no resolution; the cell values are read as an attribute table rather than as a grid

A grid stored as the cells that have values rather than as a full rectangle, which is what makes it different from a SpatialGridDataFrame and much smaller for a sparse coverage.

Superseded byterra::SpatRaster

Built asA grid with a coordinate system

Not readthe grid topology carrying the cell size and the origin is not read, so there is no resolution; nothing in the profile distinguishes it from a full grid

The current way to hold gridded data in R, and the successor to the raster package's classes. A SpatRaster holds a pointer into terra's C++ side, so it cannot be saved directly. terra::wrap() turns it into a PackedSpatRaster first, and that is what a package actually bundles.

Stored asPackedSpatRaster wrapped before saving

Built asA grid with a coordinate system

Not readthe cell values are not read, so there is no distribution; resolution and extent are not recovered from the packed form; per-layer ranges are not available

A graph: vertices, edges, and attributes on either. Stored as a plain list with a fixed layout, which is why the counts are readable without igraph installed. That layout changed in igraph 2.0, so a graph saved before it needs upgrade_graph() and a reader that assumes the current layout is reading the wrong slots on an old one.

Built asA list that need not line up

Not readthe graph, vertex and edge attribute lists are not read, so a weighted or named graph reports neither weights nor names

An analysis of variance fit. It is an lm underneath with the terms arranged for the ANOVA table, which is why the class chain says aov and then lm.

Built asA list that need not line up

Not readthe ANOVA table itself is computed on demand rather than stored, so nothing here is that table

A fitted proportional hazards model, carrying coefficients, their variance, and the survival object it was fitted to.

Built asA list that need not line up

Not readthe formula and the baseline hazard are not read

A generalised additive model: a glm whose terms can be smooths fitted from the data rather than fixed shapes. It inherits from glm and lm, so its class chain is three deep and its slot list is the longest of any model here.

Built asA list that need not line up

Not readthe smooth terms are a list of basis objects that are listed rather than opened, so neither the number of smooths nor their bases is read; the formula is a language object and is not rendered

A fitted generalised linear model. Everything an lm carries, plus the family and the link, which sit in a slot the reader lists by name without opening.

Built asA list that need not line up

Not readthe family and link are not read, so a logistic and a Poisson fit look the same here; the formula is not rendered

A regularisation path: one fit per penalty value rather than one fit. That is why it holds a matrix of coefficients rather than a vector, and why a bundled example of one is larger than an lm.

Built asA list that need not line up

Not readthe coefficient matrix is sparse and is listed rather than summarised, so neither the path length nor the number of non-zero coefficients is read

A hierarchical clustering: the merge order, the heights the merges happened at, and the leaf order for drawing. Not a tree structure but the instructions for building one.

Built asA list that need not line up

Not readthe leaf count and the tree height are inside the merge and height vectors and are not read

The result of a hypothesis test: statistic, p value, confidence interval, and the names of what was compared. Every test in stats returns this one shape, which is why the class is so common.

Built asA list that need not line up

Not readthe values sit in a list and are listed by slot rather than read, so neither the statistic nor the p value is extracted

A fitted linear model. It is a plain list, so its slot names are readable without stats loaded: coefficients, residuals, fitted values, the terms object and, when the fit kept it, the model frame the data came from.

Built asA list that need not line up

Not readthe formula is a language object and is not rendered, so the model is not identified; no response class, and no coefficient count separate from the slot lengths

A fitted linear mixed model from nlme, the older of R's two mixed model packages and the one that is a plain list rather than S4, which is why more of it is readable.

Built asA list that need not line up

Not readthe random effects structure and the grouping factors are in slots that are listed rather than read

A nonlinear least squares fit. Small, because it stores the model function and the converged parameters rather than a design matrix.

Built asA list that need not line up

Not readthe model function is a closure and is not read; no convergence information is extracted

A principal components fit: the rotation matrix, the standard deviations, and optionally the rotated data. Small and self-contained, which is why it is a common thing to bundle.

Built asA list that need not line up

Not readthe component count and the variance explained are not derived from the slots

A fitted forest. It keeps per-tree structure and the out-of-bag error trace, which is why the object is large relative to the data it was fitted to.

Built asA list that need not line up

Not readthe tree count, the mtry setting and the out-of-bag error sit in slots that are listed rather than read

A fitted classification or regression tree. Its frame slot is a data.frame with one row per node, which is why a tree reports rows nested inside it.

Built asA list that need not line up

Not readthe node table is reached as an anonymous nested frame, so neither the depth nor the leaf count is derived from it

An estimated survival curve: times, numbers at risk, numbers of events, and the step function itself. What a Kaplan-Meier plot is drawn from.

Built asA list that need not line up

Not readthe curve is a set of parallel vectors that are listed rather than summarised, so neither the follow-up time nor the event count is extracted

The same clustering as a nested list, one element per branch, with attributes carrying the height and the labels. Deeply recursive, which is the one thing about it that is measured.

Built asA list that need not line up

Not readthe branch attributes carrying heights and labels are not read at any level; no leaf count

Parallel MCMC chains, each a matrix of draws by parameter. What every Bayesian sampler in R is converted to before it is diagnosed.

Built asA list that need not line up

Not readthe chains are matrices inside a list and are not descended into, so neither the draw count nor the parameter names is read

A fitted mixed model. Unlike the other model classes it is S4 rather than a list, so it falls to the S4 path and a matrix found in one of its slots is reported as the object's shape.

Built asSlots the reader does not open

Not readthe shape comes from the first matrix found in a slot rather than from the model; no fixed effects, no random effect structure and no observation count

A matrix held outside R's memory so it can outgrow it. The object is a pointer to that memory, so what a package bundles is the descriptor and the backing file, attached with attach.big.matrix().

Stored asa big.matrix.descriptor plus a backing file wrapped before saving

Built asNothing the reader opens

A binding from names to values. R writes a user environment with everything in it, so the contents do travel. What is written by reference instead is the global environment and any package or namespace environment, which come back attached to whatever the loading session has. Nothing here descends into one, so an object that keeps its data in an environment reports a class name and no shape, and that is this reader rather than the format.

Built asNothing the reader opens

A frame whose columns live in files on disk, paged in as needed. It saves and loads without error and works until the files move, which makes it the path-reference failure rather than the pointer one.

Stored asan ff file on disk plus its metadata wrapped before saving

Built asNothing the reader opens

A closure: its arguments, its body, and the environment it was defined in. It saves and loads, but the environment it carries can pull an entire session's worth of objects into the file with it.

Built asNothing the reader opens