Advanced R Programming Concepts

library(purrr)
library(dplyr)

# map() — apply function to list/vector, return list
map(1:5, ~ .x^2)               # List of squares
map_dbl(1:5, ~ .x^2)           # Numeric vector
map_chr(1:5, ~ paste0("item_", .x))  # Character vector
map_lgl(1:5, ~ .x > 3)         # Logical vector

# map2() — iterate over two vectors simultaneously
x_vals <- c(1, 2, 3, 4, 5)
y_vals <- c(10, 20, 30, 40, 50)
map2_dbl(x_vals, y_vals, ~ .x + .y)  # 11 22 33 44 55

# pmap() — iterate over multiple inputs
params <- list(n=c(10,20,30), mean=c(0,5,10), sd=c(1,2,3))
pmap(params, rnorm) %>% map_dbl(mean)  # 3 means from 3 distributions

# reduce() — fold list with binary function
reduce(1:5, `+`)      # 1+2+3+4+5 = 15
reduce(list(c(1,2,3), c(4,5), c(6)), union)  # Set union

# keep/discard — filter list elements
nums <- list(1, -3, 5, -2, 8, -1)
keep(nums, ~ .x > 0)    # 1 5 8
discard(nums, ~ .x > 0) # -3 -2 -1

# Safely handle errors
safe_log <- safely(log)
results <- map(list(10, -1, 0, 5), safe_log)
map(results, "result")  # Results (NA for errors)
map(results, "error")   # Error messages

# compose functions (pipe without %>%)
process <- compose(
  partial(round, digits=2),
  mean,
  ~ .x[!is.na(.x)]      # Remove NAs first
)
process(c(1, 2, NA, 4, 5))  # 3.0

# Closures — functions that remember their environment
make_counter <- function(start=0) {
  count <- start
  list(
    increment = function(by=1) { count <<- count + by; invisible(count) },
    reset     = function() { count <<- 0; invisible(count) },
    get       = function() count
  )
}

counter <- make_counter(10)
counter$increment()
counter$increment(5)
counter$get()    # 16
counter$reset()
counter$get()    # 0

# Factory functions — create customized functions
make_power <- function(exp) function(x) x^exp
square <- make_power(2)
cube   <- make_power(3)
square(4)  # 16
cube(3)    # 27

# Memoization — cache expensive function results
library(memoise)
slow_function <- function(n) { Sys.sleep(0.01); sum(1:n) }
fast_function <- memoise(slow_function)  # Cache results!

system.time(fast_function(1000))  # Slow first time
system.time(fast_function(1000))  # Instant (cached)

library(data.table)

# Convert to data.table
DT <- as.data.table(diamonds)  # Use ggplot2 diamonds dataset

# data.table syntax: DT[rows, columns, by]
# Filter
DT[cut == "Ideal" & price < 1000]

# Select and compute
DT[, .(mean_price = mean(price), count = .N), by=cut]

# Add column (modifies in place — memory efficient)
DT[, price_per_carat := price / carat]

# Fast aggregation (10-100x faster than dplyr for large data)
DT[, .(avg_price=mean(price), sd=sd(price)), by=.(cut, color)]

# data.table is 10-50x faster than dplyr for:
# - Large datasets (> 100K rows)
# - Complex groupby operations
# - In-place modification (no copy)

# Benchmark
large_df <- data.frame(x=rnorm(1e6), g=sample(letters, 1e6, TRUE))
large_DT <- as.data.table(large_df)

system.time(aggregate(x ~ g, large_df, mean))    # base R
system.time(large_DT[, .(mean=mean(x)), by=g])  # data.table — much faster

library(dplyr)
library(rlang)

# Problem: function that takes column names as arguments
# This WON'T work: dplyr uses non-standard evaluation
filter_and_select <- function(df, filter_col, filter_val, output_cols) {
  # Naive version fails:
  # df %>% filter(filter_col == filter_val) %>% select(output_cols)

  # Correct: use enquo() and !! to program with dplyr
  df %>%
    filter({{ filter_col }} == filter_val) %>%
    select({{ output_cols }})
}

# Using .data pronoun (simpler for string column names)
summarize_group <- function(df, group_col, value_col) {
  df %>%
    group_by(.data[[group_col]]) %>%
    summarise(mean = mean(.data[[value_col]]), n=n(), .groups="drop")
}
summarize_group(mtcars, "cyl", "mpg")