900_not function

NSE_project/17_04_call2.qmd

@@ -23,7 +23,14 @@ f <- function(...) sum(...)
 
 # create call, no evaluation (whether f, g exist or not)
 call2("f", 1, 2, 3) # f(1, 2, 3)
-call2("g", 1, 2, 3) # f(1, 2, 3)
+call2("g", 1, 2, 3) # g(1, 2, 3)
+call2("g", 1, 2 + 10, 3) # g(1, 12, 3)
+
+## evaluates arguments, not function itself
+x=-1
+call2("g", 1, 2 + 10, 3 + x) # g(1, 12, 22)
+call2("g", x, 2+x, 3+x) # g(-1, 1, 2)
+rm(x)
 
 lobstr::ast(call2("f", 1, 2, 3))
 # █─call2
@@ -41,6 +48,9 @@ if (FALSE) call2("f", 1, 2, 3, x)
 
 # but ast freezes (stops substitution here)
 ast(call2("f", 1, 2, 3, x))
+
+
+# 
 ```
 
 
@@ -53,6 +63,8 @@ ast(call2("+", 1, call2("*", 2, 3)))
 ast(call2("mean", x, na.rm = TRUE))
 ```
 
+
+
 ## Create template, or way to create more complicated functions from simpler
 ```{r}
 cv <- function(var) {

NSE_project/500_cheat.qmd

@@ -3,8 +3,6 @@ title: cheat
 editor_options: 
   chunk_output_type: console
 ---
-
-
 ```{r}
 library(rlang)
 

NSE_project/900_not_function.md

@@ -0,0 +1,92 @@
+# not function
+
+
+Operator Precedence came up in today’s discussion of this code from
+Advanced R 18.4.1 <a
+href="https://adv-r.hadley.nz/expressions.html?q=%in%#operator-precedence"
+class="uri">https://adv-r.hadley.nz/expressions.html?q=%in%#operator-precedence</a>
+
+``` r
+knitr::opts_chunk$set(echo = TRUE,  
+                      comment="      ##", 
+                      collapse=TRUE)
+
+lobstr::ast(!x %in% y)
+```
+
+    █─`!` 
+    └─█─`%in%` 
+      ├─x 
+      └─y 
+
+The reason this works, if I followed the discussion correctly, is due to
+“operator precedence”, %in% is evaluated before !
+
+SEE <https://rdrr.io/r/base/Syntax.html>
+
+I want to suggest another way to see this.
+
+`!` is a function and, of course, functions take arguments, in this case
+exactly one argument. **If you mentally parse functions as lists, the
+function is first, followed by arguments.** lobstr::ast shows this.
+
+If you remember `!` is a function, then it’s argument must be what
+remains: x %in% y.
+
+# Background !not function
+
+``` r
+library(lobstr)
+
+## usage examples
+x = TRUE
+!x
+      ## [1] FALSE
+! x    # spacing not important
+      ## [1] FALSE
+
+`!` (x)
+      ## [1] FALSE
+`!`(x)
+      ## [1] FALSE
+
+## class
+`!` |> class()   # function
+      ## [1] "function"
+
+## structure
+lobstr::ast(!x)
+      ## █─`!` 
+      ## └─x
+
+## source code
+`!`
+      ## function (x)  .Primitive("!")
+
+#error
+# `!` x
+
+```
+
+``` r
+
+## first argument, as string
+## 2nd arugment as expression (otherwise, call will try to evaluate this argument)
+call("!", quote(x %in% y))
+      ## !x %in% y
+
+call("`!`", quote(x %in% y))
+      ## `\`!\``(x %in% y)
+call("`!`", "x %in% y")
+      ## `\`!\``("x %in% y")
+
+
+rlang::call2(`!`, quote(x))
+      ## .Primitive("!")(x)
+```
+
+``` r
+lobstr::ast(! x)
+      ## █─`!` 
+      ## └─x
+```

NSE_project/900_not_function.qmd

@@ -0,0 +1,68 @@
+---
+title: "not function"
+format: html
+---
+
+Operator Precedence came up in today's discussion of this code from Advanced R 18.4.1 [https://adv-r.hadley.nz/expressions.html?q=%in%#operator-precedence](https://adv-r.hadley.nz/expressions.html?q=%in%#operator-precedence){.uri}
+
+```{r}
+knitr::opts_chunk$set(echo = TRUE,  
+                      comment="      ##", 
+                      collapse=TRUE)
+
+lobstr::ast(!x %in% y)
+```
+
+The reason this works, if I followed the discussion correctly, is due to "operator precedence", %in% is evaluated before !
+
+SEE <https://rdrr.io/r/base/Syntax.html>
+
+I want to suggest another way to see this.
+
+`!` is a function and, of course, functions take arguments, in this case exactly one argument. **If you mentally parse functions as lists,  the function is first, followed by arguments.** lobstr::ast shows this.
+
+If you remember `!` is a function, then it's argument must be what remains: x %in% y.
+
+# Background !not function
+
+```{r two}
+library(lobstr)
+
+## usage examples
+x = TRUE
+!x
+! x    # spacing not important
+
+`!` (x)
+`!`(x)
+
+## class
+`!` |> class()   # function
+
+## structure
+lobstr::ast(!x)
+
+## source code
+`!`
+
+#error
+# `!` x
+ 
+```
+
+```{r call}
+
+## first argument, as string
+## 2nd arugment as expression (otherwise, call will try to evaluate this argument)
+call("!", quote(x %in% y))
+
+call("`!`", quote(x %in% y))
+call("`!`", "x %in% y")
+
+
+rlang::call2(`!`, quote(x))
+```
+
+```{r}
+lobstr::ast(! x)
+```