Should I use purrr map or base R lapply for simple iterations?

Use purrr map for better type stability and pipe compatibility in complex pipelines, but base R lapply is sufficient for simple tasks with no dependencies. purrr shines when you need consistent outputs and error handling.

How to handle errors in purrr map functions without stopping execution?

Wrap your function with safely() or possibly() from purrr to capture errors and continue processing. For example, map(data, safely(function)) returns a list with results and errors for graceful recovery.

Can purrr be used for parallel processing in R?

Yes, purrr integrates with in_parallel() to spread computation across cores. Combine map() with .progress = TRUE and parallel backends like future to speed up long-running jobs easily.

How to extract nested elements from a list using purrr?

Use map() with character or numeric vectors, or the pluck() function for deep extraction. For instance, map_dbl(list, "coefficients", "estimate") safely retrieves specific nested values from model outputs.

Why is my purrr map_dbl returning NA values?

This often happens when the input function returns non-numeric values or errors. Check your function's output with map() first, and use safely() to handle exceptions or ensure consistent double returns.

How to install purrr without the entire tidyverse?

Install purrr alone with install.packages('purrr'), but note it has dependencies like rlang and vctrs. For the development version, use pak::pak('tidyverse/purrr') from GitHub.

Open-Awesome

purrr

NOASSERTIONRv1.2.2

A functional programming toolkit for R that enhances data manipulation with consistent, type-stable functions.

Visit Website GitHub

1.4k stars293 forks0 contributors

What is purrr?

purrr is an R package that provides a functional programming toolkit for working with functions and vectors. It solves the problem of verbose and error-prone iteration in R by offering a consistent set of functions like `map()` that replace for loops with more readable and type-stable code.

Target Audience

R developers and data scientists, especially those working within the tidyverse ecosystem, who need to perform complex data manipulation, iteration, and functional programming tasks.

Value Proposition

Developers choose purrr for its consistency, type safety, and seamless integration with the pipe operator, making code more expressive and easier to debug compared to base R alternatives.

Overview

A functional programming toolkit for R

Use Cases

Best For

Replacing for loops with functional iteration in data pipelines
Applying complex transformations across lists or vectors with consistent output types
Parallelizing data processing tasks across multiple cores or machines
Extracting and summarizing model results from split data frames
Writing more readable and maintainable R code for data manipulation
Tracking progress of long-running iterative jobs in R

Not Ideal For

Data.table-centric workflows where optimized in-place operations are preferred over functional iteration
Lightweight scripts or packages aiming for minimal dependencies, as purrr requires the tidyverse ecosystem
Real-time applications where microseconds matter, due to the slight overhead of purrr's abstractions

Pros & Cons

Pros

Type-Stable Iteration

Functions like map() always return the advertised output type, such as lists from map() or doubles from map_dbl(), reducing debugging time by preventing silent type coercion errors.

Seamless Pipe Integration

First argument is always the data, allowing natural chaining with the pipe operator (%>% or |>) for readable and maintainable data pipelines, as shown in the mtcars example.

Flexible Function Application

map() accepts functions, character vectors for component extraction, or numeric vectors for positional access, making it versatile for different use cases without boilerplate code.

Built-in Progress and Parallelism

Includes .progress argument for tracking long jobs and integrates with in_parallel() for easy multi-core or distributed computing, enhancing productivity for data-heavy tasks.

Cons

Ecosystem Dependency

As part of the tidyverse, purrr introduces multiple package dependencies, which can bloat project environments and complicate deployment in minimal or production setups.

Performance Overhead

The functional abstractions add a layer of function calls that can be slower than optimized base R loops or data.table operations for large-scale data processing.

Conceptual Learning Curve

Requires a shift from imperative for-loops to functional paradigms, which may be challenging for R users unfamiliar with map-reduce patterns or tidyverse conventions.

Frequently Asked Questions

Related Projects

magrittr <img class="emoji" alt="heart" src="https://cdn.jsdelivr.net/gh/qinwf/awesome-R@3c66da6e291bcc0520b1649125b0bed750896a9a/heart.png" height="20" align="absmiddle" width="20">

Improve the readability of R code with the pipe

Stars972

Forks161

Last commit2 months ago

lambda.r

Functional programming in R

Stars219

Forks15

Last commit1 year ago

pipeR

Multi-Paradigm Pipeline Implementation

Stars172

Forks39

Last commit9 years ago

Community-curated · Updated weekly · 100% open source

Found a gem we're missing?

Open-Awesome is built by the community, for the community. Submit a project, suggest an awesome list, or help improve the catalog on GitHub.

Submit a project Star on GitHub