Type-safety of the R language

Question

Wikipedia states that R is "multi-paradigm: array, object-oriented, imperative, functional, procedural, reflective and also dynamic. But what about its type safety? Please explain the different aspects/kinds of possible type safety in R with examples, e.g.

• Do we get unchecked run-time type errors?
• Are operations or function calls which attempt to disregard data types rejected?
• Is there a well-defined error or exceptional behavior (as opposed to an undefined behavior) as soon as a type-matching failure happens?
• Are data objects fixed and invariable typed?
• Can the type system be evaded?
• Does it have a complex, fine-grained type system with compound types and does each each object have a well-defined type that will prohibit illegal values and operations?
• Support for implicit type conversion (this has been shown by some answers already, thank you).

These questions are derived from Wikipedia (http://en.wikipedia.org/wiki/Strong_typing) as strong/weakly typed is too fuzzy to ask for (thanks delnan for clarifications here).

Answer 1

> a = TRUE
> a
[1] TRUE
> a[3] = 1
> a
[1]  1 NA  1
> a[5] = 3.14
> a
[1] 1.00   NA 1.00   NA 3.14
> a = "Ala"
> a
[1] "Ala"

You can see it's dynamic - I can assign anything to variable a and change it at will. It's also weakly typed performing implicit conversions liberally - see how I can add ints and then floats to what was originally boolean "vector". You can usually treat booleans as is they were numbers and numbers as if they were strings.

Answer 2

Implicit coercion by operators and functions is widespread in the language (and it has argument recycling). Warnings are issued most of the time for the recycling but not for coercion.

 a <- c(TRUE, FALSE)
     b <- c(-4:4)
 a < b
#[1] FALSE FALSE FALSE FALSE FALSE  TRUE  TRUE  TRUE  TRUE
#Warning message:
#In a < b : longer object length is not a multiple of shorter object length

  c(a,b)
# [1]  1  0 -4 -3 -2 -1  0  1  2  3  4

 a + b
[1] -3 -3 -1 -1  1  1  3  3  5
# Standard Warning message re: multiple of shorter object length

> data.frame( a =a, b=b)
Error in data.frame(a = a, b = b) : 
  arguments imply differing number of rows: 2, 9

But if arguments to data.frame have lengths that are an even multiple of the vector with the longest lenght, they get recycled without warning:

> data.frame( a =c(TRUE,FALSE,TRUE), b=b)
      a  b
1  TRUE -4
2 FALSE -3
3  TRUE -2
4  TRUE -1
5 FALSE  0
6  TRUE  1
7  TRUE  2
8 FALSE  3
9  TRUE  4

Functions are made polymorphic via two class systems, one of which depends on the period character signalling the target class, the other of which depends on object class signatures. (And the function naming conventions are very erratic.)

I disagree with the premise of R as an object-oriented language. People with object-oriented experience that come to R expect a different behavior than it exhibits. It is a functional language that is dispatched with class systems that examine the objects given but it's not like a real object-oriented language.

Answer 3

There's an excellent survey that answers your question with examples: Evaluating the Design of the R Language by F.Morandat et al.

A citation from abstract:

R is a dynamic language for statistical computing that combines lazy functional features and object-oriented programming"

Each of these key words "dynamic", "lazy" etc is provided with the examples in this paper (look at the chapter "3. The Three Faces of R").

The authors went through the following points:
– Semantics of Core R
– They built a corpus of R programs and evaluated them.
– Implementation Evaluation
– Language Evaluation

Answer 4

R has essentially no type safety. You can do all sorts of things which end up with meaningless objects.

x <- lm(Sepal.Width ~ Sepal.Length, data=iris)
x
## Call:
## lm(formula = Sepal.Width ~ Sepal.Length, data = iris)
##
## Coefficients:
##  (Intercept)  Sepal.Length  
##      3.41895      -0.06188  

opar <- par(mfrow=c(2,2))

plot(x)                  # Note generated plot results.
par(opar)


class(x) <- "data.frame"
plot(x)
Error in data.matrix(x) : 
  (list) object cannot be coerced to type 'double'
x
## [1] coefficients  residuals     effects       rank          fitted.values assign        qr            df.residual  
## [9] xlevels       call          terms         model        
## <0 rows> (or 0-length row.names)

Answer 5

R is dynamically typed.

Example: x <- "hi" (typeof(x) = character); x <- 1 (typeof(x) = double)

Concerning type safety: x <- 1; y <- "a"

x + y : Error in x + y : non-numeric argument to binary operator

However paste(x,y) (which is a concatenation) works : "1 a"