R评估过程中会发生什么？

Question

I'm interested in how the most basic thing, evaluation, works in R.

I came to R as a biologist, and yet interested in everything related to code, it's still a bit mysterious.

I think I understand properly:

• that everything that exists is an object in R
• that everything that happens is a function call (same ref)
• what an environment is and how lazy evaluation works
• (more or less) what happens during compilation for compiled language.

But technically, what happens behind the curtain when we evaluate something in R, when we press enter after a (or more) line(s) of code?

I have found this, in the R language definition by the core team:

When a user types a command at the prompt (or when an expression is read from a file) the first thing that happens to it is that the command is transformed by the parser into an internal representation. The evaluator executes parsed R expressions and returns the value of the expression. All expressions have a value. This is the core of the language.

But it is abstruse to me (particularly the boldtype part) and the subsection do not help me to disentangle this.

Do I have to open a fundamental book on informatics to understand this, or is there another way to understand, technically, what I'm doing 8 hours a day?

Answer 1

This is going to be an incomplete answer, but it seems your question is about the nature of the "internal representation." In essence, R's parser takes arbitrary R code, removes irrelevant stuff (like superfluous whitespace) and creates a nested set of expressions to evaluate. We can use pryr::call_tree() to see what is going on.

Take a simple expression that only uses mathematical operators:

> 1 + 2 - 3 * 4 / 5
[1] 0.6

In that series of operations, an output occurs that respects R's precedence rules. But what is actually happening? First, the parser converts whatever is typed into an "expression":

> parse(text = "1 + 2 - 3 * 4 / 5")
expression(1 + 2 - 3 * 4 / 5)

This expression masks a deeper complexity:

> library("pryr")
> call_tree(parse(text = "1 + 2 - 3 * 4 / 5"))
\- ()
  \- `-
  \- ()
    \- `+
    \-  1
    \-  2
  \- ()
    \- `/
    \- ()
      \- `*
      \-  3
      \-  4
    \-  5

This expression is the sequential evaluation of four functions, first "*"() , then "/"() , then "+"() , then "-"() . Thus, this can actually be rewritten as a deeply nested expression:

> "-"("+"(1,2), "/"("*"(3,4), 5))
[1] 0.6
> call_tree(parse(text = '"-"("+"(1,2), "/"("*"(3,4), 5))'))
\- ()
  \- `-
  \- ()
    \- `+
    \-  1
    \-  2
  \- ()
    \- `/
    \- ()
      \- `*
      \-  3
      \-  4
    \-  5

Multi-line expressions are also parsed into individual expressions:

> parse(text = "1; 2; 3")
expression(1, 2, 3)
> parse(text = "1\n2\n3")
expression(1, 2, 3)
> call_tree(parse(text = "1; 2; 3"))
\-  1

\-  2

\-  3

These call trees are then evaluated.

Thus when R's read-eval-print loop executes, it parses the code typed in the interpreter or sourced from a file into this call tree structure, then sequentially evaluates each function call, and then prints the result unless an error occurs). Errors occur when a parsable line of code cannot be fully evaluated:

> call_tree(parse(text = "2 + 'A'"))
\- ()
  \- `+
  \-  2
  \-  "A"

And a parsing failure occurs when a typable line of code cannot be parsed into a call tree:

> parse(text = "2 + +")
Error in parse(text = "2 + +") : <text>:2:0: unexpected end of input
1: 2 + +
   ^

That's not a complete story, but perhaps it gets you part way to understanding.