galaaz 0.4.9 → 0.4.10

data/blogs/nse_dplyr/nse_dplyr.tex

@@ -0,0 +1,1373 @@
+\documentclass[11pt,]{article}
+\usepackage{lmodern}
+\usepackage{amssymb,amsmath}
+\usepackage{ifxetex,ifluatex}
+\usepackage{fixltx2e} % provides \textsubscript
+\ifnum 0\ifxetex 1\fi\ifluatex 1\fi=0 % if pdftex
+  \usepackage[T1]{fontenc}
+  \usepackage[utf8]{inputenc}
+\else % if luatex or xelatex
+  \ifxetex
+    \usepackage{mathspec}
+  \else
+    \usepackage{fontspec}
+  \fi
+  \defaultfontfeatures{Ligatures=TeX,Scale=MatchLowercase}
+\fi
+% use upquote if available, for straight quotes in verbatim environments
+\IfFileExists{upquote.sty}{\usepackage{upquote}}{}
+% use microtype if available
+\IfFileExists{microtype.sty}{%
+\usepackage{microtype}
+\UseMicrotypeSet[protrusion]{basicmath} % disable protrusion for tt fonts
+}{}
+\usepackage[margin=1in]{geometry}
+\usepackage{hyperref}
+\hypersetup{unicode=true,
+            pdftitle={Non Standard Evaluation in dplyr with Galaaz},
+            pdfauthor={Rodrigo Botafogo; Daniel Mossé - University of Pittsburgh},
+            pdfborder={0 0 0},
+            breaklinks=true}
+\urlstyle{same}  % don't use monospace font for urls
+\usepackage{color}
+\usepackage{fancyvrb}
+\newcommand{\VerbBar}{|}
+\newcommand{\VERB}{\Verb[commandchars=\\\{\}]}
+\DefineVerbatimEnvironment{Highlighting}{Verbatim}{commandchars=\\\{\}}
+% Add ',fontsize=\small' for more characters per line
+\usepackage{framed}
+\definecolor{shadecolor}{RGB}{248,248,248}
+\newenvironment{Shaded}{\begin{snugshade}}{\end{snugshade}}
+\newcommand{\AlertTok}[1]{\textcolor[rgb]{0.94,0.16,0.16}{#1}}
+\newcommand{\AnnotationTok}[1]{\textcolor[rgb]{0.56,0.35,0.01}{\textbf{\textit{#1}}}}
+\newcommand{\AttributeTok}[1]{\textcolor[rgb]{0.77,0.63,0.00}{#1}}
+\newcommand{\BaseNTok}[1]{\textcolor[rgb]{0.00,0.00,0.81}{#1}}
+\newcommand{\BuiltInTok}[1]{#1}
+\newcommand{\CharTok}[1]{\textcolor[rgb]{0.31,0.60,0.02}{#1}}
+\newcommand{\CommentTok}[1]{\textcolor[rgb]{0.56,0.35,0.01}{\textit{#1}}}
+\newcommand{\CommentVarTok}[1]{\textcolor[rgb]{0.56,0.35,0.01}{\textbf{\textit{#1}}}}
+\newcommand{\ConstantTok}[1]{\textcolor[rgb]{0.00,0.00,0.00}{#1}}
+\newcommand{\ControlFlowTok}[1]{\textcolor[rgb]{0.13,0.29,0.53}{\textbf{#1}}}
+\newcommand{\DataTypeTok}[1]{\textcolor[rgb]{0.13,0.29,0.53}{#1}}
+\newcommand{\DecValTok}[1]{\textcolor[rgb]{0.00,0.00,0.81}{#1}}
+\newcommand{\DocumentationTok}[1]{\textcolor[rgb]{0.56,0.35,0.01}{\textbf{\textit{#1}}}}
+\newcommand{\ErrorTok}[1]{\textcolor[rgb]{0.64,0.00,0.00}{\textbf{#1}}}
+\newcommand{\ExtensionTok}[1]{#1}
+\newcommand{\FloatTok}[1]{\textcolor[rgb]{0.00,0.00,0.81}{#1}}
+\newcommand{\FunctionTok}[1]{\textcolor[rgb]{0.00,0.00,0.00}{#1}}
+\newcommand{\ImportTok}[1]{#1}
+\newcommand{\InformationTok}[1]{\textcolor[rgb]{0.56,0.35,0.01}{\textbf{\textit{#1}}}}
+\newcommand{\KeywordTok}[1]{\textcolor[rgb]{0.13,0.29,0.53}{\textbf{#1}}}
+\newcommand{\NormalTok}[1]{#1}
+\newcommand{\OperatorTok}[1]{\textcolor[rgb]{0.81,0.36,0.00}{\textbf{#1}}}
+\newcommand{\OtherTok}[1]{\textcolor[rgb]{0.56,0.35,0.01}{#1}}
+\newcommand{\PreprocessorTok}[1]{\textcolor[rgb]{0.56,0.35,0.01}{\textit{#1}}}
+\newcommand{\RegionMarkerTok}[1]{#1}
+\newcommand{\SpecialCharTok}[1]{\textcolor[rgb]{0.00,0.00,0.00}{#1}}
+\newcommand{\SpecialStringTok}[1]{\textcolor[rgb]{0.31,0.60,0.02}{#1}}
+\newcommand{\StringTok}[1]{\textcolor[rgb]{0.31,0.60,0.02}{#1}}
+\newcommand{\VariableTok}[1]{\textcolor[rgb]{0.00,0.00,0.00}{#1}}
+\newcommand{\VerbatimStringTok}[1]{\textcolor[rgb]{0.31,0.60,0.02}{#1}}
+\newcommand{\WarningTok}[1]{\textcolor[rgb]{0.56,0.35,0.01}{\textbf{\textit{#1}}}}
+\usepackage{graphicx,grffile}
+\makeatletter
+\def\maxwidth{\ifdim\Gin@nat@width>\linewidth\linewidth\else\Gin@nat@width\fi}
+\def\maxheight{\ifdim\Gin@nat@height>\textheight\textheight\else\Gin@nat@height\fi}
+\makeatother
+% Scale images if necessary, so that they will not overflow the page
+% margins by default, and it is still possible to overwrite the defaults
+% using explicit options in \includegraphics[width, height, ...]{}
+\setkeys{Gin}{width=\maxwidth,height=\maxheight,keepaspectratio}
+\IfFileExists{parskip.sty}{%
+\usepackage{parskip}
+}{% else
+\setlength{\parindent}{0pt}
+\setlength{\parskip}{6pt plus 2pt minus 1pt}
+}
+\setlength{\emergencystretch}{3em}  % prevent overfull lines
+\providecommand{\tightlist}{%
+  \setlength{\itemsep}{0pt}\setlength{\parskip}{0pt}}
+\setcounter{secnumdepth}{5}
+% Redefines (sub)paragraphs to behave more like sections
+\ifx\paragraph\undefined\else
+\let\oldparagraph\paragraph
+\renewcommand{\paragraph}[1]{\oldparagraph{#1}\mbox{}}
+\fi
+\ifx\subparagraph\undefined\else
+\let\oldsubparagraph\subparagraph
+\renewcommand{\subparagraph}[1]{\oldsubparagraph{#1}\mbox{}}
+\fi
+
+%%% Use protect on footnotes to avoid problems with footnotes in titles
+\let\rmarkdownfootnote\footnote%
+\def\footnote{\protect\rmarkdownfootnote}
+
+%%% Change title format to be more compact
+\usepackage{titling}
+
+% Create subtitle command for use in maketitle
+\newcommand{\subtitle}[1]{
+  \posttitle{
+    \begin{center}\large#1\end{center}
+    }
+}
+
+\setlength{\droptitle}{-2em}
+
+  \title{Non Standard Evaluation in dplyr with Galaaz}
+    \pretitle{\vspace{\droptitle}\centering\huge}
+  \posttitle{\par}
+    \author{Rodrigo Botafogo \\ Daniel Mossé - University of Pittsburgh}
+    \preauthor{\centering\large\emph}
+  \postauthor{\par}
+      \predate{\centering\large\emph}
+  \postdate{\par}
+    \date{10/05/2019}
+
+% usar portugues do Brasil
+% \usepackage[brazilian]{babel}
+\usepackage[utf8]{inputenc}
+
+\usepackage{geometry}
+\geometry{a4paper, top=1in}
+
+% needed for kableExtra
+\usepackage{longtable}
+\usepackage{multirow}
+\usepackage[table]{xcolor}
+\usepackage{wrapfig}
+\usepackage{float}
+\usepackage{colortbl}
+\usepackage{pdflscape}
+\usepackage{tabu}
+\usepackage{threeparttable}
+\usepackage[normalem]{ulem}
+
+\usepackage{bbm}
+\usepackage{booktabs}
+\usepackage{expex}
+
+\usepackage{graphicx}
+
+\usepackage{fancyhdr}
+% set the header and foot style
+% style 'fancy' adds the section name on the header
+% and the page number on the footer
+\pagestyle{fancy}
+
+% style 'fancyhf' leaves header and footer empty
+%\fancyhf{}
+
+% sets the left head element to \rightmark, which contains the
+% current section (\leftmark is the current chapter)
+%\fancyhead[L]{\rightmark} .
+
+% sets the right head element to the page number.
+% \fancyhead[R]{\thepage}
+
+% lets the head rule disappear.
+% \renewcommand{\headrulewidth}{0pt}
+% Possible selectors for the optional argument of \fancyhead/\fancyfoot
+% are L (left), C (center) or R (right) for the position of the element
+% and E (even) or O (odd) to distinguish even and odd pages. If you omit
+% E/O the element is set for all pages.
+
+% \usepackage{lipsum}
+
+% make available command lastpage
+\usepackage{lastpage}
+
+% default fontsize 11pt better to add
+% fontsize on the yaml header
+% \usepackage[fontsize=11pt]{scrextend}
+
+% comandos para formatar uma tabela
+\usepackage{array}
+\newcolumntype{L}[1]{>{\raggedright\let\newline\\\arraybackslash\hspace{0pt}}m{#1}}
+\newcolumntype{C}[1]{>{\centering\let\newline\\\arraybackslash\hspace{0pt}}m{#1}}
+\newcolumntype{R}[1]{>{\raggedleft\let\newline\\\arraybackslash\hspace{0pt}}m{#1}}
+
+% necessário if we need to import other latex documents
+\usepackage{import}
+
+% Command to import an R variable to latex
+\newcommand{\RtoLatex}[2]{\newcommand{#1}{#2}}
+
+% 
+%\newcommand{\atraso}[1]{\color{red} \textbf {Tempo desde a Assinatura do Contrato: #1 dias}}
+
+\begin{document}
+\maketitle
+
+{
+\setcounter{tocdepth}{2}
+\tableofcontents
+}
+\hypertarget{introduction}{%
+\section{Introduction}\label{introduction}}
+
+In this post we will see how to program with \emph{dplyr} in Galaaz.
+
+\hypertarget{but-first-what-is-galaaz}{%
+\subsection{But first, what is
+Galaaz??}\label{but-first-what-is-galaaz}}
+
+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.
+
+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 \emph{dplyr} is easier
+in Galaaz than in R.
+
+R users are probably quite knowledgeable about \emph{dplyr}, for the
+Ruby developer, \emph{dplyr} and the \emph{tidyverse} 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.
+
+For the coupling of Ruby and R we use new technologies provided by
+Oracle: GraalVM, TruffleRuby and FastR:
+
+\begin{verbatim}
+ 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++.
+
+ GraalVM removes the isolation between programming languages and enables
+ interoperability in a shared runtime. It can run either standalone or in
+ the context of OpenJDK, Node.js, Oracle Database, or MySQL.
+
+ GraalVM allows you to write polyglot applications with a seamless way to
+ pass values from one language to another. With GraalVM there is no copying
+ or marshaling necessary as it is with other polyglot systems. This lets
+ you achieve high performance when language boundaries are crossed. Most
+ of the time there is no additional cost for crossing a language boundary
+ at all.
+
+ Often developers have to make uncomfortable compromises that require them
+ to rewrite their software in other languages. For example:
+
+  * “That library is not available in my language. I need to rewrite it.” 
+  * “That language would be the perfect fit for my problem, but we cannot
+    run it in our environment.” 
+  * “That problem is already solved in my language, but the language is
+    too slow.”
+
+With GraalVM we aim to allow developers to freely choose the right language
+for the task at hand without making compromises.
+\end{verbatim}
+
+Interested readers should also check out the following sites:
+
+\begin{itemize}
+\tightlist
+\item
+  \href{https://www.graalvm.org/}{GraalVM Home}
+\item
+  \href{https://github.com/oracle/truffleruby}{TruffleRuby}
+\item
+  \href{https://github.com/oracle/fastr}{FastR}
+\item
+  \href{https://medium.com/graalvm/faster-r-with-fastr-4b8db0e0dceb}{Faster
+  R with FastR}
+\item
+  \href{https://medium.freecodecamp.org/how-to-make-beautiful-ruby-plots-with-galaaz-320848058857}{How
+  to make Beautiful Ruby Plots with Galaaz}
+\item
+  \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}
+\item
+  \href{https://towardsdatascience.com/how-to-do-reproducible-research-in-ruby-with-gknit-c26d2684d64e}{How
+  to do reproducible research in Ruby with gKnit}
+\item
+  \href{https://r4ds.had.co.nz/}{R for Data Science}
+\item
+  \href{https://adv-r.hadley.nz/}{Advanced R}
+\end{itemize}
+
+\hypertarget{programming-with-dplyr}{%
+\subsection{Programming with dplyr}\label{programming-with-dplyr}}
+
+This post will follow closely the work done in
+\url{https://dplyr.tidyverse.org/articles/programming.html}, by Hardley
+Wickham. In it, Hardley states:
+
+\begin{quote}
+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:
+\end{quote}
+
+\begin{quote}
+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 \& df\$y
+==2 \& df\$z == 3, {]}.
+\end{quote}
+
+\begin{quote}
+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.
+\end{quote}
+
+\begin{quote}
+Unfortunately these benefits do not come for free. There are two main
+drawbacks:
+\end{quote}
+
+\begin{quote}
+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:
+\end{quote}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{df <-}\StringTok{ }\KeywordTok{data.frame}\NormalTok{(}\DataTypeTok{x =} \DecValTok{1}\OperatorTok{:}\DecValTok{3}\NormalTok{, }\DataTypeTok{y =} \DecValTok{3}\OperatorTok{:}\DecValTok{1}\NormalTok{)}
+\KeywordTok{print}\NormalTok{(}\KeywordTok{filter}\NormalTok{(df, x }\OperatorTok{==}\StringTok{ }\DecValTok{1}\NormalTok{))}
+\CommentTok{#> # A tibble: 1 x 2}
+\CommentTok{#>       x     y}
+\CommentTok{#>   <int> <int>}
+\CommentTok{#> 1     1     3}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{quote}
+Is not equivalent to this code:
+\end{quote}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{my_var <-}\StringTok{ }\NormalTok{x}
+\CommentTok{#> Error in eval(expr, envir, enclos): object 'x' not found}
+\KeywordTok{filter}\NormalTok{(df, my_var }\OperatorTok{==}\StringTok{ }\DecValTok{1}\NormalTok{)}
+\CommentTok{#> Error: object 'my_var' not found}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{quote}
+This makes it hard to create functions with arguments that change how
+dplyr verbs are computed.
+\end{quote}
+
+In this post we will see that programming with \emph{dplyr} in Galaaz
+does not require knowledge of non-standard evaluation in R and can be
+accomplished by utilizing normal Ruby constructs.
+
+\hypertarget{writing-expressions-in-galaaz}{%
+\section{Writing Expressions in
+Galaaz}\label{writing-expressions-in-galaaz}}
+
+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 \(y = sin(x)\) describes a function but
+cannot be computed unless the value of \(x\) is bound to some value.
+
+Let's take a look at some of those expressions in Ruby:
+
+\hypertarget{expressions-from-operators}{%
+\subsection{Expressions from
+operators}\label{expressions-from-operators}}
+
+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:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{exp1 = }\StringTok{:a}\NormalTok{ + }\StringTok{:b}
+\NormalTok{puts exp1}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## a + b
+\end{verbatim}
+
+We can build any complex mathematical expression such as:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{exp2 = (}\StringTok{:a}\NormalTok{ + }\StringTok{:b}\NormalTok{) * }\FloatTok{2.0}\NormalTok{ + }\StringTok{:c}\NormalTok{ ** }\DecValTok{2}\NormalTok{ / }\StringTok{:z}
+\NormalTok{puts exp2}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## (a + b) * 2 + c^2L/z
+\end{verbatim}
+
+The `L' after two indicates that 2 is an integer.
+
+It is also possible to use inequality operators in building expressions:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{exp3 = (}\StringTok{:a}\NormalTok{ + }\StringTok{:b}\NormalTok{) >= }\StringTok{:z}
+\NormalTok{puts exp3}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## a + b >= z
+\end{verbatim}
+
+Expressions' definition can also make use of normal Ruby variables
+without any problem:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{x = }\DecValTok{20}
+\NormalTok{y = }\DecValTok{30}
+\NormalTok{exp_var = (}\StringTok{:a}\NormalTok{ + }\StringTok{:b}\NormalTok{) * x <= }\StringTok{:z}\NormalTok{ - y}
+\NormalTok{puts exp_var}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## (a + b) * 20L <= z - 30L
+\end{verbatim}
+
+Galaaz provides both symbolic representations for operators, such as
+(\textgreater{}, \textless{}, !=) as functional notation for those
+operators such as (.gt, .ge, etc.). So the same expression written above
+can also be written as
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{exp4 = (}\StringTok{:a}\NormalTok{ + }\StringTok{:b}\NormalTok{).ge }\StringTok{:z}
+\NormalTok{puts exp4}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## a + b >= z
+\end{verbatim}
+
+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'
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{exp5 = (}\StringTok{:a}\NormalTok{ + }\StringTok{:b}\NormalTok{).eq }\StringTok{:z}
+\NormalTok{puts exp5}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## a + b == z
+\end{verbatim}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{exp6 = }\StringTok{:y}\NormalTok{.assign }\StringTok{:a}\NormalTok{ + }\StringTok{:b}
+\NormalTok{puts exp6}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## y <- a + b
+\end{verbatim}
+
+In general we think that using the functional notation is preferable to
+using the symbolic notation as otherwise, we end up writing invalid
+expressions such as
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{exp_wrong = (}\StringTok{:a}\NormalTok{ + }\StringTok{:b}\NormalTok{) == }\StringTok{:z}
+\NormalTok{puts exp_wrong}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## Message:
+##  Error in function (x, y, num.eq = TRUE, single.NA = TRUE, attrib.as.set = TRUE,  :
+##   object 'a' not found (RError)
+## Translated to internal error
+\end{verbatim}
+
+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.
+
+\hypertarget{expressions-with-r-methods}{%
+\subsection{Expressions with R
+methods}\label{expressions-with-r-methods}}
+
+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 \(y = sin(x)\). 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)'
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{exp7 = }\StringTok{:y}\NormalTok{.assign E.sin(}\StringTok{:x}\NormalTok{)}
+\NormalTok{puts exp7}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## y <- sin(x)
+\end{verbatim}
+
+Expressions can also be written using `.' notation:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{exp8 = }\StringTok{:y}\NormalTok{.assign }\StringTok{:x}\NormalTok{.sin}
+\NormalTok{puts exp8}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## y <- sin(x)
+\end{verbatim}
+
+When a function has multiple arguments, the first one can be used before
+the `.':
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{exp9 = }\StringTok{:x}\NormalTok{.c(}\StringTok{:y}\NormalTok{)}
+\NormalTok{puts exp9}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## c(x, y)
+\end{verbatim}
+
+\hypertarget{evaluating-an-expression}{%
+\subsection{Evaluating an Expression}\label{evaluating-an-expression}}
+
+Expressions can be evaluated by calling function `eval' with a binding.
+A binding can be provided with a list:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{exp = (}\StringTok{:a}\NormalTok{ + }\StringTok{:b}\NormalTok{) * }\FloatTok{2.0}\NormalTok{ + }\StringTok{:c}\NormalTok{ ** }\DecValTok{2}\NormalTok{ / }\StringTok{:z}
+\NormalTok{puts exp.eval(R.list(}\StringTok{a: }\DecValTok{10}\NormalTok{, }\StringTok{b: }\DecValTok{20}\NormalTok{, }\StringTok{c: }\DecValTok{30}\NormalTok{, }\StringTok{z: }\DecValTok{40}\NormalTok{))}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## [1] 82.5
+\end{verbatim}
+
+\ldots{} with a data frame:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{df = R.data__frame(}
+  \StringTok{a: }\NormalTok{R.c(}\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{3}\NormalTok{),}
+  \StringTok{b: }\NormalTok{R.c(}\DecValTok{10}\NormalTok{, }\DecValTok{20}\NormalTok{, }\DecValTok{30}\NormalTok{),}
+  \StringTok{c: }\NormalTok{R.c(}\DecValTok{100}\NormalTok{, }\DecValTok{200}\NormalTok{, }\DecValTok{300}\NormalTok{),}
+  \StringTok{z: }\NormalTok{R.c(}\DecValTok{1000}\NormalTok{, }\DecValTok{2000}\NormalTok{, }\DecValTok{3000}\NormalTok{))}
+
+\NormalTok{puts exp.eval(df)}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## [1] 32 64 96
+\end{verbatim}
+
+\hypertarget{using-galaaz-to-call-r-functions}{%
+\section{Using Galaaz to call R
+functions}\label{using-galaaz-to-call-r-functions}}
+
+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: \url{https://www.rubydoc.info/gems/galaaz/0.4.9}), so
+we will present only a few examples scripts using Galaaz.
+
+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':
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{vec = R.c(}\FloatTok{1.0}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{3}\NormalTok{)}
+\NormalTok{puts vec}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## [1] 1 2 3
+\end{verbatim}
+
+A list is created in R with the `list' function, so in Galaaz we do:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{list = R.list(}\StringTok{a: }\FloatTok{1.0}\NormalTok{, }\StringTok{b: }\DecValTok{2}\NormalTok{, }\StringTok{c: }\DecValTok{3}\NormalTok{)}
+\NormalTok{puts list}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## $a
+## [1] 1
+## 
+## $b
+## [1] 2
+## 
+## $c
+## [1] 3
+\end{verbatim}
+
+Note that we can use named arguments in our list. The same code in R
+would be:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{lst =}\StringTok{ }\KeywordTok{list}\NormalTok{(}\DataTypeTok{a =} \DecValTok{1}\NormalTok{, }\DataTypeTok{b =}\NormalTok{ 2L, }\DataTypeTok{c =}\NormalTok{ 3L)}
+\KeywordTok{print}\NormalTok{(lst)}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## $a
+## [1] 1
+## 
+## $b
+## [1] 2
+## 
+## $c
+## [1] 3
+\end{verbatim}
+
+Now, let's say that `x' is an angle of 45\(^\circ\) and we acttually
+want to create the expression \(y = sin(45^\circ)\), which is
+\(y = 0.850...\). In this case, we will use `R.sin':
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{exp10 = }\StringTok{:y}\NormalTok{.assign R.sin(}\DecValTok{45}\NormalTok{)}
+\NormalTok{puts exp10}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## y <- 0.850903524534118
+\end{verbatim}
+
+\hypertarget{filtering-using-expressions}{%
+\section{Filtering using
+expressions}\label{filtering-using-expressions}}
+
+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'':
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{df = R.data__frame(}\StringTok{x: }\NormalTok{(}\DecValTok{1}\NormalTok{..}\DecValTok{3}\NormalTok{), }\StringTok{y: }\NormalTok{(}\DecValTok{3}\NormalTok{..}\DecValTok{1}\NormalTok{))}
+\NormalTok{puts df}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   x y
+## 1 1 3
+## 2 2 2
+## 3 3 1
+\end{verbatim}
+
+The `filter' function can be called on this data frame either by using
+`R.filter(df, \ldots{})' 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.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts df.filter(}\StringTok{:x}\NormalTok{.eq }\DecValTok{1}\NormalTok{)}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   x y
+## 1 1 3
+\end{verbatim}
+
+In R, and when coding with `tidyverse', arguments to a function are
+usually not \emph{referencially transparent}. That is, you can't replace
+a value with a seemingly equivalent object that you've defined
+elsewhere. In other words, this code
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{my_var <-}\StringTok{ }\NormalTok{x}
+\KeywordTok{filter}\NormalTok{(df, my_var }\OperatorTok{==}\StringTok{ }\DecValTok{1}\NormalTok{)}
+\end{Highlighting}
+\end{Shaded}
+
+Generates the following error: "object `x' not found.
+
+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.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{my_var = }\StringTok{:x}
+\NormalTok{puts df.filter(my_var.eq }\DecValTok{1}\NormalTok{)}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   x y
+## 1 1 3
+\end{verbatim}
+
+As stated by Hardley
+
+\begin{quote}
+dplyr code is ambiguous. Depending on what variables are defined where,
+filter(df, x == y) could be equivalent to any of:
+\end{quote}
+
+\begin{verbatim}
+df[df$x == df$y, ]
+df[df$x == y, ]
+df[x == df$y, ]
+df[x == y, ]
+\end{verbatim}
+
+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:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{y = }\DecValTok{1}
+\NormalTok{x = }\DecValTok{2}
+
+\CommentTok{# looking for values where the 'x' column is equal to the 'y' column}
+\NormalTok{puts df.filter(}\StringTok{:x}\NormalTok{.eq }\StringTok{:y}\NormalTok{)}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   x y
+## 1 2 2
+\end{verbatim}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\CommentTok{# looking for values where the 'x' column is equal to the 'y' variable}
+\CommentTok{# in this case, the number 1}
+\NormalTok{puts df.filter(}\StringTok{:x}\NormalTok{.eq y)}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   x y
+## 1 1 3
+\end{verbatim}
+
+\hypertarget{writing-a-function-that-applies-to-different-data-sets}{%
+\section{Writing a function that applies to different data
+sets}\label{writing-a-function-that-applies-to-different-data-sets}}
+
+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'.
+
+Here is the intended behaviour using the `mutate' function of `dplyr':
+
+\begin{verbatim}
+mutate(df1, y = a + x)
+mutate(df2, y = a + x)
+mutate(df3, y = a + x)
+mutate(df4, y = a + x)
+\end{verbatim}
+
+The naive approach to writing an R function to solve this problem is:
+
+\begin{verbatim}
+mutate_y <- function(df) {
+  mutate(df, y = a + x)
+}
+\end{verbatim}
+
+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.
+
+In Galaaz the method mutate\_y bellow will work fine and will never fail
+silently.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{def}\NormalTok{ mutate_y(df)}
+\NormalTok{  df.mutate(}\StringTok{:y}\NormalTok{.assign }\StringTok{:a}\NormalTok{ + }\StringTok{:x}\NormalTok{)}
+\KeywordTok{end}
+\end{Highlighting}
+\end{Shaded}
+
+Here we create a data frame that has only one column named `x':
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{df1 = R.data__frame(}\StringTok{x: }\NormalTok{(}\DecValTok{1}\NormalTok{..}\DecValTok{3}\NormalTok{))}
+\NormalTok{puts df1}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   x
+## 1 1
+## 2 2
+## 3 3
+\end{verbatim}
+
+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:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{a = }\DecValTok{10}
+\NormalTok{mutate_y(df1)}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## Message:
+##  Error in mutate_impl(.data, dots) :
+##   Evaluation error: object 'a' not found.
+## In addition: Warning message:
+## In mutate_impl(.data, dots) :
+##   mismatched protect/unprotect (unprotect with empty protect stack) (RError)
+## Translated to internal error
+\end{verbatim}
+
+\hypertarget{different-expressions}{%
+\section{Different expressions}\label{different-expressions}}
+
+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:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{set.seed}\NormalTok{(}\DecValTok{123}\NormalTok{)}
+
+\NormalTok{df <-}\StringTok{ }\KeywordTok{data.frame}\NormalTok{(}
+  \DataTypeTok{g1 =} \KeywordTok{c}\NormalTok{(}\DecValTok{1}\NormalTok{, }\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{2}\NormalTok{),}
+  \DataTypeTok{g2 =} \KeywordTok{c}\NormalTok{(}\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{1}\NormalTok{),}
+  \DataTypeTok{a =} \KeywordTok{sample}\NormalTok{(}\DecValTok{5}\NormalTok{),}
+  \DataTypeTok{b =} \KeywordTok{sample}\NormalTok{(}\DecValTok{5}\NormalTok{)}
+\NormalTok{)}
+
+\KeywordTok{as.data.frame}\NormalTok{(df) }
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   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
+\end{verbatim}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{d2 <-}\StringTok{ }\NormalTok{df }\OperatorTok{%>%}
+\StringTok{  }\KeywordTok{group_by}\NormalTok{(g1) }\OperatorTok{%>%}
+\StringTok{  }\KeywordTok{summarise}\NormalTok{(}\DataTypeTok{a =} \KeywordTok{mean}\NormalTok{(a))}
+           
+\KeywordTok{as.data.frame}\NormalTok{(d2)          }
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   g1 a
+## 1  1 3
+## 2  2 3
+\end{verbatim}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{d2 <-}\StringTok{ }\NormalTok{df }\OperatorTok{%>%}
+\StringTok{  }\KeywordTok{group_by}\NormalTok{(g2) }\OperatorTok{%>%}
+\StringTok{  }\KeywordTok{summarise}\NormalTok{(}\DataTypeTok{a =} \KeywordTok{mean}\NormalTok{(a))}
+           
+\KeywordTok{as.data.frame}\NormalTok{(d2)          }
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   g2        a
+## 1  1 2.666667
+## 2  2 3.500000
+\end{verbatim}
+
+As shown by Hardley, one might expect this function to do the trick:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{my_summarise <-}\StringTok{ }\ControlFlowTok{function}\NormalTok{(df, group_var) \{}
+\NormalTok{  df }\OperatorTok{%>%}
+\StringTok{    }\KeywordTok{group_by}\NormalTok{(group_var) }\OperatorTok{%>%}
+\StringTok{    }\KeywordTok{summarise}\NormalTok{(}\DataTypeTok{a =} \KeywordTok{mean}\NormalTok{(a))}
+\NormalTok{\}}
+
+\CommentTok{# my_summarise(df, g1)}
+\CommentTok{#> Error: Column `group_var` is unknown}
+\end{Highlighting}
+\end{Shaded}
+
+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.
+
+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 `\textasciitilde{}'
+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':
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts ~}\StringTok{:df}
+\NormalTok{print }\StringTok{"\textbackslash{}n"}
+
+\KeywordTok{def}\NormalTok{ my_summarize(df, group_var)}
+\NormalTok{  df.group_by(group_var).}
+\NormalTok{    summarize(}\StringTok{a: :a}\NormalTok{.mean)}
+\KeywordTok{end}
+
+\NormalTok{puts my_summarize(}\StringTok{:df}\NormalTok{, }\StringTok{:g1}\NormalTok{).as__data__frame}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   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
+## 
+##   g1 a
+## 1  1 3
+## 2  2 3
+\end{verbatim}
+
+It works!!! Well, let's make sure this was not just some coincidence
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts my_summarize(}\StringTok{:df}\NormalTok{, }\StringTok{:g2}\NormalTok{).as__data__frame}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   g2        a
+## 1  1 2.666667
+## 2  2 3.500000
+\end{verbatim}
+
+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.
+
+\hypertarget{different-input-variables}{%
+\section{Different input variables}\label{different-input-variables}}
+
+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?
+
+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:
+
+\begin{verbatim}
+summarise(df, mean = mean(a), sum = sum(a), n = n())
+#> # A tibble: 1 x 3
+#>    mean   sum     n
+#>   <dbl> <int> <int>
+#> 1     3    15     5
+
+summarise(df, mean = mean(a * b), sum = sum(a * b), n = n())
+#> # A tibble: 1 x 3
+#>    mean   sum     n
+#>   <dbl> <int> <int>
+#> 1   9    45     5
+\end{verbatim}
+
+Let's try it in galaaz:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{def}\NormalTok{ my_summarise2(df, expr)}
+\NormalTok{  df.summarize(}
+    \StringTok{mean: }\NormalTok{E.mean(expr),}
+    \StringTok{sum: }\NormalTok{E.sum(expr),}
+    \StringTok{n: }\NormalTok{E.n}
+\NormalTok{  )}
+\KeywordTok{end}
+
+\NormalTok{puts my_summarise2((~}\StringTok{:df}\NormalTok{), }\StringTok{:a}\NormalTok{)}
+\NormalTok{puts my_summarise2((~}\StringTok{:df}\NormalTok{), }\StringTok{:a}\NormalTok{ * }\StringTok{:b}\NormalTok{)}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   mean sum n
+## 1    3  15 5
+##   mean sum n
+## 1    9  45 5
+\end{verbatim}
+
+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'.
+
+\hypertarget{different-input-and-output-variable}{%
+\section{Different input and output
+variable}\label{different-input-and-output-variable}}
+
+Now the next challenge presented by Hardley is to vary the name of the
+output variables based on the received expression. So, if the input
+expression is `a', we want our data frame columns to be named `mean\_a'
+and `sum\_a'. Now, if the input expression is `b', columns should be
+named `mean\_b' and `sum\_b'.
+
+\begin{verbatim}
+mutate(df, mean_a = mean(a), sum_a = sum(a))
+#> # A tibble: 5 x 6
+#>      g1    g2     a     b mean_a sum_a
+#>   <dbl> <dbl> <int> <int>  <dbl> <int>
+#> 1     1     1     1     3      3    15
+#> 2     1     2     4     2      3    15
+#> 3     2     1     2     1      3    15
+#> 4     2     2     5     4      3    15
+#> # … with 1 more row
+
+mutate(df, mean_b = mean(b), sum_b = sum(b))
+#> # A tibble: 5 x 6
+#>      g1    g2     a     b mean_b sum_b
+#>   <dbl> <dbl> <int> <int>  <dbl> <int>
+#> 1     1     1     1     3      3    15
+#> 2     1     2     4     2      3    15
+#> 3     2     1     2     1      3    15
+#> 4     2     2     5     4      3    15
+#> # … with 1 more row
+\end{verbatim}
+
+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'
+
+Here is our Ruby code:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{def}\NormalTok{ my_mutate(df, expr)}
+\NormalTok{  mean_name = }\StringTok{"mean_}\OtherTok{#\{}\NormalTok{expr.to_s}\OtherTok{\}}\StringTok{"}
+\NormalTok{  sum_name = }\StringTok{"sum_}\OtherTok{#\{}\NormalTok{expr.to_s}\OtherTok{\}}\StringTok{"}
+
+\NormalTok{  df.mutate(mean_name => E.mean(expr),}
+\NormalTok{            sum_name => E.sum(expr))}
+\KeywordTok{end}
+
+\NormalTok{puts my_mutate((~}\StringTok{:df}\NormalTok{), }\StringTok{:a}\NormalTok{)}
+\NormalTok{puts my_mutate((~}\StringTok{:df}\NormalTok{), }\StringTok{:b}\NormalTok{)}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   g1 g2 a b mean_a sum_a
+## 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 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
+\end{verbatim}
+
+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), \ldots{}) where the
+column name was followed by a `:' colom. In this example, we have
+df.mutate(mean\_name =\textgreater{} E.mean(expr), \ldots{}) and
+variable mean\_name is not followed by `:' but by `=\textgreater{}'.
+This is standard Ruby notation.
+
+{[}explain\ldots{}.{]}
+
+\hypertarget{capturing-multiple-variables}{%
+\section{Capturing multiple
+variables}\label{capturing-multiple-variables}}
+
+Moving on with new complexities, Hardley proposes us to solve the
+problem in which the summarise function will receive any number of
+grouping variables.
+
+This again is quite standard Ruby. In order to receive an undefined
+number of paramenters the paramenter is preceded by '*':
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{def}\NormalTok{ my_summarise3(df, *group_vars)}
+\NormalTok{  df.group_by(*group_vars).}
+\NormalTok{    summarise(}\StringTok{a: }\NormalTok{E.mean(}\StringTok{:a}\NormalTok{))}
+\KeywordTok{end}
+
+\NormalTok{puts my_summarise3((~}\StringTok{:df}\NormalTok{), }\StringTok{:g1}\NormalTok{, }\StringTok{:g2}\NormalTok{).as__data__frame}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   g1 g2 a
+## 1  1  1 2
+## 2  1  2 4
+## 3  2  1 3
+## 4  2  2 3
+\end{verbatim}
+
+\hypertarget{why-does-r-require-nse-and-galaaz-does-not}{%
+\section{Why does R require NSE and Galaaz does
+not?}\label{why-does-r-require-nse-and-galaaz-does-not}}
+
+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?
+
+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.
+
+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.
+
+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'.
+
+\hypertarget{advanced-dplyr-features}{%
+\section{Advanced dplyr features}\label{advanced-dplyr-features}}
+
+In the blog: Programming with dplyr by using dplyr
+(\url{https://www.r-bloggers.com/programming-with-dplyr-by-using-dplyr/})
+Iñaki Úcar shows surprise that some R users are trying to code in dplyr
+avoiding the use of NSE. For instance he says:
+
+\begin{quote}
+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''.
+\end{quote}
+
+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.
+
+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:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{puts (~}\StringTok{:starwars}\NormalTok{).head.as__data__frame}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##             name height mass  hair_color  skin_color eye_color birth_year
+## 1 Luke Skywalker    172   77       blond        fair      blue       19.0
+## 2          C-3PO    167   75        <NA>        gold    yellow      112.0
+## 3          R2-D2     96   32        <NA> white, blue       red       33.0
+## 4    Darth Vader    202  136        none       white    yellow       41.9
+## 5    Leia Organa    150   49       brown       light     brown       19.0
+## 6      Owen Lars    178  120 brown, grey       light      blue       52.0
+##   gender homeworld species
+## 1   male  Tatooine   Human
+## 2   <NA>  Tatooine   Droid
+## 3   <NA>     Naboo   Droid
+## 4   male  Tatooine   Human
+## 5 female  Alderaan   Human
+## 6   male  Tatooine   Human
+##                                                                                                                                       films
+## 1                                           Revenge of the Sith, Return of the Jedi, The Empire Strikes Back, A New Hope, The Force Awakens
+## 2                    Attack of the Clones, The Phantom Menace, Revenge of the Sith, Return of the Jedi, The Empire Strikes Back, A New Hope
+## 3 Attack of the Clones, The Phantom Menace, Revenge of the Sith, Return of the Jedi, The Empire Strikes Back, A New Hope, The Force Awakens
+## 4                                                              Revenge of the Sith, Return of the Jedi, The Empire Strikes Back, A New Hope
+## 5                                           Revenge of the Sith, Return of the Jedi, The Empire Strikes Back, A New Hope, The Force Awakens
+## 6                                                                                     Attack of the Clones, Revenge of the Sith, A New Hope
+##                             vehicles                starships
+## 1 Snowspeeder, Imperial Speeder Bike X-wing, Imperial shuttle
+## 2                                                            
+## 3                                                            
+## 4                                             TIE Advanced x1
+## 5              Imperial Speeder Bike                         
+## 6
+\end{verbatim}
+
+The grouped\_mean function bellow will receive a grouping variable and
+calculate summaries for the value\_variables given:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{grouped_mean <-}\StringTok{ }\ControlFlowTok{function}\NormalTok{(data, grouping_variables, value_variables) \{}
+\NormalTok{  data }\OperatorTok{%>%}
+\StringTok{    }\KeywordTok{group_by_at}\NormalTok{(grouping_variables) }\OperatorTok{%>%}
+\StringTok{    }\KeywordTok{mutate}\NormalTok{(}\DataTypeTok{count =} \KeywordTok{n}\NormalTok{()) }\OperatorTok{%>%}
+\StringTok{    }\KeywordTok{summarise_at}\NormalTok{(}\KeywordTok{c}\NormalTok{(value_variables, }\StringTok{"count"}\NormalTok{), mean, }\DataTypeTok{na.rm =} \OtherTok{TRUE}\NormalTok{) }\OperatorTok{%>%}
+\StringTok{    }\KeywordTok{rename_at}\NormalTok{(value_variables, }\KeywordTok{funs}\NormalTok{(}\KeywordTok{paste0}\NormalTok{(}\StringTok{"mean_"}\NormalTok{, .)))}
+\NormalTok{    \}}
+
+\NormalTok{gm =}\StringTok{ }\NormalTok{starwars }\OperatorTok{%>%}\StringTok{ }
+\StringTok{   }\KeywordTok{grouped_mean}\NormalTok{(}\StringTok{"eye_color"}\NormalTok{, }\KeywordTok{c}\NormalTok{(}\StringTok{"mass"}\NormalTok{, }\StringTok{"birth_year"}\NormalTok{))}
+
+\KeywordTok{as.data.frame}\NormalTok{(gm)   }
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##        eye_color mean_mass mean_birth_year count
+## 1          black  76.28571        33.00000    10
+## 2           blue  86.51667        67.06923    19
+## 3      blue-gray  77.00000        57.00000     1
+## 4          brown  66.09231       108.96429    21
+## 5           dark       NaN             NaN     1
+## 6           gold       NaN             NaN     1
+## 7  green, yellow 159.00000             NaN     1
+## 8          hazel  66.00000        34.50000     3
+## 9         orange 282.33333       231.00000     8
+## 10          pink       NaN             NaN     1
+## 11           red  81.40000        33.66667     5
+## 12     red, blue       NaN             NaN     1
+## 13       unknown  31.50000             NaN     3
+## 14         white  48.00000             NaN     1
+## 15        yellow  81.11111        76.38000    11
+\end{verbatim}
+
+The same code with Galaaz, becomes:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{def}\NormalTok{ grouped_mean(data, grouping_variables, value_variables)}
+\NormalTok{  data.}
+\NormalTok{    group_by_at(grouping_variables).}
+\NormalTok{    mutate(}\StringTok{count: }\NormalTok{E.n).}
+\NormalTok{    summarise_at(E.c(value_variables, }\StringTok{"count"}\NormalTok{), ~}\StringTok{:mean}\NormalTok{, }\StringTok{na__rm: }\DecValTok{true}\NormalTok{).}
+\NormalTok{    rename_at(value_variables, E.funs(E.paste0(}\StringTok{"mean_"}\NormalTok{, value_variables)))}
+\KeywordTok{end}
+
+\NormalTok{puts grouped_mean((~}\StringTok{:starwars}\NormalTok{), }\StringTok{"eye_color"}\NormalTok{, E.c(}\StringTok{"mass"}\NormalTok{, }\StringTok{"birth_year"}\NormalTok{)).as__data__frame}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##        eye_color mean_mass mean_birth_year count
+## 1          black  76.28571        33.00000    10
+## 2           blue  86.51667        67.06923    19
+## 3      blue-gray  77.00000        57.00000     1
+## 4          brown  66.09231       108.96429    21
+## 5           dark       NaN             NaN     1
+## 6           gold       NaN             NaN     1
+## 7  green, yellow 159.00000             NaN     1
+## 8          hazel  66.00000        34.50000     3
+## 9         orange 282.33333       231.00000     8
+## 10          pink       NaN             NaN     1
+## 11           red  81.40000        33.66667     5
+## 12     red, blue       NaN             NaN     1
+## 13       unknown  31.50000             NaN     3
+## 14         white  48.00000             NaN     1
+## 15        yellow  81.11111        76.38000    11
+\end{verbatim}
+
+\hypertarget{conclusion}{%
+\section{Conclusion}\label{conclusion}}
+
+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.
+
+
+\end{document}