# ToRForm

## DetailsDetails

- Null is interpreted as an R NULL element and transformed to RNull[].
- Scalars of basic vector types (integers, reals, complex numbers, strings, and True|False) are interpreted as one-element R vectors of the same types. This reflects the way they are treated in R.
- Lists (or multidimensional arrays) of basic vector types (integers, reals, complex numbers, strings, and True|False) are interpreted as R vectors and transformed into expressions with an RVector head.
- All lists representing R vectors (including multidimensional arrays) can contain missing elements, which must be represented by Missing[].
- Lists not matching the above description will automatically be interpreted as R lists and converted to expressions with the head RList. That would include ragged lists and lists of elements of different types. Valid (for the purposes of
*RLink*) R lists can contain other valid R lists, valid R vectors, or an R NULL element. - Expressions with the heads REnvironment, RCode, or RFunction are left unchanged under the action of ToRForm, with the exception of the conversion of function attributes that expressions with the head RFunction may contain.
- Whenever you need to send to R an object with nontrivial attributes, you will need to use the container RObject, which allows you to store both your data and the attributes, and RAttributes, for attributes specifically.
- All Wolfram Language expressions that do not fall into one of the above categories cannot be currently sent to R and passing those to ToRForm will result in $Failed being returned.
- ToRForm is called internally by RSet to convert your input into internal
*RLink*representation before sending it to R. Most of the time, you will not need to call this function explicitly. It is, however, useful to determine*RLink*'s internal form of your input, in particular to test whether or not*RLink*interpreted your input as you intended.

## ExamplesExamplesopen allclose all

### Basic Examples (6)Basic Examples (6)

In[1]:= |

Here are some sample conversions for basic vector types:

NULL is transformed to RNull:

Here is an internal form of a list of integers:

A list of logical values (True or False):

However, lists of elements of different types will be interpreted as an R list. For example:

The previous example illustrates that the full internal *RLink* form is often rather inconvenient to work with.

Here is an internal form of an integer matrix:

You can notice three things here: first, matrix data is stored in a one-dimensional list. Second, the matrix is converted to a column-major order, since this corresponds to how it is stored in R. Finally, matrix dimensions are stored in the "dim" attribute.

Ragged (irregular) lists will be interpreted as R lists:

The same is true for lists containing elements of different types:

When you have to give your R object some extra attributes, you must wrap what you would normally construct in an RObject head and add attributes wrapped in an RAttributes head:

To perform the reverse operation and obtain a short form from the full internal form for a given expression representing some R object, you can use FromRForm:

The list, which is the value of the "myAtt" attribute for this object, was returned in a slightly different form. This is consistent with scalars being treated by R as one-element vectors, but can become a problem if you always rely on automatic type identification:

This problem and the recommended solution are discussed in more detail in the documentation page for RList.

Regardless of the way ToRForm interprets things, the cycle ToRForm to FromRForm should always return the same expression, except "dressing" scalars in extra lists.