galaaz 0.4.9 → 0.4.10

data/blogs/nse_dplyr/nse_dplyr.html

@@ -12,6 +12,7 @@
 <meta name="author" content="Rodrigo Botafogo" />
 <meta name="author" content="Daniel Mossé - University of Pittsburgh" />
 
+<meta name="date" content="2019-10-05" />
 
 <title>Non Standard Evaluation in dplyr with Galaaz</title>
 
@@ -373,18 +374,20 @@ $(document).ready(function () {
 <h1 class="title toc-ignore">Non Standard Evaluation in dplyr with Galaaz</h1>
 <h4 class="author"><em>Rodrigo Botafogo</em></h4>
 <h4 class="author"><em>Daniel Mossé - University of Pittsburgh</em></h4>
-<h4 class="date"><em>20/02/2019</em></h4>
+<h4 class="date"><em>10/05/2019</em></h4>
 
 </div>
 
 
 <div id="introduction" class="section level1">
 <h1>Introduction</h1>
-<p>In this post we will see how to program with dplyr in Galaaz.</p>
-<div id="but-first-what-is-galaaz" class="section level3">
-<h3>But first, what is Galaaz??</h3>
-<p>Galaaz is a system for tightly coupling Ruby and R. Ruby is a powerful language, with a large community, a very large set of libraries and great for web development. However, it lacks libraries for data science, statistics, scientific plotting and machine learning. On the other hand, R is considered one of the most powerful languages for solving all of the above problems. Maybe the strongest competitor to R is Python with libraries such as NumPy, Panda, SciPy, SciKit-Learn and a couple more.</p>
-<p>With Galaaz we do not intend to re-implement any of the scientific libraries in R. However, we allow for very tight coupling between the two languages to the point that the Ruby developer does not need to know that there is an R engine running. For this to happen we use new technologies provided by Oracle: GraalVM, TruffleRuby and FastR:</p>
+<p>In this post we will see how to program with <em>dplyr</em> in Galaaz.</p>
+<div id="but-first-what-is-galaaz" class="section level2">
+<h2>But first, what is Galaaz??</h2>
+<p>Galaaz is a system for tightly coupling Ruby and R. Ruby is a powerful language, with a large community, a very large set of libraries and great for web development. However, it lacks libraries for data science, statistics, scientific plotting and machine learning. On the other hand, R is considered one of the most powerful languages for solving all of the above problems. Maybe the strongest competitor to R is Python with libraries such as NumPy, Pandas, SciPy, SciKit-Learn and many more.</p>
+<p>With Galaaz we do not intend to re-implement any of the scientific libraries in R. However, we allow for very tight coupling between the two languages to the point that the Ruby developer does not need to know that there is an R engine running. Also, from the point of view of the R user/developer Galaaz looks a lot like R, with just minor syntactic difference, so there is almost no learning courve for the R developer. And as we will see in this post, programming with <em>dplyr</em> is easier in Galaaz than in R.</p>
+<p>R users are probably quite knowledgeable about <em>dplyr</em>, for the Ruby developer, <em>dplyr</em> and the <em>tidyverse</em> libraries are a set of libraries for data manipulation in R, developed by Hardley Wickham, chief scientis at RStudio and a prolific R coder and writer.</p>
+<p>For the coupling of Ruby and R we use new technologies provided by Oracle: GraalVM, TruffleRuby and FastR:</p>
 <pre><code> GraalVM is a universal virtual machine for running applications
  written in JavaScript, Python 3, Ruby, R, JVM-based languages like Java,
  Scala, Kotlin, and LLVM-based languages such as C and C++.
@@ -417,16 +420,21 @@ for the task at hand without making compromises.</code></pre>
 <li><a href="https://github.com/oracle/truffleruby">TruffleRuby</a></li>
 <li><a href="https://github.com/oracle/fastr">FastR</a></li>
 <li><a href="https://medium.com/graalvm/faster-r-with-fastr-4b8db0e0dceb">Faster R with FastR</a></li>
+<li><a href="https://medium.freecodecamp.org/how-to-make-beautiful-ruby-plots-with-galaaz-320848058857">How to make Beautiful Ruby Plots with Galaaz</a></li>
+<li><a href="https://towardsdatascience.com/ruby-plotting-with-galaaz-an-example-of-tightly-coupling-ruby-and-r-in-graalvm-520b69e21021">Ruby Plotting with Galaaz: An example of tightly coupling Ruby and R in GraalVM</a></li>
+<li><a href="https://towardsdatascience.com/how-to-do-reproducible-research-in-ruby-with-gknit-c26d2684d64e">How to do reproducible research in Ruby with gKnit</a></li>
+<li><a href="https://r4ds.had.co.nz/">R for Data Science</a></li>
+<li><a href="https://adv-r.hadley.nz/">Advanced R</a></li>
 </ul>
 </div>
-<div id="now-to-programming-with-dplyr" class="section level3">
-<h3>Now to programming with dplyr</h3>
-<p>According to Hardley (<a href="https://dplyr.tidyverse.org/articles/programming.html" class="uri">https://dplyr.tidyverse.org/articles/programming.html</a>)</p>
+<div id="programming-with-dplyr" class="section level2">
+<h2>Programming with dplyr</h2>
+<p>This post will follow closely the work done in <a href="https://dplyr.tidyverse.org/articles/programming.html" class="uri">https://dplyr.tidyverse.org/articles/programming.html</a>, by Hardley Wickham. In it, Hardley states:</p>
 <blockquote>
 <p>Most dplyr functions use non-standard evaluation (NSE). This is a catch-all term that means they don’t follow the usual R rules of evaluation. Instead, they capture the expression that you typed and evaluate it in a custom way. This has two main benefits for dplyr code:</p>
 </blockquote>
 <blockquote>
-<p>Operations on data frames can be expressed succinctly because you don’t need to repeat the name of the data frame. For example, you can write filter(df, x == 1, y == 2, z == 3) instead of df[df<span class="math inline">\(x == 1 &amp; df\)</span>y ==2 &amp; df$z == 3, ].</p>
+<p>Operations on data frames can be expressed succinctly because you don’t need to repeat the name of the data frame. For example, you can write filter(df, x == 1, y == 2, z == 3) instead of df[df$x == 1 &amp; df$y ==2 &amp; df$z == 3, ].</p>
 </blockquote>
 <blockquote>
 <p>dplyr can choose to compute results in a different way to base R. This is important for database backends because dplyr itself doesn’t do any work, but instead generates the SQL that tells the database what to do.</p>
@@ -438,15 +446,8 @@ for the task at hand without making compromises.</code></pre>
 <p>Most dplyr arguments are not referentially transparent. That means you can’t replace a value with a seemingly equivalent object that you’ve defined elsewhere. In other words, this code:</p>
 </blockquote>
 <pre class="r"><code>df &lt;- data.frame(x = 1:3, y = 3:1)
-print(df)</code></pre>
-<pre><code>##   x y
-## 1 1 3
-## 2 2 2
-## 3 3 1</code></pre>
-<pre class="r"><code>print(filter(df, x == 1))</code></pre>
-<pre><code>##   x y
-## 1 1 3</code></pre>
-<pre class="r"><code>#&gt; # A tibble: 1 x 2
+print(filter(df, x == 1))
+#&gt; # A tibble: 1 x 2
 #&gt;       x     y
 #&gt;   &lt;int&gt; &lt;int&gt;
 #&gt; 1     1     3</code></pre>
@@ -460,30 +461,39 @@ filter(df, my_var == 1)
 <blockquote>
 <p>This makes it hard to create functions with arguments that change how dplyr verbs are computed.</p>
 </blockquote>
+<p>In this post we will see that programming with <em>dplyr</em> in Galaaz does not require knowledge of non-standard evaluation in R and can be accomplished by utilizing normal Ruby constructs.</p>
 </div>
 </div>
 <div id="writing-expressions-in-galaaz" class="section level1">
 <h1>Writing Expressions in Galaaz</h1>
-<p>Galaaz extends Ruby to work with complex expressions, similar to R’s expressions build with ‘quote’ (base R) or ‘quo’ (tidyverse). Let’s take a look at some of those expressions.</p>
+<p>Galaaz extends Ruby to work with expressions, similar to R’s expressions build with ‘quote’ (base R) or ‘quo’ (tidyverse). Expressions in this context are like mathematical expressions or formulae. For instance, in mathematics, the expression <span class="math inline">\(y = sin(x)\)</span> describes a function but cannot be computed unless the value of <span class="math inline">\(x\)</span> is bound to some value.</p>
+<p>Let’s take a look at some of those expressions in Ruby:</p>
 <div id="expressions-from-operators" class="section level2">
 <h2>Expressions from operators</h2>
-<p>The code bellow creates an expression summing two symbols</p>
+<p>The code bellow creates an expression summing two symbols. Note that :a and :b are Ruby symbols and are not bound to any value at the time of expression definition:</p>
 <pre class="ruby"><code>exp1 = :a + :b
 puts exp1</code></pre>
 <pre><code>## a + b</code></pre>
-<p>We can build any complex mathematical expression</p>
+<p>We can build any complex mathematical expression such as:</p>
 <pre class="ruby"><code>exp2 = (:a + :b) * 2.0 + :c ** 2 / :z
 puts exp2</code></pre>
 <pre><code>## (a + b) * 2 + c^2L/z</code></pre>
-<p>It is also possible to use inequality operators in building expressions</p>
+<p>The ‘L’ after two indicates that 2 is an integer.</p>
+<p>It is also possible to use inequality operators in building expressions:</p>
 <pre class="ruby"><code>exp3 = (:a + :b) &gt;= :z
 puts exp3</code></pre>
 <pre><code>## a + b &gt;= z</code></pre>
+<p>Expressions’ definition can also make use of normal Ruby variables without any problem:</p>
+<pre class="ruby"><code>x = 20
+y = 30
+exp_var = (:a + :b) * x &lt;= :z - y
+puts exp_var</code></pre>
+<pre><code>## (a + b) * 20L &lt;= z - 30L</code></pre>
 <p>Galaaz provides both symbolic representations for operators, such as (&gt;, &lt;, !=) as functional notation for those operators such as (.gt, .ge, etc.). So the same expression written above can also be written as</p>
 <pre class="ruby"><code>exp4 = (:a + :b).ge :z
 puts exp4</code></pre>
 <pre><code>## a + b &gt;= z</code></pre>
-<p>Two type of expression can only be created with the functional representation of the operators, those are expressions involving ‘==’, and ‘=’. In order to write an expression involving ‘==’ we need to use the method ‘.eq’ and for ‘=’ we need the function ‘.assign’</p>
+<p>Two type of expression, however, can only be created with the functional representation of the operators, those are expressions involving ‘==’, and ‘=’. In order to write an expression involving ‘==’ we need to use the method ‘.eq’ and for ‘=’ we need the function ‘.assign’</p>
 <pre class="ruby"><code>exp5 = (:a + :b).eq :z
 puts exp5</code></pre>
 <pre><code>## a + b == z</code></pre>
@@ -497,43 +507,94 @@ puts exp_wrong</code></pre>
 ##  Error in function (x, y, num.eq = TRUE, single.NA = TRUE, attrib.as.set = TRUE,  :
 ##   object 'a' not found (RError)
 ## Translated to internal error</code></pre>
-<p>and it might be difficult to understand what is going on here. The problem lies with the fact that when using ‘==’ we are comparing expression (:a + :b) to expression :z with ‘==’. When the comparison is executed, the system tries to evaluate :a, :b and :z, and those symbols, at this time are not bound to anything and we get a “object ‘a’ not found” message.<br />
-If we only use functional notation, this type of error will never occur.</p>
+<p>and it might be difficult to understand what is going on here. The problem lies with the fact that when using ‘==’ we are comparing expression (:a + :b) to expression :z with ‘==’. When the comparison is executed, the system tries to evaluate :a, :b and :z, and those symbols at this time are not bound to anything and we get a “object ‘a’ not found” message. If we only use functional notation, this type of error will not occur.</p>
 </div>
 <div id="expressions-with-r-methods" class="section level2">
 <h2>Expressions with R methods</h2>
-<p>It is often necessary to create an expression that uses a method or function. For instance, in mathematics, it’s quite natural to write an expressin such as <span class="math inline">\(y = sin(x)\)</span>. In this case, the ‘sin’ function is part of the expression and should not immediately executed. Now, let’s say that ‘x’ is an angle of 45<span class="math inline">\(^\circ\)</span> and we acttually want our expression to be <span class="math inline">\(y = 0.850...\)</span>. When we want the function to be part of the expression, we call the function preceeding it by the letter E, such as ‘E.sin(x)’</p>
+<p>It is often necessary to create an expression that uses a method or function. For instance, in mathematics, it’s quite natural to write an expressin such as <span class="math inline">\(y = sin(x)\)</span>. In this case, the ‘sin’ function is part of the expression and should not immediately be executed. When we want the function to be part of the expression, we call the function preceeding it by the letter E, such as ‘E.sin(x)’</p>
 <pre class="ruby"><code>exp7 = :y.assign E.sin(:x)
 puts exp7</code></pre>
 <pre><code>## y &lt;- sin(x)</code></pre>
-<p>However, if we want the function to be evaluated, then we use the normal call to function with R as ‘R.sin(x)’.</p>
-<pre class="ruby"><code>x = 45
-exp8 = :y.assign R.sin(x)
+<p>Expressions can also be written using ‘.’ notation:</p>
+<pre class="ruby"><code>exp8 = :y.assign :x.sin
 puts exp8</code></pre>
-<pre><code>## y &lt;- 0.850903524534118</code></pre>
+<pre><code>## y &lt;- sin(x)</code></pre>
+<p>When a function has multiple arguments, the first one can be used before the ‘.’:</p>
+<pre class="ruby"><code>exp9 = :x.c(:y)
+puts exp9</code></pre>
+<pre><code>## c(x, y)</code></pre>
+</div>
+<div id="evaluating-an-expression" class="section level2">
+<h2>Evaluating an Expression</h2>
+<p>Expressions can be evaluated by calling function ‘eval’ with a binding. A binding can be provided with a list:</p>
+<pre class="ruby"><code>exp = (:a + :b) * 2.0 + :c ** 2 / :z
+puts exp.eval(R.list(a: 10, b: 20, c: 30, z: 40))</code></pre>
+<pre><code>## [1] 82.5</code></pre>
+<p>… with a data frame:</p>
+<pre class="ruby"><code>df = R.data__frame(
+  a: R.c(1, 2, 3),
+  b: R.c(10, 20, 30),
+  c: R.c(100, 200, 300),
+  z: R.c(1000, 2000, 3000))
+
+puts exp.eval(df)</code></pre>
+<pre><code>## [1] 32 64 96</code></pre>
 </div>
 </div>
+<div id="using-galaaz-to-call-r-functions" class="section level1">
+<h1>Using Galaaz to call R functions</h1>
+<p>Galaaz tries to emulate as closely as possible the way R functions are called and migrating from R to Galaaz should be quite easy requiring only minor syntactic changes to an R script. In this post, we do not have enough space to write a complete manual on Galaaz (a short manual can be found at: <a href="https://www.rubydoc.info/gems/galaaz/0.4.9" class="uri">https://www.rubydoc.info/gems/galaaz/0.4.9</a>), so we will present only a few examples scripts using Galaaz.</p>
+<p>Basically, to call an R function from Ruby with Galaaz, one only needs to preceed the function with ‘R.’. For instance, to create a vector in R, the ‘c’ function is used. From Galaaz, a vector can be created by using ‘R.c’:</p>
+<pre class="ruby"><code>vec = R.c(1.0, 2, 3)
+puts vec</code></pre>
+<pre><code>## [1] 1 2 3</code></pre>
+<p>A list is created in R with the ‘list’ function, so in Galaaz we do:</p>
+<pre class="ruby"><code>list = R.list(a: 1.0, b: 2, c: 3)
+puts list</code></pre>
+<pre><code>## $a
+## [1] 1
+## 
+## $b
+## [1] 2
+## 
+## $c
+## [1] 3</code></pre>
+<p>Note that we can use named arguments in our list. The same code in R would be:</p>
+<pre class="r"><code>lst = list(a = 1, b = 2L, c = 3L)
+print(lst)</code></pre>
+<pre><code>## $a
+## [1] 1
+## 
+## $b
+## [1] 2
+## 
+## $c
+## [1] 3</code></pre>
+<p>Now, let’s say that ‘x’ is an angle of 45<span class="math inline">\(^\circ\)</span> and we acttually want to create the expression <span class="math inline">\(y = sin(45^\circ)\)</span>, which is <span class="math inline">\(y = 0.850...\)</span>. In this case, we will use ‘R.sin’:</p>
+<pre class="ruby"><code>exp10 = :y.assign R.sin(45)
+puts exp10</code></pre>
+<pre><code>## y &lt;- 0.850903524534118</code></pre>
+</div>
 <div id="filtering-using-expressions" class="section level1">
 <h1>Filtering using expressions</h1>
-<p>Now that we now how to write expression, we can use then to filter a data frame by expressions.<br />
-Let’s first start by creating a simple data frame with two columns named ‘x’ and ‘y’</p>
-<pre class="ruby"><code>@df = R.data__frame(x: (1..3), y: (3..1))
-puts @df</code></pre>
+<p>Now that we know how to write expression and call R functions let’s do some data manipulation in Galaaz. Let’s first start by creating the same data frame that we created previously in section “Programming with dplyr”:</p>
+<pre class="ruby"><code>df = R.data__frame(x: (1..3), y: (3..1))
+puts df</code></pre>
 <pre><code>##   x y
 ## 1 1 3
 ## 2 2 2
 ## 3 3 1</code></pre>
-<p>In the code bellow we want to filter the data frame by rows in which the value of ‘x’ is equal to 1.</p>
-<pre class="ruby"><code>puts @df.filter(:x.eq 1)</code></pre>
+<p>The ‘filter’ function can be called on this data frame either by using ‘R.filter(df, …)’ or by using dot notation. We prefer to use dot notation as shown bellow. The argument to ‘filter’ in Galaaz should be an expression. Note that if we gave to filter a Ruby expression such as ‘x == 1’, we would get an error, since there is no variable ‘x’ defined and if ‘x’ was a variable then ‘x == 1’ would either be ‘true’ or ‘false’. Our goal is to filter our data frame returning all rows in which the ‘x’ value is equal to 1. To express this we want: ‘:x.eq 1’, where :x will be interpreted by filter as the ‘x’ column.</p>
+<pre class="ruby"><code>puts df.filter(:x.eq 1)</code></pre>
 <pre><code>##   x y
 ## 1 1 3</code></pre>
-<p>In R, and when coding with ‘tidyverse’, arguments to a function are usually not <em>referencially transparent</em>. That is, ou can’t replace a value with a seemingly equivalent object that you’ve defined elsewhere. In other words, this code</p>
+<p>In R, and when coding with ‘tidyverse’, arguments to a function are usually not <em>referencially transparent</em>. That is, you can’t replace a value with a seemingly equivalent object that you’ve defined elsewhere. In other words, this code</p>
 <pre class="r"><code>my_var &lt;- x
 filter(df, my_var == 1)</code></pre>
 <p>Generates the following error: &quot;object ‘x’ not found.</p>
-<p>However, in Ruby and Galaaz, arguments are referencially transparent as can be seen by the code bellow. Note, initally that ‘my_var = :x’ will not give the error “object ‘x’ not found” since ‘:x’ is treated as an expression and assigned to my_var. Then when doing (my_var.eq 1), my_var is a variable that resolves to ‘:x’ and it becomes equivalent to (:x.eq 1) which is what we want.</p>
+<p>However, in Galaaz, arguments are referencially transparent as can be seen by the code bellow. Note initally that ‘my_var = :x’ will not give the error “object ‘x’ not found” since ‘:x’ is treated as an expression and assigned to my_var. Then when doing (my_var.eq 1), my_var is a variable that resolves to ‘:x’ and it becomes equivalent to (:x.eq 1) which is what we want.</p>
 <pre class="ruby"><code>my_var = :x
-puts @df.filter(my_var.eq 1)</code></pre>
+puts df.filter(my_var.eq 1)</code></pre>
 <pre><code>##   x y
 ## 1 1 3</code></pre>
 <p>As stated by Hardley</p>
@@ -544,34 +605,46 @@ puts @df.filter(my_var.eq 1)</code></pre>
 df[df$x == y, ]
 df[x == df$y, ]
 df[x == y, ]</code></pre>
-<p>In galaaz this ambiguity does not exist, filter(df, x.eq y) is not a valid expression as expressions are build with symbols. In doing filter(df, :x.eq y) we are looking for elements of the ‘x’ column that are equal to a previously defined y variable. Finally, filter(df, :x.eq :y) we are looking for elements in which the ‘x’ column value is equal to the ‘y’ column value. This can be seen in the following two chunks of code:</p>
-<pre class="ruby"><code>@y = 1
-@x = 2
+<p>In galaaz this ambiguity does not exist, filter(df, x.eq y) is not a valid expression as expressions are build with symbols. In doing filter(df, :x.eq y) we are looking for elements of the ‘x’ column that are equal to a previously defined y variable. Finally in filter(df, :x.eq :y) we are looking for elements in which the ‘x’ column value is equal to the ‘y’ column value. This can be seen in the following two chunks of code:</p>
+<pre class="ruby"><code>y = 1
+x = 2
 
 # looking for values where the 'x' column is equal to the 'y' column
-puts @df.filter(:x.eq :y)</code></pre>
+puts df.filter(:x.eq :y)</code></pre>
 <pre><code>##   x y
 ## 1 2 2</code></pre>
 <pre class="ruby"><code># looking for values where the 'x' column is equal to the 'y' variable
 # in this case, the number 1
-puts @df.filter(:x.eq @y)</code></pre>
+puts df.filter(:x.eq y)</code></pre>
 <pre><code>##   x y
 ## 1 1 3</code></pre>
 </div>
 <div id="writing-a-function-that-applies-to-different-data-sets" class="section level1">
 <h1>Writing a function that applies to different data sets</h1>
+<p>Let’s suppose that we want to write a function that receives as the first argument a data frame and as second argument an expression that adds a column to the data frame that is equal to the sum of elements in column ‘a’ plus ‘x’.</p>
+<p>Here is the intended behaviour using the ‘mutate’ function of ‘dplyr’:</p>
 <pre><code>mutate(df1, y = a + x)
 mutate(df2, y = a + x)
 mutate(df3, y = a + x)
 mutate(df4, y = a + x)</code></pre>
-<p>Here we create a mutate_y Ruby method.</p>
+<p>The naive approach to writing an R function to solve this problem is:</p>
+<pre><code>mutate_y &lt;- function(df) {
+  mutate(df, y = a + x)
+}</code></pre>
+<p>Unfortunately, in R, this function can fail silently if one of the variables isn’t present in the data frame, but is present in the global environment. We will not go through here how to solve this problem in R.</p>
+<p>In Galaaz the method mutate_y bellow will work fine and will never fail silently.</p>
 <pre class="ruby"><code>def mutate_y(df)
   df.mutate(:y.assign :a + :x)
 end</code></pre>
-<p>Note that contrary to what happens in R, method mutate_y will fail independetly from the fact that variable ‘a’ is defined or not.</p>
+<p>Here we create a data frame that has only one column named ‘x’:</p>
 <pre class="ruby"><code>df1 = R.data__frame(x: (1..3))
-puts df1
-a = 10
+puts df1</code></pre>
+<pre><code>##   x
+## 1 1
+## 2 2
+## 3 3</code></pre>
+<p>Note that method mutate_y will fail independetly from the fact that variable ‘a’ is defined and in the scope of the method. Variable ‘a’ has no relationship with the symbol ‘:a’ used in the definition of ‘mutate_y’ above:</p>
+<pre class="ruby"><code>a = 10
 mutate_y(df1)</code></pre>
 <pre><code>## Message:
 ##  Error in mutate_impl(.data, dots) :
@@ -583,14 +656,24 @@ mutate_y(df1)</code></pre>
 </div>
 <div id="different-expressions" class="section level1">
 <h1>Different expressions</h1>
-<pre class="r"><code>df &lt;- data.frame(
+<p>Let’s move to the next problem as presented by Hardley where trying to write a function in R that will receive two argumens, the first a variable and the second an expression is not trivial. Bellow we create a data frame and we want to write a function that groups data by a variable and summarises it by an expression:</p>
+<pre class="r"><code>set.seed(123)
+
+df &lt;- data.frame(
   g1 = c(1, 1, 2, 2, 2),
   g2 = c(1, 2, 1, 2, 1),
   a = sample(5),
   b = sample(5)
 )
 
-d2 &lt;- df %&gt;%
+as.data.frame(df) </code></pre>
+<pre><code>##   g1 g2 a b
+## 1  1  1 2 1
+## 2  1  2 4 3
+## 3  2  1 5 4
+## 4  2  2 3 2
+## 5  2  1 1 5</code></pre>
+<pre class="r"><code>d2 &lt;- df %&gt;%
   group_by(g1) %&gt;%
   summarise(a = mean(a))
            
@@ -604,9 +687,9 @@ as.data.frame(d2)          </code></pre>
            
 as.data.frame(d2)          </code></pre>
 <pre><code>##   g2        a
-## 1  1 3.666667
-## 2  2 2.000000</code></pre>
-<p>Trying to write a function in R that will receive two argumens, the first a variable and the second an expression is not trivia. As shown by Hardley, one might expect this function to do the trick:</p>
+## 1  1 2.666667
+## 2  2 3.500000</code></pre>
+<p>As shown by Hardley, one might expect this function to do the trick:</p>
 <pre class="r"><code>my_summarise &lt;- function(df, group_var) {
   df %&gt;%
     group_by(group_var) %&gt;%
@@ -615,37 +698,37 @@ as.data.frame(d2)          </code></pre>
 
 # my_summarise(df, g1)
 #&gt; Error: Column `group_var` is unknown</code></pre>
-<p>In order to solve this problem, coding with dplyr requires the introduction of many new concepts and functions such as ‘quo’, ‘quos’, ‘enquo’, ‘enquos’, ‘!!’ (bang bang), ‘!!!’ (triple bang).</p>
-<p>Now, let’s try to implement the same function in galaaz. The next code block first prints the ‘df’ data frame define previously in R, then creates the my_summarize function and calls it passing the R data frame and the group by variable ‘:g1’</p>
+<p>In order to solve this problem, coding with dplyr requires the introduction of many new concepts and functions such as ‘quo’, ‘quos’, ‘enquo’, ‘enquos’, ‘!!’ (bang bang), ‘!!!’ (triple bang). Again, we’ll leave to Hardley the explanation on how to use all those functions.</p>
+<p>Now, let’s try to implement the same function in galaaz. The next code block first prints the ‘df’ data frame define previously in R (to access an R variable from Galaaz, we use the tilda operator ‘~’ applied to the R variable name as symbol, i.e., ‘:df’. We then create the ‘my_summarize’ method and call it passing the R data frame and the group by variable ‘:g1’:</p>
 <pre class="ruby"><code>puts ~:df
 print &quot;\n&quot;
 
 def my_summarize(df, group_var)
   df.group_by(group_var).
-    summarize(a: E.mean(:a))
+    summarize(a: :a.mean)
 end
 
-puts my_summarize((~:df), :g1).as__data__frame</code></pre>
+puts my_summarize(:df, :g1).as__data__frame</code></pre>
 <pre><code>##   g1 g2 a b
-## 1  1  1 5 2
-## 2  1  2 1 5
-## 3  2  1 2 4
-## 4  2  2 3 1
-## 5  2  1 4 3
+## 1  1  1 2 1
+## 2  1  2 4 3
+## 3  2  1 5 4
+## 4  2  2 3 2
+## 5  2  1 1 5
 ## 
 ##   g1 a
 ## 1  1 3
 ## 2  2 3</code></pre>
-<p>It works!!! Well let’s make sure this was not just some coincidence</p>
-<pre class="ruby"><code>puts my_summarize((~:df), :g2).as__data__frame</code></pre>
+<p>It works!!! Well, let’s make sure this was not just some coincidence</p>
+<pre class="ruby"><code>puts my_summarize(:df, :g2).as__data__frame</code></pre>
 <pre><code>##   g2        a
-## 1  1 3.666667
-## 2  2 2.000000</code></pre>
+## 1  1 2.666667
+## 2  2 3.500000</code></pre>
 <p>Great, everything is fine! No magic, no new functions, no complexities, just normal, standard Ruby code. If you’ve ever done NSE in R, this certainly feels much safer and easy to implement.</p>
 </div>
 <div id="different-input-variables" class="section level1">
 <h1>Different input variables</h1>
-<p>In the previous section we’ve managed to get rid of all NSE formulation for a simple example, but does this remain true for more complex examples, or will the Ruby way prove inpractical for more complex code?</p>
+<p>In the previous section we’ve managed to get rid of all NSE formulation for a simple example, but does this remain true for more complex examples, or will the Galaaz way prove inpractical for more complex code?</p>
 <p>In the next example Hardley proposes us to write a function that given an expression such as ‘a’ or ‘a * b’, calculates three summaries. What we want a function that does the same as these R statements:</p>
 <pre><code>summarise(df, mean = mean(a), sum = sum(a), n = n())
 #&gt; # A tibble: 1 x 3
@@ -657,7 +740,7 @@ summarise(df, mean = mean(a * b), sum = sum(a * b), n = n())
 #&gt; # A tibble: 1 x 3
 #&gt;    mean   sum     n
 #&gt;   &lt;dbl&gt; &lt;int&gt; &lt;int&gt;
-#&gt; 1   9.6    48     5</code></pre>
+#&gt; 1   9    45     5</code></pre>
 <p>Let’s try it in galaaz:</p>
 <pre class="ruby"><code>def my_summarise2(df, expr)
   df.summarize(
@@ -672,8 +755,8 @@ puts my_summarise2((~:df), :a * :b)</code></pre>
 <pre><code>##   mean sum n
 ## 1    3  15 5
 ##   mean sum n
-## 1  7.6  38 5</code></pre>
-<p>Once again, there is no need to use any special theory or functions. The only point to be careful about is the use of ‘E’ to build an expression that uses the mean, sum and n.</p>
+## 1    9  45 5</code></pre>
+<p>Once again, there is no need to use any special theory or functions. The only point to be careful about is the use of ‘E’ to build expressions from functions ‘mean’, ‘sum’ and ‘n’.</p>
 </div>
 <div id="different-input-and-output-variable" class="section level1">
 <h1>Different input and output variable</h1>
@@ -697,7 +780,8 @@ mutate(df, mean_b = mean(b), sum_b = sum(b))
 #&gt; 3     2     1     2     1      3    15
 #&gt; 4     2     2     5     4      3    15
 #&gt; # … with 1 more row</code></pre>
-<p>Here is our Ruby code</p>
+<p>In order to solve this problem in R, Hardley needs to introduce some more new functions and notations: ‘quo_name’ and the ‘:=’ operator from package ‘rlang’</p>
+<p>Here is our Ruby code:</p>
 <pre class="ruby"><code>def my_mutate(df, expr)
   mean_name = &quot;mean_#{expr.to_s}&quot;
   sum_name = &quot;sum_#{expr.to_s}&quot;
@@ -709,22 +793,24 @@ end
 puts my_mutate((~:df), :a)
 puts my_mutate((~:df), :b)</code></pre>
 <pre><code>##   g1 g2 a b mean_a sum_a
-## 1  1  1 5 2      3    15
-## 2  1  2 1 5      3    15
-## 3  2  1 2 4      3    15
-## 4  2  2 3 1      3    15
-## 5  2  1 4 3      3    15
+## 1  1  1 2 1      3    15
+## 2  1  2 4 3      3    15
+## 3  2  1 5 4      3    15
+## 4  2  2 3 2      3    15
+## 5  2  1 1 5      3    15
 ##   g1 g2 a b mean_b sum_b
-## 1  1  1 5 2      3    15
-## 2  1  2 1 5      3    15
-## 3  2  1 2 4      3    15
-## 4  2  2 3 1      3    15
-## 5  2  1 4 3      3    15</code></pre>
+## 1  1  1 2 1      3    15
+## 2  1  2 4 3      3    15
+## 3  2  1 5 4      3    15
+## 4  2  2 3 2      3    15
+## 5  2  1 1 5      3    15</code></pre>
 <p>It really seems that “Non Standard Evaluation” is actually quite standard in Galaaz! But, you might have noticed a small change in the way the arguments to the mutate method were called. In a previous example we used df.summarise(mean: E.mean(:a), …) where the column name was followed by a ‘:’ colom. In this example, we have df.mutate(mean_name =&gt; E.mean(expr), …) and variable mean_name is not followed by ‘:’ but by ‘=&gt;’. This is standard Ruby notation.</p>
 <p>[explain….]</p>
 </div>
 <div id="capturing-multiple-variables" class="section level1">
 <h1>Capturing multiple variables</h1>
+<p>Moving on with new complexities, Hardley proposes us to solve the problem in which the summarise function will receive any number of grouping variables.</p>
+<p>This again is quite standard Ruby. In order to receive an undefined number of paramenters the paramenter is preceded by ’*’:</p>
 <pre class="ruby"><code>def my_summarise3(df, *group_vars)
   df.group_by(*group_vars).
     summarise(a: E.mean(:a))
@@ -732,14 +818,26 @@ end
 
 puts my_summarise3((~:df), :g1, :g2).as__data__frame</code></pre>
 <pre><code>##   g1 g2 a
-## 1  1  1 5
-## 2  1  2 1
+## 1  1  1 2
+## 2  1  2 4
 ## 3  2  1 3
 ## 4  2  2 3</code></pre>
 </div>
+<div id="why-does-r-require-nse-and-galaaz-does-not" class="section level1">
+<h1>Why does R require NSE and Galaaz does not?</h1>
+<p>NSE introduces a number of new concepts, such as ‘quoting’, ‘quasiquotation’, ‘unquoting’ and ‘unquote-splicing’, while in Galaaz none of those concepts are needed. What gives?</p>
+<p>R is an extremely flexible language and it has lazy evaluation of parameters. When in R a function is called as ‘summarise(df, a = b)’, the summarise function receives the litteral ‘a = b’ parameter and can work with this as if it were a string. In R, it is not clear what a and b are, they can be expressions or they can be variables, it is up to the function to decide what ‘a = b’ means.</p>
+<p>In Ruby, there is no lazy evaluation of parameters and ‘a’ is always a variable and so is ‘b’. Variables assume their value as soon as they are used, so ‘x = a’ is immediately evaluate and variable ‘x’ will receive the value of variable ‘a’ as soon as the Ruby statement is executed. Ruby also provides the notion of a symbol; ‘:a’ is a symbol and does not evaluate to anything. Galaaz uses Ruby symbols to build expressions that are not bound to anything: ‘:a.eq :b’ is clearly an expression and has no relationship whatsoever with the statment ‘a = b’. By using symbols, variables and expressions all the possible ambiguities that are found in R are eliminated in Galaaz.</p>
+<p>The main problem that remains, is that in R, functions are not clearly documented as what type of input they are expecting, they might be expecting regular variables or they might be expecting expressions and the R function will know how to deal with an input of the form ‘a = b’, now for the Ruby developer it might not be immediately clear if it should call the function passing the value ‘true’ if variable ‘a’ is equal to variable ‘b’ or if it should call the function passing the expression ‘:a.eq :b’.</p>
+</div>
 <div id="advanced-dplyr-features" class="section level1">
 <h1>Advanced dplyr features</h1>
-<p><a href="https://www.r-bloggers.com/programming-with-dplyr-by-using-dplyr/" class="uri">https://www.r-bloggers.com/programming-with-dplyr-by-using-dplyr/</a></p>
+<p>In the blog: Programming with dplyr by using dplyr (<a href="https://www.r-bloggers.com/programming-with-dplyr-by-using-dplyr/" class="uri">https://www.r-bloggers.com/programming-with-dplyr-by-using-dplyr/</a>) Iñaki Úcar shows surprise that some R users are trying to code in dplyr avoiding the use of NSE. For instance he says:</p>
+<blockquote>
+<p>Take the example of seplyr. It stands for standard evaluation dplyr, and enables us to program over dplyr without having “to bring in (or study) any deep-theory or heavy-weight tools such as rlang/tidyeval”.</p>
+</blockquote>
+<p>For me, there isn’t really any surprise that users are trying to avoid dplyr deep-theory. R users frequently are not programmers and learning to code is already hard business, on top of that, having to learn how to ‘quote’ or ‘enquo’ or ‘quos’ or ‘enquos’ is not necessarily a ‘piece of cake’. So much so, that ‘tidyeval’ has some more advanced functions that instead of using quoted expressions, uses strings as arguments.</p>
+<p>In the following examples, we show the use of functions ‘group_by_at’, ‘summarise_at’ and ‘rename_at’ that receive strings as argument. The data frame used in ‘starwars’ that describes features of characters in the Starwars movies:</p>
 <pre class="ruby"><code>puts (~:starwars).head.as__data__frame</code></pre>
 <pre><code>##             name height mass  hair_color  skin_color eye_color birth_year
 ## 1 Luke Skywalker    172   77       blond        fair      blue       19.0
@@ -769,6 +867,7 @@ puts my_summarise3((~:df), :g1, :g2).as__data__frame</code></pre>
 ## 4                                             TIE Advanced x1
 ## 5              Imperial Speeder Bike                         
 ## 6</code></pre>
+<p>The grouped_mean function bellow will receive a grouping variable and calculate summaries for the value_variables given:</p>
 <pre class="r"><code>grouped_mean &lt;- function(data, grouping_variables, value_variables) {
   data %&gt;%
     group_by_at(grouping_variables) %&gt;%
@@ -797,15 +896,16 @@ as.data.frame(gm)   </code></pre>
 ## 13       unknown  31.50000             NaN     3
 ## 14         white  48.00000             NaN     1
 ## 15        yellow  81.11111        76.38000    11</code></pre>
+<p>The same code with Galaaz, becomes:</p>
 <pre class="ruby"><code>def grouped_mean(data, grouping_variables, value_variables)
   data.
     group_by_at(grouping_variables).
     mutate(count: E.n).
     summarise_at(E.c(value_variables, &quot;count&quot;), ~:mean, na__rm: true).
-    rename_at(value_variables, R.funs(E.paste0(&quot;mean_&quot;, value_variables)))
+    rename_at(value_variables, E.funs(E.paste0(&quot;mean_&quot;, value_variables)))
 end
 
-puts grouped_mean((~:starwars), &quot;eye_color&quot;, R.c(&quot;mass&quot;, &quot;birth_year&quot;)).as__data__frame</code></pre>
+puts grouped_mean((~:starwars), &quot;eye_color&quot;, E.c(&quot;mass&quot;, &quot;birth_year&quot;)).as__data__frame</code></pre>
 <pre><code>##        eye_color mean_mass mean_birth_year count
 ## 1          black  76.28571        33.00000    10
 ## 2           blue  86.51667        67.06923    19
@@ -823,6 +923,10 @@ puts grouped_mean((~:starwars), &quot;eye_color&quot;, R.c(&quot;mass&quot;, &qu
 ## 14         white  48.00000             NaN     1
 ## 15        yellow  81.11111        76.38000    11</code></pre>
 </div>
+<div id="conclusion" class="section level1">
+<h1>Conclusion</h1>
+<p>Ruby and Galaaz provide a nice framework for developing code that uses R functions. Although R is a very powerful and flexible language, sometimes, too much flexibility makes life harder for the casual user. We believe however, that even for the advanced user, Ruby integrated with R throught Galaaz, makes a powerful environment for data analysis. In this blog post we showed how Galaaz consistent syntax eliminates the need for complex constructs such as quoting, enquoting, quasiquotation, etc. This simplification comes from the fact that expressions and variables are clearly separated objects, which is not the case in the R language.</p>
+</div>