galaaz 2.1.7 → 2.1.8

data/blogs/nse_dplyr/nse_dplyr.tex

@@ -0,0 +1,1589 @@
+% Options for packages loaded elsewhere
+\PassOptionsToPackage{unicode}{hyperref}
+\PassOptionsToPackage{hyphens}{url}
+\documentclass[
+  11pt,
+]{article}
+\usepackage{xcolor}
+\usepackage[margin=1in]{geometry}
+\usepackage{amsmath,amssymb}
+\setcounter{secnumdepth}{5}
+\usepackage{iftex}
+\ifPDFTeX
+  \usepackage[T1]{fontenc}
+  \usepackage[utf8]{inputenc}
+  \usepackage{textcomp} % provide euro and other symbols
+\else % if luatex or xetex
+  \usepackage{unicode-math} % this also loads fontspec
+  \defaultfontfeatures{Scale=MatchLowercase}
+  \defaultfontfeatures[\rmfamily]{Ligatures=TeX,Scale=1}
+\fi
+\usepackage{lmodern}
+\ifPDFTeX\else
+  % xetex/luatex font selection
+\fi
+% Use upquote if available, for straight quotes in verbatim environments
+\IfFileExists{upquote.sty}{\usepackage{upquote}}{}
+\IfFileExists{microtype.sty}{% use microtype if available
+  \usepackage[]{microtype}
+  \UseMicrotypeSet[protrusion]{basicmath} % disable protrusion for tt fonts
+}{}
+\makeatletter
+\@ifundefined{KOMAClassName}{% if non-KOMA class
+  \IfFileExists{parskip.sty}{%
+    \usepackage{parskip}
+  }{% else
+    \setlength{\parindent}{0pt}
+    \setlength{\parskip}{6pt plus 2pt minus 1pt}}
+}{% if KOMA class
+  \KOMAoptions{parskip=half}}
+\makeatother
+\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.13,0.29,0.53}{#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.56,0.35,0.01}{#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.13,0.29,0.53}{\textbf{#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.81,0.36,0.00}{\textbf{#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}
+\makeatletter
+\newsavebox\pandoc@box
+\newcommand*\pandocbounded[1]{% scales image to fit in text height/width
+  \sbox\pandoc@box{#1}%
+  \Gscale@div\@tempa{\textheight}{\dimexpr\ht\pandoc@box+\dp\pandoc@box\relax}%
+  \Gscale@div\@tempb{\linewidth}{\wd\pandoc@box}%
+  \ifdim\@tempb\p@<\@tempa\p@\let\@tempa\@tempb\fi% select the smaller of both
+  \ifdim\@tempa\p@<\p@\scalebox{\@tempa}{\usebox\pandoc@box}%
+  \else\usebox{\pandoc@box}%
+  \fi%
+}
+% Set default figure placement to htbp
+\def\fps@figure{htbp}
+\makeatother
+\setlength{\emergencystretch}{3em} % prevent overfull lines
+\providecommand{\tightlist}{%
+  \setlength{\itemsep}{0pt}\setlength{\parskip}{0pt}}
+% 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}}
+
+% Soft-wrap Pandoc highlighted code/output boxes (Shaded + Highlighting).
+% This runs after Pandoc's default \DefineVerbatimEnvironment{Highlighting}
+% (header includes come later in the generated .tex). Prefer manual line
+% breaks in Rmd sources; breaklines is a safety net for leftovers/output.
+% Requires TinyTeX/TeX Live package: tlmgr install fvextra
+\IfFileExists{fvextra.sty}{%
+  \usepackage{fvextra}%
+  \DefineVerbatimEnvironment{Highlighting}{Verbatim}{%
+    breaklines=true,
+    breakanywhere=true,
+    breakindent=1.5em,
+    fontsize=\small,
+    commandchars=\\\{\}%
+  }%
+}{%
+  % fancyvrb is already loaded by Pandoc; shrink code so more fits per line.
+  \DefineVerbatimEnvironment{Highlighting}{Verbatim}{%
+    fontsize=\small,
+    commandchars=\\\{\}%
+  }%
+}
+
+% 
+%\newcommand{\atraso}[1]{\color{red} \textbf {Tempo desde a Assinatura do Contrato: #1 dias}}
+\usepackage{bookmark}
+\IfFileExists{xurl.sty}{\usepackage{xurl}}{} % add URL line breaks if available
+\urlstyle{same}
+\hypersetup{
+  pdftitle={Non Standard Evaluation in dplyr with Galaaz},
+  pdfauthor={Rodrigo Botafogo; Daniel Mossé - University of Pittsburgh},
+  hidelinks,
+  pdfcreator={LaTeX via pandoc}}
+
+\title{Non Standard Evaluation in dplyr with Galaaz}
+\author{Rodrigo Botafogo \and Daniel Mossé - University of Pittsburgh}
+\date{10/05/2019 (narrative updated for Galaaz 2.0, 2026)}
+
+\begin{document}
+\maketitle
+
+{
+\setcounter{tocdepth}{2}
+\tableofcontents
+}
+\section{Introduction}\label{introduction}
+
+According to Steven Sagaert's answer on Quora about ``Is programming
+language R overrated?'':
+
+\begin{quote}
+R is a sophisticated language with an unusual (i.e.~non-mainstream) set
+of features. It`s an impure functional programming language with
+sophisticated metaprogramming and 3 different OO systems.
+\end{quote}
+
+\begin{quote}
+Just like common lisp you can completely customise how things work via
+metaprogramming. The biggest example is the tidyverse: by creating it's
+own evaluation system (tidyeval) was able to create a custom syntax for
+dplyr.
+\end{quote}
+
+\begin{quote}
+Mastering R (the language) and its ecosystem is not a matter of weeks or
+months but takes years. The rabbit hole goes pretty deep\ldots{}
+\end{quote}
+
+Although a highly configurable language can give programmers a great
+deal of power, it can also take years to master---as noted above.
+Programming with \emph{dplyr}, for instance, means learning evaluation
+rules that are not always approachable for \textbf{statisticians and
+analysts who are not full-time software engineers}. That is not a
+criticism: R was \textbf{built} for \textbf{statisticians} who need
+trustworthy results on a deadline, not necessarily for building large
+applications.
+
+\textbf{Unfortunately}, when such a user moves on to more
+\textbf{sophisticated} programming patterns, the learning curve can
+become a real hurdle.
+
+In this post we will see how to program with \emph{dplyr} in Galaaz and
+how Ruby can simplify the learning curve of mastering \emph{dplyr}
+coding.
+
+\section{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. It is also easy to learn. 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. \textbf{Python} is a
+strong competitor, with NumPy, pandas, SciPy, scikit-learn, and
+\textbf{many thousands} of other packages on PyPI. We will not dwell on
+R \textbf{versus} Python here: both are excellent languages with
+different strengths. Our interest is to bring to yet another excellent
+language, Ruby, the data science libraries that it lacks.
+
+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 curve for the R developer.
+And as we will see in this post that 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 Hadley
+Wickham, Chief Scientist at Posit (formerly RStudio) and a prolific R
+coder and writer.
+
+For the coupling of Ruby and R, \textbf{Galaaz 2.0} uses
+\textbf{\href{https://www.jruby.org/}{JRuby}} (Ruby on the JVM) together
+with \textbf{GNU R}. A \textbf{bridge} sends expressions and data
+between Ruby and an R process so that Ruby can call \textbf{dplyr} and
+the rest of the tidyverse as if they were part of the same workflow. An
+\textbf{earlier} Galaaz line of work used Oracle's \textbf{GraalVM} with
+\textbf{TruffleRuby} and \textbf{FastR} in a single runtime; that
+approach is \textbf{no longer} the supported stack---see the project
+\textbf{manual} for setup, \textbf{\texttt{bin/galaaz-jruby}}, and
+\textbf{gKnit}.
+
+\section{Tidyverse and dplyr}\label{tidyverse-and-dplyr}
+
+In
+\href{https://rviews.rstudio.com/2017/06/08/what-is-the-tidyverse/}{What
+is the tidyverse?} the tidyverse is explained as follows:
+
+\begin{quote}
+The tidyverse is a coherent system of packages for data manipulation,
+exploration and visualization that share a common design philosophy.
+These were mostly developed by Hadley Wickham himself, but they are now
+being expanded by several contributors. Tidyverse packages are intended
+to make statisticians and data scientists more productive by guiding
+them through workflows that facilitate communication, and result in
+reproducible work products. Fundamentally, the tidyverse is about the
+connections between the tools that make the workflow possible.
+\end{quote}
+
+\emph{dplyr} is one of the many packages that are part of the tidyverse.
+It is:
+
+\begin{quote}
+a grammar of data manipulation, providing a consistent set of verbs that
+help you solve the most common data manipulation challenges:
+\end{quote}
+
+\begin{quote}
+\begin{enumerate}
+\def\labelenumi{\arabic{enumi}.}
+\tightlist
+\item
+  mutate() adds new variables that are functions of existing variables
+\item
+  select() picks variables based on their names.
+\item
+  filter() picks cases based on their values.
+\item
+  summarise() reduces multiple values down to a single summary.
+\item
+  arrange() changes the ordering of the rows.
+\end{enumerate}
+\end{quote}
+
+Very often R is used interactively and users use \emph{dplyr} to
+manipulate a single dataset without programming. When users want to
+replicate their work for multiple datasets, programming becomes
+necessary.
+
+\section{Programming with dplyr}\label{programming-with-dplyr}
+
+In the vignette
+\href{https://dplyr.tidyverse.org/articles/programming.html}{``Programming
+with dplyr''}, Hadley Wickham 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}
+
+But then he goes on:
+
+\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 }\OtherTok{\textless{}{-}} \FunctionTok{data.frame}\NormalTok{(}\AttributeTok{x =} \DecValTok{1}\SpecialCharTok{:}\DecValTok{3}\NormalTok{, }\AttributeTok{y =} \DecValTok{3}\SpecialCharTok{:}\DecValTok{1}\NormalTok{)}
+\FunctionTok{print}\NormalTok{(}\FunctionTok{filter}\NormalTok{(df, x }\SpecialCharTok{==} \DecValTok{1}\NormalTok{))}
+\CommentTok{\#\textgreater{} \# A tibble: 1 x 2}
+\CommentTok{\#\textgreater{}       x     y}
+\CommentTok{\#\textgreater{}   \textless{}int\textgreater{} \textless{}int\textgreater{}}
+\CommentTok{\#\textgreater{} 1     1     3}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{quote}
+Is not equivalent to this code:
+\end{quote}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{my\_var }\OtherTok{\textless{}{-}}\NormalTok{ x}
+\CommentTok{\#\textgreater{} Error in eval(expr, envir, enclos): object \textquotesingle{}x\textquotesingle{} not found}
+\FunctionTok{filter}\NormalTok{(df, my\_var }\SpecialCharTok{==} \DecValTok{1}\NormalTok{)}
+\CommentTok{\#\textgreater{} Error: object \textquotesingle{}my\_var\textquotesingle{} 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}
+
+As a result of this, programming with \emph{dplyr} requires learning a
+set of new ideas and concepts. In this vignette Hadley goes on showing
+how to program ever more difficult problems with \emph{dplyr}, showing
+the problems it faces and the new concepts needed to solve them.
+
+In this blog, we will look at all the problems presented by Harley on
+the vignette and show how those same problems can be solved using Galaaz
+and the Ruby language.
+
+This blog is organized as follows: first we show how to write
+expressions using Galaaz.\\
+Expressions are a fundamental concept in \emph{dplyr} and are not part
+of basic Ruby. We extend the Ruby language create a manipulate
+expressions that will be used by \emph{dplyr} functions.
+
+Then we show very succintly how Ruby and R can be integrated and how R
+functions are transparently called from Ruby. Galaaz
+\href{https://github.com/rbotafogo/galaaz/wiki}{user manual} (still in
+development) goes in much deeper detail about this integration.
+
+Next in section ``Data manipulation wiht \emph{dplyr}'' we go through
+all the problems on the \emph{dplyr} vignette and look at how they are
+solved in Galaaz. We then discuss why programming with Galaaz and
+\emph{dplyr} is easier than programming with \emph{dplyr} in plain R.
+
+The following section looks at another more advanced problem and shows
+that Galaaz can still handle it without any difficulty. We then provide
+further reading and concluding remarks.
+
+\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.
+
+Expressions are fundamental in \emph{dplyr} programming as they are the
+input to \emph{dplyr} functions, for instance, as we will see shortly,
+if a data frame has a column named `x' and we want to add another
+column, y, to this dataframe that has the values of `x' times 2, then we
+would call a \emph{dplyr} function with the expression `y = x * 2'.
+
+\subsection{A note on notation}\label{a-note-on-notation}
+
+This blog was written in Rmarkdown and automatically converted to HTML
+or PDF (depending on where you are reading this blog) with gKnit (a tool
+provided by Galaaz). In Rmarkdown, it is possible to write text and code
+blocks that are executed to generate the final report. Code blocks
+appear inside a `box' and the result of their execution appear either in
+another type of `box' with a different background (HTML) or as normal
+text (PDF). Every output line from the code execution is preceded by
+`\#\#'.
+
+\subsection{Expressions from
+operators}\label{expressions-from-operators}
+
+The code below creates an expression summing two symbols. Note that :a
+and :b are Ruby symbols and are not bound to any values at the time of
+expression definition:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\ControlFlowTok{begin}
+\NormalTok{  exp1 }\OperatorTok{=} \WarningTok{:a} \OperatorTok{+} \WarningTok{:b}
+  \FunctionTok{puts}\NormalTok{ exp1}
+\ControlFlowTok{rescue} \OperatorTok{=\textgreater{}}\NormalTok{ e}
+  \CommentTok{\# Bare Symbol\#+ is not expression sugar in Galaaz 2.0; short error for PDF.}
+  \FunctionTok{puts} \StringTok{"}\SpecialCharTok{\#\{}\NormalTok{e}\AttributeTok{.class}\SpecialCharTok{\}}\StringTok{: }\SpecialCharTok{\#\{}\NormalTok{e}\AttributeTok{.message}\SpecialCharTok{\}}\StringTok{"}
+\ControlFlowTok{end}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## NoMethodError: undefined method '+' for an instance of Symbol
+\end{verbatim}
+
+In Galaaz, we can build any complex mathematical expression such as:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{exp2 }\OperatorTok{=}\NormalTok{ (}\ConstantTok{R}\KeywordTok{[}\WarningTok{:a}\KeywordTok{]} \OperatorTok{+} \ConstantTok{R}\KeywordTok{[}\WarningTok{:b}\KeywordTok{]}\NormalTok{) }\OperatorTok{*} \FloatTok{2.0} \OperatorTok{+} \ConstantTok{R}\KeywordTok{[}\WarningTok{:c}\KeywordTok{]} \OperatorTok{**} \DecValTok{2} \OperatorTok{/} \ConstantTok{R}\KeywordTok{[}\WarningTok{:z}\KeywordTok{]}
+\FunctionTok{puts}\NormalTok{ exp2}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## a + b * 2.0 + c ^ 2L / z
+\end{verbatim}
+
+Expressions are printed with the same format as the equivalent R
+expressions. The `L' after 2 indicates that 2 is an integer.
+
+The R developer should note that in R, if she writes the number `2', the
+R interpreter will convert it to float. In order to get an interger she
+should write `2L'. Galaaz follows Ruby notation and `2' is an integer,
+while `2.0' is a float.
+
+It is also possible to use inequality operators in building expressions:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{exp3 }\OperatorTok{=}\NormalTok{ (}\ConstantTok{R}\KeywordTok{[}\WarningTok{:a}\KeywordTok{]} \OperatorTok{+} \ConstantTok{R}\KeywordTok{[}\WarningTok{:b}\KeywordTok{]}\NormalTok{) }\OperatorTok{\textgreater{}=} \ConstantTok{R}\KeywordTok{[}\WarningTok{:z}\KeywordTok{]}
+\FunctionTok{puts}\NormalTok{ 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 }\OperatorTok{=} \DecValTok{20}
+\NormalTok{y }\OperatorTok{=} \FloatTok{30.0}
+\NormalTok{exp\_var }\OperatorTok{=}\NormalTok{ (}\ConstantTok{R}\KeywordTok{[}\WarningTok{:a}\KeywordTok{]} \OperatorTok{+} \ConstantTok{R}\KeywordTok{[}\WarningTok{:b}\KeywordTok{]}\NormalTok{) }\OperatorTok{*}\NormalTok{ x }\OperatorTok{\textless{}=} \ConstantTok{R}\KeywordTok{[}\WarningTok{:z}\KeywordTok{]} \OperatorTok{{-}}\NormalTok{ y}
+\FunctionTok{puts}\NormalTok{ exp\_var}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## a + b * 20L <= z - 30.0
+\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 }\OperatorTok{=}\NormalTok{ (}\ConstantTok{R}\KeywordTok{[}\WarningTok{:a}\KeywordTok{]} \OperatorTok{+} \ConstantTok{R}\KeywordTok{[}\WarningTok{:b}\KeywordTok{]}\NormalTok{)}\AttributeTok{.ge} \ConstantTok{R}\KeywordTok{[}\WarningTok{:z}\KeywordTok{]}
+\FunctionTok{puts}\NormalTok{ exp4}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## a + b >= z
+\end{verbatim}
+
+Two types of expressions, however, can only be created with the
+functional representation of the operators. Those are expressions
+involving `==', and `='. This is the case since those symbols have
+special meaning in Ruby and should not be redefined.
+
+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 }\OperatorTok{=}\NormalTok{ (}\ConstantTok{R}\KeywordTok{[}\WarningTok{:a}\KeywordTok{]} \OperatorTok{+} \ConstantTok{R}\KeywordTok{[}\WarningTok{:b}\KeywordTok{]}\NormalTok{)}\AttributeTok{.eq} \ConstantTok{R}\KeywordTok{[}\WarningTok{:z}\KeywordTok{]}
+\FunctionTok{puts}\NormalTok{ exp5}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## a + b == z
+\end{verbatim}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{exp6 }\OperatorTok{=} \ConstantTok{R}\KeywordTok{[}\WarningTok{:y}\KeywordTok{]}\AttributeTok{.assign} \ConstantTok{R}\KeywordTok{[}\WarningTok{:a}\KeywordTok{]} \OperatorTok{+} \ConstantTok{R}\KeywordTok{[}\WarningTok{:b}\KeywordTok{]}
+\FunctionTok{puts}\NormalTok{ exp6}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## y <- a + b
+\end{verbatim}
+
+Users should be careful when writing expressions not to inadvertently
+use `==' or `=' as this will generate an error, that might be a bit
+cryptic (in future releases of Galaza, we plan to improve the error
+message).
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{exp\_wrong }\OperatorTok{=}\NormalTok{ (}\ConstantTok{R}\KeywordTok{[}\WarningTok{:a}\KeywordTok{]} \OperatorTok{+} \ConstantTok{R}\KeywordTok{[}\WarningTok{:b}\KeywordTok{]}\NormalTok{) }\OperatorTok{==} \ConstantTok{R}\KeywordTok{[}\WarningTok{:z}\KeywordTok{]}
+\FunctionTok{puts}\NormalTok{ exp\_wrong}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## false
+\end{verbatim}
+
+The problem lies with the fact that when using `==' we are comparing
+expression (R{[}:a{]} + R{[}:b{]}) to expression R{[}:z{]} with `=='.
+When this comparison is executed, the system tries to evaluate :a, :b
+and :z, and those symbols, at this time, are not bound to anything
+giving the ``object `a' not found'' message.
+
+\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 be immediately 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 }\OperatorTok{=} \ConstantTok{R}\KeywordTok{[}\WarningTok{:y}\KeywordTok{]}\AttributeTok{.assign} \ConstantTok{E}\AttributeTok{.sin}\NormalTok{(}\ConstantTok{R}\KeywordTok{[}\WarningTok{:x}\KeywordTok{]}\NormalTok{)}
+\FunctionTok{puts}\NormalTok{ exp7}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## y <- sin(x)
+\end{verbatim}
+
+Function expressions can also be written using `.' notation:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{exp8 }\OperatorTok{=} \ConstantTok{R}\KeywordTok{[}\WarningTok{:y}\KeywordTok{]}\AttributeTok{.assign} \ConstantTok{R}\KeywordTok{[}\WarningTok{:x}\KeywordTok{]}\AttributeTok{.sin}
+\FunctionTok{puts}\NormalTok{ 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 `.'. For instance, the R concatenate function `c', that concatenates
+two or more arguments can be part of an expression as:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{exp9 }\OperatorTok{=} \ConstantTok{R}\KeywordTok{[}\WarningTok{:x}\KeywordTok{]}\AttributeTok{.c}\NormalTok{(}\ConstantTok{R}\KeywordTok{[}\WarningTok{:y}\KeywordTok{]}\NormalTok{)}
+\FunctionTok{puts}\NormalTok{ exp9}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## c(x, y)
+\end{verbatim}
+
+Note that this gives an OO feeling to the code, as if we were saying `x'
+concatenates `y'. As a side note, `.' notation can be used as the R pipe
+operator `\%\textgreater\%', but is more general than the pipe.
+
+\subsection{Evaluating an Expression}\label{evaluating-an-expression}
+
+Although we are mainly focusing on expressions to pass them to
+\emph{dplyr} functions, expressions can be evaluated by calling function
+`eval' with a binding.
+
+A binding can be provided with a list or a data frame as shown below:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{exp }\OperatorTok{=}\NormalTok{ (}\ConstantTok{R}\KeywordTok{[}\WarningTok{:a}\KeywordTok{]} \OperatorTok{+} \ConstantTok{R}\KeywordTok{[}\WarningTok{:b}\KeywordTok{]}\NormalTok{) }\OperatorTok{*} \FloatTok{2.0} \OperatorTok{+} \ConstantTok{R}\KeywordTok{[}\WarningTok{:c}\KeywordTok{]} \OperatorTok{**} \DecValTok{2} \OperatorTok{/} \ConstantTok{R}\KeywordTok{[}\WarningTok{:z}\KeywordTok{]}
+\FunctionTok{puts}\NormalTok{ exp}\AttributeTok{.eval}\NormalTok{(}\ConstantTok{R}\AttributeTok{.list}\NormalTok{(}\WarningTok{a:} \DecValTok{10}\NormalTok{, }\WarningTok{b:} \DecValTok{20}\NormalTok{, }\WarningTok{c:} \DecValTok{30}\NormalTok{, }\WarningTok{z:} \DecValTok{40}\NormalTok{))}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## [1] 72.5
+\end{verbatim}
+
+with a data frame:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{df }\OperatorTok{=} \ConstantTok{R}\AttributeTok{.data\_\_frame}\NormalTok{(}
+  \WarningTok{a:} \ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{3}\NormalTok{),}
+  \WarningTok{b:} \ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\DecValTok{10}\NormalTok{, }\DecValTok{20}\NormalTok{, }\DecValTok{30}\NormalTok{),}
+  \WarningTok{c:} \ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\DecValTok{100}\NormalTok{, }\DecValTok{200}\NormalTok{, }\DecValTok{300}\NormalTok{),}
+  \WarningTok{z:} \ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\DecValTok{1000}\NormalTok{, }\DecValTok{2000}\NormalTok{, }\DecValTok{3000}\NormalTok{))}
+
+\FunctionTok{puts}\NormalTok{ exp}\AttributeTok{.eval}\NormalTok{(df)}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## [1] 31 62 93
+\end{verbatim}
+
+\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 preced the function with `R.'. For instance, to create a vector in R,
+the `c' function is used. In Galaaz, a vector can be created by using
+`R.c':
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{vec }\OperatorTok{=} \ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\FloatTok{1.0}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{3}\NormalTok{)}
+\FunctionTok{puts}\NormalTok{ 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 }\OperatorTok{=} \ConstantTok{R}\AttributeTok{.list}\NormalTok{(}\WarningTok{a:} \FloatTok{1.0}\NormalTok{, }\WarningTok{b:} \DecValTok{2}\NormalTok{, }\WarningTok{c:} \DecValTok{3}\NormalTok{)}
+\FunctionTok{puts}\NormalTok{ 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 }\OtherTok{=} \FunctionTok{list}\NormalTok{(}\AttributeTok{a =} \DecValTok{1}\NormalTok{, }\AttributeTok{b =} \DecValTok{2}\DataTypeTok{L}\NormalTok{, }\AttributeTok{c =} \DecValTok{3}\DataTypeTok{L}\NormalTok{)}
+\FunctionTok{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 }\OperatorTok{=} \ConstantTok{R}\KeywordTok{[}\WarningTok{:y}\KeywordTok{]}\AttributeTok{.assign} \ConstantTok{R}\AttributeTok{.sin}\NormalTok{(}\DecValTok{45}\NormalTok{)}
+\FunctionTok{puts}\NormalTok{ exp10}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## y <- 0.850903524534118
+\end{verbatim}
+
+\section{\texorpdfstring{Data manipulation wiht
+\emph{dplyr}}{Data manipulation wiht dplyr}}\label{data-manipulation-wiht-dplyr}
+
+In this section we will give a brief tour \emph{dplyr}'s usage in Galaaz
+and how to manipulate data in Ruby with it. This section will follow
+\href{https://dplyr.tidyverse.org/articles/dplyr.html}{\emph{dplyr}'s
+vignette} that explores the nycflights13 data set. This dataset contains
+all 336776 flights that departed from New York City in 2013. The data
+comes from the US Bureau of Transportation Statistics.
+
+Let's start by taking a look at this dataset:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\ConstantTok{R}\AttributeTok{.library}\NormalTok{(}\VerbatimStringTok{\textquotesingle{}nycflights13\textquotesingle{}}\NormalTok{)}
+\CommentTok{\# check it\textquotesingle{}s dimension}
+\FunctionTok{puts} \OperatorTok{\textasciitilde{}}\ConstantTok{R}\KeywordTok{[}\WarningTok{:flights}\KeywordTok{]}\AttributeTok{.dim}
+\CommentTok{\# and the structure}
+\OperatorTok{\textasciitilde{}}\ConstantTok{R}\KeywordTok{[}\WarningTok{:flights}\KeywordTok{]}\AttributeTok{.str}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## ~(dim(flights))
+## <environment: 0x57d8ad019298>
+\end{verbatim}
+
+Now, let's use a first verb of \emph{dplyr}: `filter'. This verb,
+obviously, will filter the data by the given expression. In the next
+block, we filter by columns `month' and `day'. The first argument to the
+filter function is symbol `:flights'. A Ruby symbol, when given to an R
+function will convert to the R variable of the same name, in this case
+`flights', that holds the nycflights13 data frame.
+
+The second and third arguments are expressions that will be used by the
+filter function to filter by columns, looking for entries in which the
+month and day are equal to 1.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\FunctionTok{puts} \ConstantTok{R}\AttributeTok{.filter}\NormalTok{(}\WarningTok{:flights}\NormalTok{, (}\ConstantTok{R}\KeywordTok{[}\WarningTok{:month}\KeywordTok{]}\AttributeTok{.eq} \DecValTok{1}\NormalTok{), (}\ConstantTok{R}\KeywordTok{[}\WarningTok{:day}\KeywordTok{]}\AttributeTok{.eq} \DecValTok{1}\NormalTok{))}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## # A tibble: 842 x 19
+##     year month   day dep_time sched_dep_time dep_delay arr_time
+##    <int> <int> <int>    <int>          <int>     <dbl>    <int>
+##  1  2013     1     1      517            515         2      830
+##  2  2013     1     1      533            529         4      850
+##  3  2013     1     1      542            540         2      923
+##  4  2013     1     1      544            545        -1     1004
+##  5  2013     1     1      554            600        -6      812
+##  6  2013     1     1      554            558        -4      740
+##  7  2013     1     1      555            600        -5      913
+##  8  2013     1     1      557            600        -3      709
+##  9  2013     1     1      557            600        -3      838
+## 10  2013     1     1      558            600        -2      753
+## # i 832 more rows
+## # i 12 more variables: sched_arr_time <int>, arr_delay <dbl>,
+## #   carrier <chr>, flight <int>, tailnum <chr>, origin <chr>,
+## #   dest <chr>, air_time <dbl>, distance <dbl>, hour <dbl>,
+## #   minute <dbl>, time_hour <dttm>
+\end{verbatim}
+
+\subsection{\texorpdfstring{Programming with \emph{dplyr}: problems and
+how to solve them in
+Galaaz}{Programming with dplyr: problems and how to solve them in Galaaz}}\label{programming-with-dplyr-problems-and-how-to-solve-them-in-galaaz}
+
+In this section we look at the list of problems that Hadley describes in
+the ``Programming with dplyr'' vignette and show how those problems are
+solved and coded with Galaaz. Readers interested in how those problems
+are treated in \emph{dplyr} should read the vignette and use it as a
+comparison with this blog.
+
+\subsection{Filtering using
+expressions}\label{filtering-using-expressions}
+
+Now that we know how to write expressions and call R functions, let's do
+some data manipulation in Galaaz. Let's first start by creating a data
+frame. In R, the `data.frame' function creates a data frame. In Ruby,
+writing `data.frame' will not parse as a single object. To call R
+functions that have a `.' in them, we need to substitute the `.' with
+'\_\_`. So, method 'data.frame' in R, is called in Galaaz as
+`R.data\_\_frame':
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{df }\OperatorTok{=} \ConstantTok{R}\AttributeTok{.data\_\_frame}\NormalTok{(}\WarningTok{x:}\NormalTok{ (}\DecValTok{1}\OperatorTok{..}\DecValTok{3}\NormalTok{), }\WarningTok{y:}\NormalTok{ (}\DecValTok{3}\OperatorTok{..}\DecValTok{1}\NormalTok{))}
+\FunctionTok{puts}\NormalTok{ df}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   x y
+## 1 1 3
+## 2 2 2
+## 3 3 1
+\end{verbatim}
+
+\emph{dplyr} provides the `filter' function, that filters data in a data
+brame. The `filter' function can be called on this data frame either by
+using `R.filter(df, \ldots)' or by using dot notation.
+
+-------FIX---------
+
+We prefer to use dot notation as shown below. The argument to `filter'
+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: `R{[}:x{]}.eq 1', where :x will be interpreted by filter as the
+`x' column.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\FunctionTok{puts}\NormalTok{ df}\AttributeTok{.filter}\NormalTok{(}\ConstantTok{R}\KeywordTok{[}\WarningTok{:x}\KeywordTok{]}\AttributeTok{.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 }\OtherTok{\textless{}{-}}\NormalTok{ x}
+\FunctionTok{filter}\NormalTok{(df, my\_var }\SpecialCharTok{==} \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 below. Note initially that `my\_var = R{[}: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
+(R{[}:x{]}.eq 1) which is what we want.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{my\_var }\OperatorTok{=} \ConstantTok{R}\KeywordTok{[}\WarningTok{:x}\KeywordTok{]}
+\FunctionTok{puts}\NormalTok{ df}\AttributeTok{.filter}\NormalTok{(my\_var}\AttributeTok{.eq} \DecValTok{1}\NormalTok{)}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   x y
+## 1 1 3
+\end{verbatim}
+
+As stated by Hadley
+
+\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, R{[}: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,
+R{[}:x{]}.eq R{[}: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 }\OperatorTok{=} \DecValTok{1}
+\NormalTok{x }\OperatorTok{=} \DecValTok{2}
+
+\CommentTok{\# looking for values where the \textquotesingle{}x\textquotesingle{} column is equal to the \textquotesingle{}y\textquotesingle{} column}
+\FunctionTok{puts}\NormalTok{ df}\AttributeTok{.filter}\NormalTok{(}\ConstantTok{R}\KeywordTok{[}\WarningTok{:x}\KeywordTok{]}\AttributeTok{.eq} \ConstantTok{R}\KeywordTok{[}\WarningTok{:y}\KeywordTok{]}\NormalTok{)}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   x y
+## 1 2 2
+\end{verbatim}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\CommentTok{\# looking for values where the \textquotesingle{}x\textquotesingle{} column is equal to the \textquotesingle{}y\textquotesingle{} variable}
+\CommentTok{\# in this case, the number 1}
+\FunctionTok{puts}\NormalTok{ df}\AttributeTok{.filter}\NormalTok{(}\ConstantTok{R}\KeywordTok{[}\WarningTok{:x}\KeywordTok{]}\AttributeTok{.eq}\NormalTok{ y)}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   x y
+## 1 1 3
+\end{verbatim}
+
+\subsection{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 below will work fine and will never fail
+silently.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\ControlFlowTok{def}\NormalTok{ mutate\_y(df)}
+  \CommentTok{\# Column names are Ruby kwargs (y: …).}
+  \CommentTok{\# Use .assign only for R \textasciigrave{}\textless{}{-}\textasciigrave{} expressions.}
+\NormalTok{  df}\AttributeTok{.mutate}\NormalTok{(}\WarningTok{y:} \ConstantTok{R}\KeywordTok{[}\WarningTok{:a}\KeywordTok{]} \OperatorTok{+} \ConstantTok{R}\KeywordTok{[}\WarningTok{:x}\KeywordTok{]}\NormalTok{)}
+\ControlFlowTok{end}
+\end{Highlighting}
+\end{Shaded}
+
+Here we create a data frame that has only one column named `x':
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{df1 }\OperatorTok{=} \ConstantTok{R}\AttributeTok{.data\_\_frame}\NormalTok{(}\WarningTok{x:}\NormalTok{ (}\DecValTok{1}\OperatorTok{..}\DecValTok{3}\NormalTok{))}
+\FunctionTok{puts}\NormalTok{ 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 \texttt{R{[}:a{]}} used in the
+definition of `mutate\_y' above:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{a }\OperatorTok{=} \DecValTok{10}
+\ControlFlowTok{begin}
+\NormalTok{  mutate\_y(df1)}
+\ControlFlowTok{rescue} \OperatorTok{=\textgreater{}}\NormalTok{ e}
+  \CommentTok{\# Short message only — full backtraces overflow PDF code boxes.}
+  \FunctionTok{puts} \StringTok{"}\SpecialCharTok{\#\{}\NormalTok{e}\AttributeTok{.class}\SpecialCharTok{\}}\StringTok{: }\SpecialCharTok{\#\{}\NormalTok{e}\AttributeTok{.message}\SpecialCharTok{\}}\StringTok{"}
+\ControlFlowTok{end}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## NewBridge::SessionClient::RProcessError: Error: i In argument: `y = a + x`.
+## Caused by error:
+## ! object 'a' not found
+\end{verbatim}
+
+\subsection{Different expressions}\label{different-expressions}
+
+Let's move to the next problem as presented by Hadley 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. Below 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}[]
+\FunctionTok{set.seed}\NormalTok{(}\DecValTok{123}\NormalTok{)}
+
+\NormalTok{df }\OtherTok{\textless{}{-}} \FunctionTok{data.frame}\NormalTok{(}
+  \AttributeTok{g1 =} \FunctionTok{c}\NormalTok{(}\DecValTok{1}\NormalTok{, }\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{2}\NormalTok{),}
+  \AttributeTok{g2 =} \FunctionTok{c}\NormalTok{(}\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{1}\NormalTok{),}
+  \AttributeTok{a =} \FunctionTok{sample}\NormalTok{(}\DecValTok{5}\NormalTok{),}
+  \AttributeTok{b =} \FunctionTok{sample}\NormalTok{(}\DecValTok{5}\NormalTok{)}
+\NormalTok{)}
+
+\FunctionTok{as.data.frame}\NormalTok{(df)}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   g1 g2 a b
+## 1  1  1 3 3
+## 2  1  2 2 1
+## 3  2  1 5 2
+## 4  2  2 4 5
+## 5  2  1 1 4
+\end{verbatim}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{d2 }\OtherTok{\textless{}{-}}\NormalTok{ df }\SpecialCharTok{\%\textgreater{}\%}
+  \FunctionTok{group\_by}\NormalTok{(g1) }\SpecialCharTok{\%\textgreater{}\%}
+  \FunctionTok{summarise}\NormalTok{(}\AttributeTok{a =} \FunctionTok{mean}\NormalTok{(a))}
+           
+\FunctionTok{as.data.frame}\NormalTok{(d2)}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   g1        a
+## 1  1 2.500000
+## 2  2 3.333333
+\end{verbatim}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{d2 }\OtherTok{\textless{}{-}}\NormalTok{ df }\SpecialCharTok{\%\textgreater{}\%}
+  \FunctionTok{group\_by}\NormalTok{(g2) }\SpecialCharTok{\%\textgreater{}\%}
+  \FunctionTok{summarise}\NormalTok{(}\AttributeTok{a =} \FunctionTok{mean}\NormalTok{(a))}
+           
+\FunctionTok{as.data.frame}\NormalTok{(d2)          }
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   g2 a
+## 1  1 3
+## 2  2 3
+\end{verbatim}
+
+As shown by Hadley, one might expect this function to do the trick:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{my\_summarise }\OtherTok{\textless{}{-}} \ControlFlowTok{function}\NormalTok{(df, group\_var) \{}
+\NormalTok{  df }\SpecialCharTok{\%\textgreater{}\%}
+    \FunctionTok{group\_by}\NormalTok{(group\_var) }\SpecialCharTok{\%\textgreater{}\%}
+    \FunctionTok{summarise}\NormalTok{(}\AttributeTok{a =} \FunctionTok{mean}\NormalTok{(a))}
+\NormalTok{\}}
+
+\CommentTok{\# my\_summarise(df, g1)}
+\CommentTok{\#\textgreater{} Error: Column \textasciigrave{}group\_var\textasciigrave{} 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 Hadley 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 defined previously in R (to
+access an R variable from Galaaz, we use the tilde 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}[]
+\FunctionTok{puts} \OperatorTok{\textasciitilde{}}\ConstantTok{R}\KeywordTok{[}\WarningTok{:df}\KeywordTok{]}
+\FunctionTok{print} \StringTok{"}
+\StringTok{"}
+
+\ControlFlowTok{def}\NormalTok{ my\_summarize(df, group\_var)}
+\NormalTok{  df}\AttributeTok{.group\_by}\NormalTok{(group\_var)}\AttributeTok{.}
+    \AttributeTok{summarize}\NormalTok{(}\WarningTok{a:} \ConstantTok{R}\KeywordTok{[}\WarningTok{:a}\KeywordTok{]}\AttributeTok{.mean}\NormalTok{)}
+\ControlFlowTok{end}
+
+\FunctionTok{puts}\NormalTok{ my\_summarize(}\OperatorTok{\textasciitilde{}}\ConstantTok{R}\KeywordTok{[}\WarningTok{:df}\KeywordTok{]}\NormalTok{, }\ConstantTok{R}\KeywordTok{[}\WarningTok{:g1}\KeywordTok{]}\NormalTok{)}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   g1 g2 a b
+## 1  1  1 3 3
+## 2  1  2 2 1
+## 3  2  1 5 2
+## 4  2  2 4 5
+## 5  2  1 1 4
+## 
+## # A tibble: 2 x 2
+##      g1     a
+##   <dbl> <dbl>
+## 1     1  2.5 
+## 2     2  3.33
+\end{verbatim}
+
+It works!!! Well, let's make sure this was not just some coincidence
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\FunctionTok{puts}\NormalTok{ my\_summarize(}\OperatorTok{\textasciitilde{}}\ConstantTok{R}\KeywordTok{[}\WarningTok{:df}\KeywordTok{]}\NormalTok{, }\ConstantTok{R}\KeywordTok{[}\WarningTok{:g2}\KeywordTok{]}\NormalTok{)}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## # A tibble: 2 x 2
+##      g2     a
+##   <dbl> <dbl>
+## 1     1     3
+## 2     2     3
+\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.
+
+\subsection{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 Hadley 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}[]
+\ControlFlowTok{def}\NormalTok{ my\_summarise2(df, expr)}
+\NormalTok{  df}\AttributeTok{.summarize}\NormalTok{(}
+    \WarningTok{mean:} \ConstantTok{E}\AttributeTok{.mean}\NormalTok{(expr),}
+    \WarningTok{sum:} \ConstantTok{E}\AttributeTok{.sum}\NormalTok{(expr),}
+    \WarningTok{n:} \ConstantTok{E}\AttributeTok{.n}
+\NormalTok{  )}
+\ControlFlowTok{end}
+
+\FunctionTok{puts}\NormalTok{ my\_summarise2((}\OperatorTok{\textasciitilde{}}\ConstantTok{R}\KeywordTok{[}\WarningTok{:df}\KeywordTok{]}\NormalTok{), }\WarningTok{:a}\NormalTok{)}
+\FunctionTok{puts}\NormalTok{ my\_summarise2((}\OperatorTok{\textasciitilde{}}\ConstantTok{R}\KeywordTok{[}\WarningTok{:df}\KeywordTok{]}\NormalTok{), }\ConstantTok{R}\KeywordTok{[}\WarningTok{:a}\KeywordTok{]} \OperatorTok{*} \ConstantTok{R}\KeywordTok{[}\WarningTok{:b}\KeywordTok{]}\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'.
+
+\subsection{Different input and output
+variable}\label{different-input-and-output-variable}
+
+Now the next challenge presented by Hadley 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, Hadley 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}[]
+\ControlFlowTok{def}\NormalTok{ my\_mutate(df, expr)}
+\NormalTok{  mean\_name }\OperatorTok{=} \StringTok{"mean\_}\SpecialCharTok{\#\{}\NormalTok{expr}\AttributeTok{.to\_s}\SpecialCharTok{\}}\StringTok{"}
+\NormalTok{  sum\_name }\OperatorTok{=} \StringTok{"sum\_}\SpecialCharTok{\#\{}\NormalTok{expr}\AttributeTok{.to\_s}\SpecialCharTok{\}}\StringTok{"}
+
+\NormalTok{  df}\AttributeTok{.mutate}\NormalTok{(mean\_name }\OperatorTok{=\textgreater{}} \ConstantTok{E}\AttributeTok{.mean}\NormalTok{(expr),}
+\NormalTok{            sum\_name }\OperatorTok{=\textgreater{}} \ConstantTok{E}\AttributeTok{.sum}\NormalTok{(expr))}
+\ControlFlowTok{end}
+
+\FunctionTok{puts}\NormalTok{ my\_mutate((}\OperatorTok{\textasciitilde{}}\ConstantTok{R}\KeywordTok{[}\WarningTok{:df}\KeywordTok{]}\NormalTok{), }\WarningTok{:a}\NormalTok{)}
+\FunctionTok{puts}\NormalTok{ my\_mutate((}\OperatorTok{\textasciitilde{}}\ConstantTok{R}\KeywordTok{[}\WarningTok{:df}\KeywordTok{]}\NormalTok{), }\WarningTok{:b}\NormalTok{)}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+##   g1 g2 a b mean_a sum_a
+## 1  1  1 3 3      3    15
+## 2  1  2 2 1      3    15
+## 3  2  1 5 2      3    15
+## 4  2  2 4 5      3    15
+## 5  2  1 1 4      3    15
+##   g1 g2 a b mean_b sum_b
+## 1  1  1 3 3      3    15
+## 2  1  2 2 1      3    15
+## 3  2  1 5 2      3    15
+## 4  2  2 4 5      3    15
+## 5  2  1 1 4      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.{]}
+
+\subsection{Capturing multiple
+variables}\label{capturing-multiple-variables}
+
+Moving on with new complexities, Hadley 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}[]
+\ControlFlowTok{def}\NormalTok{ my\_summarise3(df, }\OperatorTok{*}\NormalTok{group\_vars)}
+\NormalTok{  df}\AttributeTok{.group\_by}\NormalTok{(}\OperatorTok{*}\NormalTok{group\_vars)}\AttributeTok{.}
+    \AttributeTok{summarise}\NormalTok{(}\WarningTok{a:} \ConstantTok{E}\AttributeTok{.mean}\NormalTok{(}\WarningTok{:a}\NormalTok{))}
+\ControlFlowTok{end}
+
+\FunctionTok{puts}\NormalTok{ my\_summarise3((}\OperatorTok{\textasciitilde{}}\ConstantTok{R}\KeywordTok{[}\WarningTok{:df}\KeywordTok{]}\NormalTok{), }\WarningTok{:g1}\NormalTok{, }\WarningTok{:g2}\NormalTok{)}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## # A tibble: 4 x 3
+## # Groups:   g1 [2]
+##      g1    g2     a
+##   <dbl> <dbl> <dbl>
+## 1     1     1     3
+## 2     1     2     2
+## 3     2     1     3
+## 4     2     2     4
+\end{verbatim}
+
+\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: `R{[}:a{]}.eq R{[}: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 `R{[}:a{]}.eq R{[}:b{]}'.
+
+\section{Advanced dplyr features}\label{advanced-dplyr-features}
+
+In the blog:
+\href{https://www.r-bloggers.com/programming-with-dplyr-by-using-dplyr/}{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}[]
+\FunctionTok{puts}\NormalTok{ (}\OperatorTok{\textasciitilde{}}\ConstantTok{R}\KeywordTok{[}\WarningTok{:starwars}\KeywordTok{]}\NormalTok{)}\AttributeTok{.head}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## # A tibble: 6 x 14
+##   name   height  mass hair_color skin_color eye_color birth_year sex  
+##   <chr>   <int> <dbl> <chr>      <chr>      <chr>          <dbl> <chr>
+## 1 Luke ~    172    77 blond      fair       blue            19   male 
+## 2 C-3PO     167    75 <NA>       gold       yellow         112   none 
+## 3 R2-D2      96    32 <NA>       white, bl~ red             33   none 
+## 4 Darth~    202   136 none       white      yellow          41.9 male 
+## 5 Leia ~    150    49 brown      light      brown           19   fema~
+## 6 Owen ~    178   120 brown, gr~ light      blue            52   male 
+## # i 6 more variables: gender <chr>, homeworld <chr>, species <chr>,
+## #   films <list>, vehicles <list>, starships <list>
+\end{verbatim}
+
+The grouped\_mean function below will receive a grouping variable and
+calculate summaries for the value\_variables given:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{grouped\_mean }\OtherTok{\textless{}{-}} \ControlFlowTok{function}\NormalTok{(data, grouping\_variables, value\_variables) \{}
+\NormalTok{  data }\SpecialCharTok{\%\textgreater{}\%}
+    \FunctionTok{group\_by\_at}\NormalTok{(grouping\_variables) }\SpecialCharTok{\%\textgreater{}\%}
+    \FunctionTok{mutate}\NormalTok{(}\AttributeTok{count =} \FunctionTok{n}\NormalTok{()) }\SpecialCharTok{\%\textgreater{}\%}
+    \FunctionTok{summarise\_at}\NormalTok{(}\FunctionTok{c}\NormalTok{(value\_variables, }\StringTok{"count"}\NormalTok{), mean, }\AttributeTok{na.rm =} \ConstantTok{TRUE}\NormalTok{) }\SpecialCharTok{\%\textgreater{}\%}
+    \FunctionTok{rename\_at}\NormalTok{(value\_variables, }\FunctionTok{funs}\NormalTok{(}\FunctionTok{paste0}\NormalTok{(}\StringTok{"mean\_"}\NormalTok{, .)))}
+\NormalTok{    \}}
+
+\NormalTok{gm }\OtherTok{=}\NormalTok{ starwars }\SpecialCharTok{\%\textgreater{}\%} 
+   \FunctionTok{grouped\_mean}\NormalTok{(}\StringTok{"eye\_color"}\NormalTok{, }\FunctionTok{c}\NormalTok{(}\StringTok{"mass"}\NormalTok{, }\StringTok{"birth\_year"}\NormalTok{))}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## Warning: `funs()` was deprecated in dplyr 0.8.0.
+## i Please use a list of either functions or lambdas:
+## 
+## # Simple named list: list(mean = mean, median = median)
+## 
+## # Auto named with `tibble::lst()`: tibble::lst(mean, median)
+## 
+## # Using lambdas list(~ mean(., trim = .2), ~ median(., na.rm = TRUE))
+## Call `lifecycle::last_lifecycle_warnings()` to see where this warning
+## was generated.
+\end{verbatim}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\FunctionTok{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}[]
+\ControlFlowTok{def}\NormalTok{ grouped\_mean(data, grouping\_variables, value\_variables)}
+\NormalTok{  data}\AttributeTok{.}
+    \AttributeTok{group\_by\_at}\NormalTok{(grouping\_variables)}\AttributeTok{.}
+    \AttributeTok{mutate}\NormalTok{(}\WarningTok{count:} \ConstantTok{E}\AttributeTok{.n}\NormalTok{)}\AttributeTok{.}
+    \AttributeTok{summarise\_at}\NormalTok{(}
+      \ConstantTok{E}\AttributeTok{.c}\NormalTok{(value\_variables, }\StringTok{"count"}\NormalTok{),}
+      \ConstantTok{R}\KeywordTok{[}\WarningTok{:mean}\KeywordTok{]}\NormalTok{,}
+      \WarningTok{na\_\_rm:} \DecValTok{true}\NormalTok{)}\AttributeTok{.}
+    \AttributeTok{rename\_at}\NormalTok{(}
+\NormalTok{      value\_variables,}
+      \ConstantTok{E}\AttributeTok{.funs}\NormalTok{(}\ConstantTok{E}\AttributeTok{.paste0}\NormalTok{(}\StringTok{"mean\_"}\NormalTok{, value\_variables)))}
+\ControlFlowTok{end}
+
+\FunctionTok{puts}\NormalTok{ grouped\_mean(}
+\NormalTok{  (}\OperatorTok{\textasciitilde{}}\ConstantTok{R}\KeywordTok{[}\WarningTok{:starwars}\KeywordTok{]}\NormalTok{),}
+  \StringTok{"eye\_color"}\NormalTok{,}
+  \ConstantTok{E}\AttributeTok{.c}\NormalTok{(}\StringTok{"mass"}\NormalTok{, }\StringTok{"birth\_year"}\NormalTok{))}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## # A tibble: 15 x 4
+##    eye_color     mean_mass mean_birth_year count
+##    <chr>             <dbl>           <dbl> <dbl>
+##  1 black              76.3            33      10
+##  2 blue               86.5            67.1    19
+##  3 blue-gray          77              57       1
+##  4 brown              66.1           109.     21
+##  5 dark              NaN             NaN       1
+##  6 gold              NaN             NaN       1
+##  7 green, yellow     159             NaN       1
+##  8 hazel              66              34.5     3
+##  9 orange            282.            231       8
+## 10 pink              NaN             NaN       1
+## 11 red                81.4            33.7     5
+## 12 red, blue         NaN             NaN       1
+## 13 unknown            31.5           NaN       3
+## 14 white              48             NaN       1
+## 15 yellow             81.1            76.4    11
+\end{verbatim}
+
+\section{Further reading}\label{further-reading}
+
+\begin{itemize}
+\tightlist
+\item
+  \href{https://www.jruby.org/}{JRuby} --- Ruby on the JVM (Galaaz 2.0)
+\item
+  \href{https://medium.freecodecamp.org/how-to-make-beautiful-ruby-plots-with-galaaz-320848058857}{How
+  to make Beautiful Ruby Plots with Galaaz} (plots; narrative partly
+  pre-2.0)
+\item
+  \href{https://towardsdatascience.com/ruby-plotting-with-galaaz-an-example-of-tightly-coupling-ruby-and-r-in-graalvm-520b69e21021}{Ruby
+  Plotting with Galaaz in GraalVM} (older stack; ideas still useful)
+\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}
+\item
+  Historical context: \href{https://www.graalvm.org/}{GraalVM},
+  \href{https://github.com/oracle/truffleruby}{TruffleRuby},
+  \href{https://github.com/oracle/fastr}{FastR}
+\end{itemize}
+
+\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}