Learn R Programming

rlang

rlang is a collection of frameworks and APIs for programming with R.

Frameworks

Two comprehensive frameworks are implemented in rlang.

  • tidy eval, a programmable data-masking framework used in tidyverse packages like dplyr and ggplot2. As a user, you will encounter the embracing operator {{ and name injection with the glue operators "{" and "{{".

  • rlang errors, a set of tools to signal and display errors. This includes backtrace capture with global_entrace() and backtrace display with last_error() and last_warnings(). Use abort() to create errors with bullet lists, structured metadata, and error chaining support.

    The display of error messages is optimised for bullet lists and chained errors and optionally integrates with the cli package (see local_use_cli()).

Argument intake

A set of tools help you check, validate, and preprocess arguments.

  • Checking function arguments, e.g. arg_match(), check_required(), and check_exclusive().

  • Checking dots, e.g. check_dots_used() and check_dots_empty().

  • Collecting dynamic dots, e.g. list2(). These dots support splicing with !!! and name injection with the glue operators "{" and "{{".

Programming interfaces

rlang provides various interfaces for working with R and R objects.

  • The R session, e.g. check_installed(), on_load(), and on_package_load().

  • Environments, e.g. env(), env_has(), env_get(), env_bind(), env_unbind(), env_print(), and local_bindings().

  • Evaluation, e.g. inject() and eval_bare().

  • Calls and symbols, e.g. call2(), is_call(), is_call_simple(), data_sym(), and data_syms().

  • Functions, e.g. new_function() and as_function(). The latter supports the purrr-style formula notation for lambda functions.

Installation

Install the released version of rlang from CRAN:

install.packages("rlang")

Or install the development version from GitHub with:

# install.packages("pak")
pak::pkg_install("r-lib/rlang")

Code of Conduct

Please note that the rlang project is released with a Contributor Code of Conduct. By contributing to this project, you agree to abide by its terms.

Copy Link

Version

Install

install.packages('rlang')

Monthly Downloads

2,554,022

Version

1.3.0

License

MIT + file LICENSE

Issues

134

Pull Requests

23

Stars

577

Forks

155

Maintainer

Lionel Henry

Last Published

July 5th, 2026

Functions in rlang (1.3.0)

as_label

Create a default name for an R object
bytes-class

Human readable memory sizes
box

Box a value
as_environment

Coerce to an environment
bare-type-predicates

Bare type predicates
as_utf8_character

Coerce to a character vector and attempt encoding conversion
as_name

Extract names from symbols
as_function

Convert to function
as_data_mask

Create a data mask
call_match

Match supplied arguments to function definition
as_string

Cast symbol to string
call_modify

Modify the arguments of a call
call2

Create a call
call_name

Extract function name or namespace of a call
caller_arg

Find the caller argument for error messages
call_args

Extract arguments from a call
catch_cnd

Catch a condition
call_fn

Extract function from a call
call_standardise

Standardise a call
check_data_frame

Check argument type (data frame)
call_inspect

Inspect a call
check_exclusive

Check that arguments are mutually exclusive
check_dots_used

Check that all dots have been used
check_type_scalar

Check argument type (scalar)
done

Box a final value for early termination
dev-notes-dots

Development notes - dots.R
check_required

Check that argument is supplied
cnd_inherits

Does a condition or its ancestors inherit from a class?
check_type_number

Check argument type (numbers)
cnd_message

Build an error message from parts
child_env

Create a child environment
cnd_signal

Signal a condition object
check_dots_unnamed

Check that all dots are unnamed
check_dots_empty0

Check that dots are empty (low level variant)
cnd_muffle

Muffle a condition
englue

Defuse function arguments with glue
enquo

Defuse function arguments
cnd_type

What type is a condition?
dots_splice

Splice lists
defusing-advanced

Advanced defusal operators
dots_values

Evaluate dots with preliminary splicing
dot-data

.data and .env pronouns
dots_n

How many arguments are currently forwarded in dots?
check_dots_empty

Check that dots are empty
env_bury

Mask bindings by defining symbols deeper in a scope
dyn-dots

Dynamic dots features
env_clone

Clone or coalesce an environment
duplicate

Duplicate an R object
chr_unserialise_unicode

Translate unicode points to UTF-8
cnd

Create a condition object
entrace

Add backtrace from error handler
env

Create a new environment
env_names

Names and numbers of symbols bound in an environment
env_has

Does an environment have or see bindings?
env_cache

Cache a value in an environment
env_get

Get an object in an environment
embrace-operator

Embrace operator {{
empty_env

Get the empty environment
expr

Defuse an R expression
env_print

Pretty-print an environment
env_poke

Poke an object in an environment
env_bind

Bind symbols to objects in an environment
env_binding_are_active

What kind of environment binding?
exec

Execute a function
expr_print

Print an expression
env_parent

Get parent environments
env_depth

Depth of an environment chain
env_inherits

Does environment inherit from another environment?
env_unbind

Remove bindings from an environment
f_rhs

Get or set formula components
f_text

Turn RHS of formula into a string or label
env_binding_lock

Lock or unlock environment bindings
eval_bare

Evaluate an expression in an environment
eval_tidy

Evaluate an expression with quosures and pronoun support
env_is_user_facing

Is frame environment user facing?
fn_body

Get or set function body
hash

Hashing
flatten

Flatten or squash a list of lists into a simpler vector
global_entrace

Entrace unexpected errors
faq-options

Global options for rlang
env_unlock

Unlock an environment
env_browse

Browse environments
global_prompt_install

Prompt user to install missing packages
glue-operators

Name injection with "{" and "{{"
ffi_standalone_types_check

Internal API for standalone-types-check
global_handle

Register default global handlers
fn_env

Return the closure environment of a function
env_name

Label of an environment
env_lock

Lock an environment
expr_interp

Process unquote operators in a captured expression
exprs_auto_name

Ensure that all elements of a list of expressions are named
inherits_any

Does an object inherit from a set of classes?
is_lang

Is object a call?
is_interactive

Is R running interactively?
is_empty

Is object an empty vector or NULL?
expr_label

Turn an expression to a label
fn_fmls

Extract arguments from a function
has_name

Does an object have an element with this name?
is_call

Is object a call?
has_length

How long is an object?
is_dictionaryish

Is a vector uniquely named?
format_error_bullets

Format bullets for error messages
format_error_call

Validate and format a function call for use in error messages
friendly_type

Format a type for error messages
is_callable

Is an object callable?
is_pairlist

Is object a node or pairlist?
is_function

Is object a function?
list2

Collect dynamic dots in a list
local_error_call

Set local error call in an execution environment
is_formula

Is object a formula?
local_bindings

Temporarily change bindings of an environment
is_installed

Are packages installed in any of the libraries?
is_reference

Is an object referencing another?
inject

Inject objects in an R expression
injection-operator

Injection operator !!
is_named

Is object named?
get_env

Get or set the environment of an object
is_copyable

Is an object copyable?
is_integerish

Is a vector integer-like?
is_condition

Is object a condition?
is_symbol

Is object a symbol?
is_namespace

Is an object a namespace environment?
is_true

Is object identical to TRUE or FALSE?
is_weakref

Is object a weak reference?
lang

Create a call
on_load

Run expressions on load
op-get-attr

Infix attribute accessor and setter
new_formula

Create a formula
quo_label

Format quosures for printing or labelling
local_options

Change global options
new_call

Create a new call from components
new_quosures

Create a list of quosures
qq_show

Show injected expression
new_quosure

Create a quosure from components
quo_expr

Squash a quosure
op-null-default

Default value for NULL
rlang_error

Errors of class rlang_error
pairlist2

Collect dynamic dots in a pairlist
last_warnings

Display last messages and warnings
local_use_cli

Use cli to format error messages
last_error

Last abort() error
interrupt

Simulate interrupt condition
invoke

Invoke a function with a list of arguments
set_expr

Set and get an expression
missing_arg

Generate or handle a missing argument
scalar-type-predicates

Scalar type predicates
set_names

Set names of a vector
scoped_env

Deprecated scoped functions
names2

Get names of a vector
rlib_trace_spec

Backtrace specification
is_environment

Is object an environment?
names_inform_repair

Inform about name repair
is_expression

Is an object an expression?
quosure-tools

Quosure getters, setters and predicates
quo_squash

Squash a quosure
search_envs

Search path environments
new-vector

Create vectors matching a given length
raw_deparse_str

Serialize a raw vector to a string
scoped_interactive

Deprecated scoped_ functions
op-null-continuation

Default value for non-NULL
op-na-default

Replace missing values
obj_address

Address of an R object
ns_registry_env

Return the namespace registry env
splice

Splice values at dots collection time
splice-operator

Splice operator !!!
sym

Create a symbol or list of symbols
switch_type

Dispatch on base types
missing

Missing values
topic-condition-customisation

Customising condition messages
topic-condition-formatting

Formatting messages with cli
new_function

Create a function
new_node

Helpers for pairlist and language nodes
parse_expr

Parse R code
topic-defuse

Defusing R expressions
topic-data-mask

What is data-masking and why do I need {{?
prim_name

Name of a primitive function
rlang-package

rlang: Functions for Base Types and Core R and 'Tidyverse' Features
stack

Get properties of the current or caller frame
rlang_backtrace_on_error

Display backtrace on error
stop_input_type

Throw a type mismatch error
string

Create a string
stack-deprecated

Call stack information
ns_env

Get the namespace of a package
new_weakref

Create a weak reference
rep_along

Create vectors matching the length of a given vector
seq2

Increasing sequence of integers in an interval
set_attrs

Add attributes to an object
return_from

Jump to or from a frame
topic-data-mask-ambiguity

The data mask ambiguity
topic-double-evaluation

The double evaluation problem
topic-embrace-constants

Why are strings and other constants enquosed in the empty environment?
topic-inject

Injecting with !!, !!!, and glue syntax
topic-metaprogramming

Metaprogramming patterns
topic-error-call

Including function calls in error messages
topic-embrace-non-args

Does {{ work on regular objects?
topic-data-mask-programming

Data mask programming patterns
topic-error-chaining

Including contextual information with error chains
vec_poke_n

Poke values into a vector
try_fetch

Try an expression with condition handlers
vector-coercion

Coerce an object to a base type
trace_back

Capture a backtrace
topic-inject-out-of-context

What happens if I use injection operators out of context?
type-predicates

Type predicates
type_of

Base type of an object
vector-construction

Create vectors
with_env

Evaluate an expression within a given environment
wref_key

Get key/value from a weak reference object
with_handlers

Establish handlers on the stack
topic-quosure

What are quosures and when are they needed?
topic-multiple-columns

Taking multiple columns without ...
zap_srcref

Zap source references
zap

Create zap objects
abort

Signal an error, warning, or message
args_dots_empty

Helper for consistent documentation of empty dots
args_error_context

Documentation anchor for error arguments
arg_match

Match an argument to a character vector
as_box

Convert object to a box
args_data_masking

Argument type: data-masking
UQ

Deprecated UQ() and UQS() operators
are_na

Test for missing values
args_dots_used

Helper for consistent documentation of used dots
as_closure

Transform to a closure