galaaz 0.4.10 → 0.5.0

data/blogs/manual/graph.rb

@@ -1,29 +0,0 @@
-# Graphics with ggplot
-
-```{ruby diverging_bar}
-require 'ggplot'
-
-R.theme_set R.theme_bw
-
-# Data Prep
-mtcars = ~:mtcars
-mtcars.car_name = R.rownames(:mtcars)
-# compute normalized mpg 
-mtcars.mpg_z = ((mtcars.mpg - mtcars.mpg.mean)/mtcars.mpg.sd).round 2
-mtcars.mpg_type = (mtcars.mpg_z > 0) ? "below" : "above"
-mtcars = mtcars[mtcars.mpg_z.order, :all]
-# convert to factor to retain sorted order in plot
-mtcars.car_name = mtcars.car_name.factor levels: mtcars.car_name
-
-# Diverging Barcharts
-gg = mtcars.ggplot(E.aes(x: :car_name, y: :mpg_z, label: :mpg_z)) + 
-     R.geom_bar(E.aes(fill: :mpg_type), stat: 'identity',  width: 0.5) +
-     R.scale_fill_manual(name: "Mileage", 
-                         labels: R.c("Above Average", "Below Average"), 
-                         values: R.c("above": "#00ba38", "below": "#f8766d")) + 
-     R.labs(subtitle: "Normalised mileage from 'mtcars'", 
-            title: "Diverging Bars") + 
-     R.coord_flip()
-
-puts gg
-```

data/blogs/nse_dplyr/nse_dplyr.tex

@@ -1,1373 +0,0 @@
-\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}