1
2
3
4
5
# Single-line comment
print("Hello, R!")  # Printing to console
x <- 10  # Assignment operator
|> sqrt()  # Native pipe (R >= 4.1)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# Numeric (double)
x <- 42.5
is.numeric(x)  # TRUE

# Integer
y <- 42L
is.integer(y)  # TRUE

# Character
name <- "R Programming"
is.character(name)  # TRUE

# Logical
is_true <- TRUE
is.logical(is_true)  # TRUE

# Complex
z <- 3 + 2i
is.complex(z)  # TRUE

# Raw
r <- charToRaw("R")
is.raw(r)  # TRUE

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# Vector (homogeneous, atomic)
numeric_vector <- c(1, 2, 3, 4, 5)
character_vector <- c("a", "b", "c")

# List (heterogeneous)
mixed_list <- list(1, "a", TRUE, 3.14)

# Factor (categorical variable)
gender <- factor(c("male", "female", "male"))

# Matrix / Array
m <- matrix(1:12, nrow = 3, ncol = 4)
a <- array(1:24, dim = c(2, 3, 4))

# Data Frame
# Note: as of R 4.0.0, stringsAsFactors defaults to FALSE
df <- data.frame(
  name = c("Alice", "Bob", "Charlie"),
  age  = c(25, 30, 35)
)

# Tibble (modern data frame from the tibble package)
# library(tibble); tibble(name = ..., age = ...)

1
2
3
4
5
6
7
8
9
10
11
12
13
# Variable assignment
x <- 10   # Preferred method
y = 20    # Also works (allowed at top level)
x <<- 30  # Super-assignment (parent environment)

# R has no true constants; use UPPER_CASE by convention
PI <- 3.14159

# `lockBinding()` can make a binding read-only
e <- new.env()
e$K <- 273.15
lockBinding("K", e)

1
2
3
4
5
6
7
8
9
10
a <- 10
b <- 3
a + b   # Addition
a - b   # Subtraction
a * b   # Multiplication
a / b   # Division
a %% b  # Modulo
a %/% b # Integer division
a ^ b   # Exponentiation

1
2
3
4
5
6
7
x == y  # Equal to
x != y  # Not equal to
x <  y  # Less than
x >  y  # Greater than
x <= y  # Less than or equal to
x >= y  # Greater than or equal to

1
2
3
4
5
6
7
TRUE & FALSE    # Vectorised AND
TRUE | FALSE    # Vectorised OR
TRUE && FALSE   # Scalar AND (errors on length != 1 since R 4.3)
TRUE || FALSE   # Scalar OR  (errors on length != 1 since R 4.3)
!TRUE           # Logical NOT
isTRUE(x); isFALSE(x)

1
2
3
4
5
6
7
8
# Native pipe (base R, requires R >= 4.1; placeholder `_` since 4.2)
mtcars |> subset(cyl == 4) |> head()
mtcars |> lm(mpg ~ wt, data = _)

# magrittr pipe (still common via dplyr/tidyverse)
library(magrittr)
mtcars %>% subset(cyl == 4) %>% head()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# If-else
if (condition) {
  # code
} else if (another_condition) {
  # code
} else {
  # code
}

# Vectorised choice
ifelse(x > 0, "positive", "non-positive")

# Switch statement
switch(x,
  "a" = "First option",
  "b" = "Second option",
  "default"
)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# For loop
for (i in seq_len(5)) {
  print(i)
}

# While loop
while (condition) {
  # code
}

# Repeat loop
repeat {
  # code
  if (condition) break
}

1
2
3
4
5
6
7
8
9
10
11
12
# Function definition
my_function <- function(x, y = 10) {
  x + y  # last expression is returned
}

# Traditional anonymous function
square <- function(x) x^2

# Shorthand lambda syntax (R >= 4.1)
square <- \(x) x^2
sapply(1:5, \(x) x^2)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# Ellipsis for variable arguments
variable_args <- function(...) {
  args <- list(...)
  print(args)
}

# Functional programming with apply family
lapply(list(1, 2, 3), \(x) x^2)
sapply(list(1, 2, 3), \(x) x^2)
vapply(1:3, \(x) x^2, numeric(1))  # type-safe

# purrr equivalents
# purrr::map(1:3, \(x) x^2); purrr::map_dbl(1:3, \(x) x^2)

1
2
3
4
5
6
7
8
9
# Creating vectors
v1 <- c(1, 2, 3)
v2 <- seq(1, 10, by = 2)
v3 <- rep(1, times = 5)

# Vector operations (recycle to longest)
v1 + v2
length(v1)

1
2
3
4
5
6
7
8
9
10
11
12
# Creating data frames
df <- data.frame(
  name = c("Alice", "Bob"),
  age  = c(25, 30)
)

# Subsetting
df$name
df[1, 2]            # First row, second column
df[df$age > 25, ]
subset(df, age > 25)

1
2
3
4
5
6
7
person <- list(name = "John", age = 30)
class(person) <- "Person"

print.Person <- function(x, ...) {
  cat("Name:", x$name, "Age:", x$age, "\n")
}

1
2
3
4
setClass("Point", representation(x = "numeric", y = "numeric"))
setGeneric("norm", function(obj) standardGeneric("norm"))
setMethod("norm", "Point", function(obj) sqrt(obj@x^2 + obj@y^2))

1
2
3
4
5
6
7
8
library(R6)
Counter <- R6Class("Counter",
  public = list(
    n = 0,
    inc = function() { self$n <- self$n + 1; invisible(self) }
  )
)

1
2
3
4
5
6
7
# install.packages("S7")
library(S7)
Range <- new_class("Range",
  properties = list(lo = class_double, hi = class_double)
)
r <- Range(lo = 0, hi = 1)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# Try-catch with conditions
tryCatch({
  # code that might throw an error
}, error = function(e) {
  message("An error occurred: ", conditionMessage(e))
}, warning = function(w) {
  message("A warning occurred: ", conditionMessage(w))
}, finally = {
  # cleanup code
})

# Modern condition handling with rlang
# rlang::abort(), rlang::warn(), rlang::inform()

1
2
3
4
5
6
7
8
9
10
11
12
13
# Reading files (base)
read.csv("data.csv")
read.table("data.txt")

# Writing files (base)
write.csv(df, "output.csv", row.names = FALSE)
write.table(df, "output.txt")

# Faster / modern alternatives
# readr::read_csv("data.csv"); readr::write_csv(df, "out.csv")
# data.table::fread("data.csv"); data.table::fwrite(df, "out.csv")
# arrow::read_parquet("data.parquet")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# Install package from CRAN
install.packages("ggplot2")

# Load package
library(ggplot2)

# Check installed packages
installed.packages()

# Install from GitHub (via pak — recommended modern installer)
# install.packages("pak")
pak::pak("tidyverse/dplyr")

# Reproducible project libraries
# renv::init(); renv::snapshot(); renv::restore()

1
2
3
4
5
6
7
8
9
10
11
12
13
# Using testthat (3rd edition)
library(testthat)

test_that("Addition works", {
  expect_equal(2 + 2, 4)
})

# Snapshot tests
# expect_snapshot(print(model))

# Property-based / parameterised checks
# Other useful packages: tinytest, hedgehog, vdiffr (for ggplot2)

1
2
3
4
5
6
7
8
9
10
# R Markdown
library(rmarkdown)
render("report.Rmd")

# Quarto (next-generation, multi-language successor to R Markdown)
# quarto::quarto_render("report.qmd")

# Workflow orchestration
# library(targets); tar_make()