Supported Structures

'squarebrackets' only supports the most common S3 objects, and only those that primarily use square brackets for sub-set operations (hence the name of the package).

One can generally divide the structures supported by 'squarebrackets' along 3 key properties:

• atomic vs recursive:
  Types logical, integer, double, complex, character, and raw are atomic.
  Lists and data.frames are recursive.

• dimensionality:
  Whether an object is a vector, array, or data.frame.
  Note that a matrix is simply an array with 2 dimensions.

• mutability:
  Base R's S3 classes (except Environments) are generally immutable:
  Modifying the object will create a copy (called 'copy-on-modify').
  'squarebrackets also supports data.tables and mutable_atomic objects, which are mutable:
  If desired, one can modify them without copy using pass-by-reference semantics.
  
  

Supported Structures

'squarebrackets' supports the following immutable structures:

• basic atomic classes
  (atomic vectors and arrays).

• factor.
  

• basic list classes
  (recursive vectors and arrays).
  

• data.frame
  (including the classes tibble, sf-data.frame and sf-tibble).
  
  

'squarebrackets' supports the following mutable structures:

• mutable_atomic
  (mutable_atomic vectors arrays);

• data.table
  (including the classes tidytable, sf-data.table, and sf-tidytable).
  
  

Details

Atomic vs Recursive
The sb_ methods provided by 'squarebrackets' work on atomic (see is.atomic) objects.
The sb2_ methods provided by 'squarebrackets' work on recursive (see is.recursive) objects.
See squarebrackets_method_dispatch for more details on the method dispatch used by 'squarebrackets'.

Dimensionality
'squarebrackets' supports dimensionless or vector objects (i.e. ndim == 0L).
squarebrackets' supports arrays (see is.array and is.matrix); note that a matrix is simply an array with 2 dimensions.
'squarebrackets' also supports data.frame-like objects (see is.data.frame).
Specifically, squarebrackets' supports a wide variety of data.frame classes:
data.frame, data.table, tibble, tidytable;
'squarebrackets' also supports their 'sf'-package compatible counter-parts:
sf-data.frame, sf-data.table, sf-tibble, sf-tidytable.

Dimensionless vectors and dimensional arrays are supported in both their atomic and recursive forms.
Data.frame-like objects, in contrast, only exist in the recursive form (and, as stated, are supported by 'squarebrackets').
Recursive vectors, recursive matrices, and recursive arrays, are collectively referred to as "lists" in the 'squarebrackets' documentation.

Note that the dimensionality of data.frame-like objects is not the same as the dimensionality of (recursive) arrays/matrices.
For example:
For any array/matrix x, it holds that length(x) == prod(dim(x)).
But for any data.frame x, it is the case that length(x) == ncol(x).

Mutable vs Immutable
Most of base R's S3 classes (except Environments) are generally immutable:
Modifying the object will create a copy (called 'copy-on-modify').
They have no explicit pass-by-reference semantics.
Most S3 objects in base 'R' are immutable:
Environments do have pass-by-reference semantics, but they are not supported by 'squarebrackets'.

Supported mutable structures:

• 'squarebrackets' supports the mutable data.table class
  (and thus also tidytable, which inherits from data.table).

• 'squarebrackets' also includes a new class of mutable objects:
  mutable_atomic objects.
  mutable_atomic objects are the same as atomic objects, except they are mutable (hence the name).
  
  

Supported immutable structures:
Atomic and recursive vectors/matrices/arrays, data.frames, and tibbles.

All the functions in the 'squarebrackets' package with the word "set" in their name perform pass-by-reference modification, and thus only work on mutable structures.
All other functions work the same way for both mutable and immutable structures.

Derived Atomic Vector
A special class of objects are the Derived Atomic Vector structures:
structures that are derived from atomic objects, but behave differently.
For example:
Factors, datetime, POSIXct and so on are derived from atomic vectors.
But they have attributes and special methods that make them behave differently.

'squarebrackets' treats derived atomic classes as regular atomic vectors.
There are highly specialized packages to handle objects derived from atomic objects.
For example, the 'anytime' package to handle date-time objects.

'squarebrackets does provide some more explicit support for factors.

Not Supported S3 structures
Key-Values storage S3 structures, such as environments, are not supported by 'squarebrackets'.