rlang1.1.6 package

Signal an error, warning, or message

Test for missing values

Match an argument to a character vector

Argument type: data-masking

Helper for consistent documentation of empty dots

Helper for consistent documentation of used dots

Documentation anchor for error arguments

Convert object to a box

Transform to a closure

Create a data mask

Coerce to an environment

Convert to function

Create a default name for an R object

Extract names from symbols

Cast symbol to string

Coerce to a character vector and attempt encoding conversion

Bare type predicates

Box a value

Human readable memory sizes

Extract arguments from a call

Extract function from a call

Inspect a call

Match supplied arguments to function definition

Modify the arguments of a call

Extract function name or namespace of a call

Standardise a call

Create a call

Find the caller argument for error messages

Catch a condition

Check that dots are empty

Check that dots are empty (low level variant)

Check that all dots are unnamed

Check that all dots have been used

Check that arguments are mutually exclusive

Check that argument is supplied

Create a child environment

Translate unicode points to UTF-8

Does a condition or its ancestors inherit from a class?

Build an error message from parts

Muffle a condition

Signal a condition object

What type is a condition?

Create a condition object

Advanced defusal operators

Development notes - dots.R

Box a final value for early termination

.data and .env pronouns

How many arguments are currently forwarded in dots?

Splice lists

Evaluate dots with preliminary splicing

Duplicate an R object

Dynamic dots features

Embrace operator {{

Get the empty environment

Defuse function arguments with glue

Defuse function arguments

Add backtrace from error handler

Bind symbols to objects in an environment

What kind of environment binding?

Lock or unlock environment bindings

Browse environments

Mask bindings by defining symbols deeper in a scope

Cache a value in an environment

Clone or coalesce an environment

Depth of an environment chain

Get an object in an environment

Does an environment have or see bindings?

Does environment inherit from another environment?

Is frame environment user facing?

Lock an environment

Label of an environment

Names and numbers of symbols bound in an environment

Get parent environments

Poke an object in an environment

Pretty-print an environment

Remove bindings from an environment

Unlock an environment

Create a new environment

Evaluate an expression in an environment

Evaluate an expression with quosures and pronoun support

Execute a function

Process unquote operators in a captured expression

Turn an expression to a label

Print an expression

Defuse an R expression

Ensure that all elements of a list of expressions are named

Get or set formula components

Turn RHS of formula into a string or label

Global options for rlang

Internal API for standalone-types-check

Flatten or squash a list of lists into a simpler vector

Get or set function body

Return the closure environment of a function

Extract arguments from a function

Format bullets for error messages

Validate and format a function call for use in error messages

Format a type for error messages

Get or set the environment of an object

Entrace unexpected errors

Register default global handlers

Prompt user to install missing packages

Name injection with "{" and "{{"

How long is an object?

Does an object have an element with this name?

Hashing

Does an object inherit from a set of classes?

Inject objects in an R expression

Injection operator !!

Simulate interrupt condition

Invoke a function with a list of arguments

Is object a call?

Is an object callable?

Is object a condition?

Is an object copyable?

Is a vector uniquely named?

Is object an empty vector or NULL?

Is object an environment?

Is an object an expression?

Is object a formula?

Is object a function?

Are packages installed in any of the libraries?

Is a vector integer-like?

Is R running interactively?

Is object a call?

Is object named?

Is an object a namespace environment?

Is object a node or pairlist?

Is an object referencing another?

Is object a symbol?

Is object identical to TRUE or FALSE?

Is object a weak reference?

Create a call

Last abort() error

Display last messages and warnings

Collect dynamic dots in a list

Temporarily change bindings of an environment

Set local error call in an execution environment

Change global options

Use cli to format error messages

Generate or handle a missing argument

Missing values

Inform about name repair

Get names of a vector

Create a new call from components

Create a formula

Create a function

Helpers for pairlist and language nodes

Create a quosure from components

Create a list of quosures

Create a weak reference

Create vectors matching a given length

Get the namespace of a package

Return the namespace registry env

Address of an R object

Run expressions on load

Infix attribute accessor and setter

Replace missing values

Default value for NULL

Collect dynamic dots in a pairlist

Parse R code

Name of a primitive function

Show injected expression

Squash a quosure

Format quosures for printing or labelling

Squash a quosure

Quosure getters, setters and predicates

Serialize a raw vector to a string

Create vectors matching the length of a given vector

Jump to or from a frame

Display backtrace on error

Errors of class rlang_error

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

Backtrace specification

Scalar type predicates

Deprecated scoped functions

Deprecated scoped_ functions

Search path environments

Increasing sequence of integers in an interval

Add attributes to an object

Set and get an expression

Set names of a vector

Splice operator !!!

Splice values at dots collection time

Call stack information

Get properties of the current or caller frame

Create a string

Dispatch on base types

Create a symbol or list of symbols

Customising condition messages

Formatting messages with cli

The data mask ambiguity

Data mask programming patterns

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

Defusing R expressions

The double evaluation problem

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

Does {{ work on regular objects?

Including function calls in error messages

Including contextual information with error chains

What happens if I use injection operators out of context?

Injecting with !!, !!!, and glue syntax

Metaprogramming patterns

Taking multiple columns without ...

What are quosures and when are they needed?

Capture a backtrace

Try an expression with condition handlers

Base type of an object

Type predicates

Deprecated UQ() and UQS() operators

Poke values into a vector

Coerce an object to a base type

Create vectors

Evaluate an expression within a given environment

Establish handlers on the stack

Get key/value from a weak reference object

Zap source references

Create zap objects