R

Question 1

What is an expression?

Answer 1

1) An object that captures the structure of the code without evaluating it.
2) The data structures present in Abstract Syntax Trees.
3) An expression is any member of the set of base types created by parsing code: scalars, symbols call objects and pairlists.

Question 2

Name the elements of an expression:

Answer 2

Constants, Symbols, Call objects and pairlists.

Question 3

What is a Call Object?

Answer 3

A captured function call.

It is a special type of list where the first element is the name of the function and the remaining elements is the arguments to the function call.

Generally the function called is a symbol.

Question 4

What is a constant?

Answer 4

NULL or an atomic vector of length 1 (i.e. a scalar). It is also the simplest element of the AST.

Bonus: Constants are self quoting meaning that the expression used to represent a constant is the constant itself.

Question 5

What is a Symbol?

Answer 5

Name of an object.

Bonus: You can create symbols in two ways:
1) Capture an expression referencing to the name of an object:
expr(x)
2) Turn string into a symbol:
rlang::sym(“x”)

Question 6

rlang::expr()

Answer 6

returns its argument unevaluated. It is equivalent to base::bquote()

Question 7

rlang::is_syntactic_literal(x)

Answer 7

checks if x is a constant.

Question 8

rlang::sym()

Answer 8

creates a symbol from a string.

Question 9

rlang::call_standardise()

Answer 9

Standardize the call to use complete argument names.

Question 10

Abstract Syntax Trees and function positions: What happens when a function in a call object is either: 1) Called from another package, an R6 object method or generated from a function factory?

Answer 10

The function position (the first position in the call object) in the abstract syntax tree is occupied by another call object.
The function is not in the current environment.

Question 11

rlang::call2()

Answer 11

Create a call object from it’s components. First position is the name of the function, provided either as a string, symbol or another call. The remaining arguments are the arguments for the provided function.

Question 12

Explain rlang::enexpr() vs rlang::expr().

Answer 12

Used to capture the code passed to a function call. As opposed to rlang::expr() which will capture whatever is typed within rlang::expr().

Question 13

rlang::eval_tidy()

Answer 13

About controlling the evaluation of code.

Question 14

What is datamasking?

Answer 14

The data mask makes it easier to evaluate an expression in the context of a data frame. This introduces potential evaluation ambiguity which we’ll then resolve with data pronouns.

Question 15

What does parsing mean?

Answer 15

The process by which a computer language takes a string and constructs an expression

Question 16

Explain the differences between calls and expressions.

Answer 16

An expression can be made up of call objects and so call objects are an element of an expression.

Question 17

In the context of R, what is meant by Associativity? Mention two important operators that are special cases in R. Why should you care?

Answer 17

The order of evaluation of repeated infix functions. Most operators are left-associative in R, meaning that R evaluates from the left, but two exceptions are the exponential operator and the assignment.
I.e. 2^3^4 compute first 3^4 = 81 and then 2^81

You should care because some operations are non-associative, ex. is usage of + in ggplot2.

Question 18

Are + associative in ggplot2?

Answer 18

No, ggplot2 uses + to draw geoms on top of eachother, i.e. geom_point + geom_smooth != geom_smooth + geom_point.

Question 19

rlang::parse_expr()

Answer 19

Takes a string and creates an expression.

is.call(rlang::parse_expr()) always evaluates to TRUE.

Question 20

What is deparsing?

Answer 20

The process of taking an expression and turning it in to a string.

Question 21

rlang::expr_text()

Answer 21

Deparses an expression.

Question 22

How is := used in tidy evaluation?

Answer 22

The colon-equals operator allows for having expressions as argument names.

Question 23

What is quotation?

Answer 23

It is the act of capturing an unevaluated expression.

Question 24

What is unquotation?

Answer 24

It is the act of selectively evaluate parts of an otherwise unevaluated expression.

Question 25

Defusing is a.k.a.

Answer 25

Quoting

Question 26

Why quote/defuse evaluation of expressions?

Answer 26

Enable data-masking. This means that an expression can be evaluated in the context of a data-frame instead of following standard evaluation rules.

Question 27

Explain the difference between data-variables and environment-variables.

Answer 27

Environment-variables are defined in the global environment or in a function and data-variables are column names in a data-frame.

Question 28

The rlang equivalent of substitute()? What do they do differently?

Answer 28

What is enquote?

enquote captures what the user has provided as arguments to a function.

substitute does also this is certain situations, but it also substitutes the arguments, if it finds a binding in the current environment provided.

Question 29

What does !! (bang-bang operator) do?

Answer 29

It unquotes its input, i.e. it takes the expression and inserts its value, i.e. evaluates it.

x = expr(!!x)

Question 30

Explain how !! behaves with call objects vs constants and symbols.

Answer 30

Constants and symbols are inserted for the right hand side of !!. Call objects are first evaluated then inserted.

Question 31

What does the following code do

dfs

Answer 31

Equivalent to
dplyr::bind_rows(a,b)

The use of !!! in this context is known as splatting. It uses unquotation to insert the elements of a list into a function as arguments.

Question 32

Explain what happens in the code below

x

Answer 32

Apply the same arguments to different functions.

purrr::map_dbl(.x, .f, …) takes an input, .x, and transform it with the function .f. The input here is the vector of function names, c(“mean”, “median”, “sd”). The function applied to this vector is the rlang::exec(.fn, …) function. Excec evaluates the function provided here each member of the vector of function names. Additional arguments, x (the numbers to compute on) and na.rm =T are passed in via the … argument in purrr::map_dbl to excec’s … argument and lastly to the particular function call.

Question 33

What is a quosure?

Answer 33

a data structure that captures an expression along with its associated environment, as found in function arguments.

Question 34

What is quasiquotation?

Answer 34

Quotation is the act of capturing an unevaluated expression and unquotation is the ability to selectively evaluate parts of an otherwise quoted expression. Together, this is called quasiquotation.