galaaz 0.5.0 → 2.1.0

data/blogs/manual/manual.tex

@@ -1,34 +1,43 @@
-\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
+% 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}
-\else % if luatex or xelatex
-  \ifxetex
-    \usepackage{mathspec}
-  \else
-    \usepackage{fontspec}
-  \fi
-  \defaultfontfeatures{Ligatures=TeX,Scale=MatchLowercase}
+  \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
+% 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
+\IfFileExists{microtype.sty}{% use microtype if available
+  \usepackage[]{microtype}
+  \UseMicrotypeSet[protrusion]{basicmath} % disable protrusion for tt fonts
 }{}
-\usepackage[margin=1in]{geometry}
-\usepackage{hyperref}
-\hypersetup{unicode=true,
-            pdftitle={Galaaz Manual},
-            pdfauthor={Rodrigo Botafogo},
-            pdfborder={0 0 0},
-            breaklinks=true}
-\urlstyle{same}  % don't use monospace font for urls
+\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}{|}
@@ -38,94 +47,99 @@
 \usepackage{framed}
 \definecolor{shadecolor}{RGB}{248,248,248}
 \newenvironment{Shaded}{\begin{snugshade}}{\end{snugshade}}
-\newcommand{\KeywordTok}[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{\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{\FloatTok}[1]{\textcolor[rgb]{0.00,0.00,0.81}{#1}}
-\newcommand{\ConstantTok}[1]{\textcolor[rgb]{0.00,0.00,0.00}{#1}}
+\newcommand{\BuiltInTok}[1]{#1}
 \newcommand{\CharTok}[1]{\textcolor[rgb]{0.31,0.60,0.02}{#1}}
-\newcommand{\SpecialCharTok}[1]{\textcolor[rgb]{0.00,0.00,0.00}{#1}}
-\newcommand{\StringTok}[1]{\textcolor[rgb]{0.31,0.60,0.02}{#1}}
-\newcommand{\VerbatimStringTok}[1]{\textcolor[rgb]{0.31,0.60,0.02}{#1}}
-\newcommand{\SpecialStringTok}[1]{\textcolor[rgb]{0.31,0.60,0.02}{#1}}
-\newcommand{\ImportTok}[1]{#1}
 \newcommand{\CommentTok}[1]{\textcolor[rgb]{0.56,0.35,0.01}{\textit{#1}}}
-\newcommand{\DocumentationTok}[1]{\textcolor[rgb]{0.56,0.35,0.01}{\textbf{\textit{#1}}}}
-\newcommand{\AnnotationTok}[1]{\textcolor[rgb]{0.56,0.35,0.01}{\textbf{\textit{#1}}}}
 \newcommand{\CommentVarTok}[1]{\textcolor[rgb]{0.56,0.35,0.01}{\textbf{\textit{#1}}}}
-\newcommand{\OtherTok}[1]{\textcolor[rgb]{0.56,0.35,0.01}{#1}}
-\newcommand{\FunctionTok}[1]{\textcolor[rgb]{0.00,0.00,0.00}{#1}}
-\newcommand{\VariableTok}[1]{\textcolor[rgb]{0.00,0.00,0.00}{#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{\OperatorTok}[1]{\textcolor[rgb]{0.81,0.36,0.00}{\textbf{#1}}}
-\newcommand{\BuiltInTok}[1]{#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{\AttributeTok}[1]{\textcolor[rgb]{0.77,0.63,0.00}{#1}}
 \newcommand{\RegionMarkerTok}[1]{#1}
-\newcommand{\InformationTok}[1]{\textcolor[rgb]{0.56,0.35,0.01}{\textbf{\textit{#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}}}}
-\newcommand{\AlertTok}[1]{\textcolor[rgb]{0.94,0.16,0.16}{#1}}
-\newcommand{\ErrorTok}[1]{\textcolor[rgb]{0.64,0.00,0.00}{\textbf{#1}}}
-\newcommand{\NormalTok}[1]{#1}
-\usepackage{longtable,booktabs}
-\usepackage{graphicx,grffile}
+\usepackage{longtable,booktabs,array}
+\newcounter{none} % for unnumbered tables
+\usepackage{calc} % for calculating minipage widths
+% Correct order of tables after \paragraph or \subparagraph
+\usepackage{etoolbox}
 \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}
+\patchcmd\longtable{\par}{\if@noskipsec\mbox{}\fi\par}{}{}
 \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}
+% Allow footnotes in longtable head/foot
+\IfFileExists{footnotehyper.sty}{\usepackage{footnotehyper}}{\usepackage{footnote}}
+\makesavenoteenv{longtable}
+\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%
 }
-\setlength{\emergencystretch}{3em}  % prevent overfull lines
+% Set default figure placement to htbp
+\def\fps@figure{htbp}
+\makeatother
+% definitions for citeproc citations
+\NewDocumentCommand\citeproctext{}{}
+\NewDocumentCommand\citeproc{mm}{%
+  \begingroup\def\citeproctext{#2}\cite{#1}\endgroup}
+\makeatletter
+ % allow citations to break across lines
+ \let\@cite@ofmt\@firstofone
+ % avoid brackets around text for \cite:
+ \def\@biblabel#1{}
+ \def\@cite#1#2{{#1\if@tempswa , #2\fi}}
+\makeatother
+\newlength{\cslhangindent}
+\setlength{\cslhangindent}{1.5em}
+\newlength{\csllabelwidth}
+\setlength{\csllabelwidth}{3em}
+\newenvironment{CSLReferences}[2] % #1 hanging-indent, #2 entry-spacing
+ {\begin{list}{}{%
+  \setlength{\itemindent}{0pt}
+  \setlength{\leftmargin}{0pt}
+  \setlength{\parsep}{0pt}
+  % turn on hanging indent if param 1 is 1
+  \ifodd #1
+   \setlength{\leftmargin}{\cslhangindent}
+   \setlength{\itemindent}{-1\cslhangindent}
+  \fi
+  % set entry spacing
+  \setlength{\itemsep}{#2\baselineskip}}}
+ {\end{list}}
+\usepackage{calc}
+\newcommand{\CSLBlock}[1]{\hfill\break\parbox[t]{\linewidth}{\strut\ignorespaces#1\strut}}
+\newcommand{\CSLLeftMargin}[1]{\parbox[t]{\csllabelwidth}{\strut#1\strut}}
+\newcommand{\CSLRightInline}[1]{\parbox[t]{\linewidth - \csllabelwidth}{\strut#1\strut}}
+\newcommand{\CSLIndent}[1]{\hspace{\cslhangindent}#1}
+\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{Galaaz Manual}
-    \pretitle{\vspace{\droptitle}\centering\huge}
-  \posttitle{\par}
-  \subtitle{How to tightly couple Ruby and R in GraalVM}
-  \author{Rodrigo Botafogo}
-    \preauthor{\centering\large\emph}
-  \postauthor{\par}
-      \predate{\centering\large\emph}
-  \postdate{\par}
-    \date{2019}
-
 % usar portugues do Brasil
 % \usepackage[brazilian]{babel}
 \usepackage[utf8]{inputenc}
@@ -211,6 +225,25 @@
 \usepackage[normalem]{ulem}
 \usepackage{makecell}
 \usepackage{xcolor}
+\usepackage{bookmark}
+\IfFileExists{xurl.sty}{\usepackage{xurl}}{} % add URL line breaks if available
+\urlstyle{same}
+\hypersetup{
+  pdftitle={Galaaz Manual},
+  pdfauthor={Rodrigo Botafogo},
+  hidelinks,
+  pdfcreator={LaTeX via pandoc}}
+
+\title{Galaaz Manual}
+\usepackage{etoolbox}
+\makeatletter
+\providecommand{\subtitle}[1]{% add subtitle to \maketitle
+  \apptocmd{\@title}{\par {\large #1 \par}}{}{}
+}
+\makeatother
+\subtitle{Coupling Ruby (JRuby) and GNU R for data science}
+\author{Rodrigo Botafogo}
+\date{2026}
 
 \begin{document}
 \maketitle
@@ -226,8 +259,10 @@ language, with a large community, a very large set of libraries and
 great for web development. However, it lacks libraries for data science,
 statistics, scientific plotting and machine learning. On the other hand,
 R is considered one of the most powerful languages for solving all of
-the above problems. Maybe the strongest competitor to R is Python with
-libraries such as NumPy, Panda, SciPy, SciKit-Learn and a couple more.
+the above problems. \textbf{Python} is a strong competitor: NumPy,
+pandas, SciPy, and scikit-learn are widely used building blocks, and
+\textbf{PyPI} hosts many thousands of other packages for numerical work,
+machine learning, and beyond.
 
 With Galaaz we do not intend to re-implement any of the scientific
 libraries in R, we allow for very tight coupling between the two
@@ -236,77 +271,52 @@ that there is an R engine running.
 
 According to Wikipedia ``Ruby is a dynamic, interpreted, reflective,
 object-oriented, general-purpose programming language. It was designed
-and developed in the mid-1990s by Yukihiro''Matz" Matsumoto in Japan."
+and developed in the mid-1990s by Yukihiro''Matz'' Matsumoto in Japan.''
 It reached high popularity with the development of Ruby on Rails (RoR)
 by David Heinemeier Hansson. RoR is a web application framework first
 released around 2005. It makes extensive use of Ruby's metaprogramming
 features. With RoR, Ruby became very popular. According to
-\href{https://www.tiobe.com/tiobe-index/ruby/}{Ruby's Tiobe index} it
-peeked in popularity around 2008, then declined until 2015 when it
-started picking up again. At the time of this writing (November 2018),
-the Tiobe index puts Ruby in 16th position as most popular language.
+\href{https://www.tiobe.com/tiobe-index/ruby/}{Ruby's place in the TIOBE
+index} it peaked in popularity around 2008, then declined until 2015
+when it started picking up again. Ruby remains a significant language in
+web development and general-purpose scripting.
 
 Python, a language similar to Ruby, ranks 4th in the index. Java, C and
 C++ take the first three positions. Ruby is often criticized for its
 focus on web applications. But Ruby can do
 \href{https://github.com/markets/awesome-ruby}{much more} than just web
-applications. Yet, for scientific computing, Ruby lags way behind Python
-and R. Python has Django framework for web, NumPy for numerical arrays,
-Pandas for data analysis. R is a free software environment for
-statistical computing and graphics with thousands of libraries for data
-analysis.
+applications. Yet, for scientific computing, Ruby lags behind Python and
+R. Python offers Django and similar frameworks for the web, plus NumPy,
+pandas, and a deep catalog of science and ML libraries. R is a free
+software environment for statistical computing and graphics with
+thousands of libraries for data analysis.
 
 Until recently, there was no real perspective for Ruby to bridge this
 gap. Implementing a complete scientific computing infrastructure would
-take too long. Enters \href{https://www.graalvm.org/}{Oracle's GraalVM}:
-
-\begin{quote}
-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:
-
-\begin{itemize}
-\tightlist
-\item
-  That library is not available in my language. I need to rewrite it.
-\item
-  That language would be the perfect fit for my problem, but we cannot
-  run it in our environment.
-\item
-  That problem is already solved in my language, but the language is too
-  slow.
-\end{itemize}
-
-With GraalVM we aim to allow developers to freely choose the right
-language for the task at hand without making compromises.
-\end{quote}
-
-As stated above, GraalVM is a \emph{universal} virtual machine that
-allows Ruby and R (and other languages) to run on the same environment.
-GraalVM allows polyglot applications to \emph{seamlessly} interact with
-one another and pass values from one language to the other. Although a
-great idea, GraalVM still requires application writers to know several
-languages. To eliminate that requirement, we built Galaaz, a gem for
-Ruby, to tightly couple Ruby and R and allow those languages to interact
-in a way that the user will be unaware of such interaction. In other
-words, a Ruby programmer will be able to use all the capabilities of R
-without knowing the R syntax.
-
-Library wrapping is a usual way of bringing features from one language
+take too long.
+
+\textbf{Galaaz 2.0} couples \textbf{JRuby} (Ruby on the JVM) with
+\textbf{GNU R}---the same R you use for CRAN and Bioconductor. Ruby and
+R run in \textbf{separate processes}; the \textbf{Galaaz bridge} sends
+requests to R and returns results to Ruby. From your point of view you
+still write Ruby: \texttt{R.c(...)},
+\texttt{R.library(\textquotesingle{}ggplot2\textquotesingle{})},
+\texttt{\textasciitilde{}:mtcars}, and dplyr-style chains on R objects.
+You do not need to learn R syntax to get a lot done, though reading R
+documentation for individual packages remains useful.
+
+Earlier experiments with Galaaz used Oracle's \textbf{GraalVM} with
+TruffleRuby and FastR so that Ruby and R could share one runtime. That
+path is no longer the focus: \textbf{standard GNU R} gives full
+compatibility with the R package ecosystem (including compiled
+extensions and Bioconductor) while JRuby gives a mature Ruby with
+\textbf{real multithreading} for application and I/O code.
+
+The bridge handles \textbf{communication and typing} between the two
+worlds; large tables can also flow through \textbf{Apache Arrow} on the
+R side when you use the optional helpers described later in this manual.
+
+Library wrapping is a common way to bring features from one language
 into another. To improve performance, Python often wraps more efficient
 C libraries. For the Python developer, the existence of such C libraries
 is hidden. The problem with library wrapping is that for any new
@@ -333,65 +343,314 @@ His name should not be mistaken with Galehaut, a different knight from
 Arthurian legend. 
 \end{verbatim}
 
+\section{\texorpdfstring{Command-line tools
+(\texttt{bin/})}{Command-line tools (bin/)}}\label{command-line-tools-bin}
+
+The Galaaz repository ships many helpers under \textbf{\texttt{bin/}}.
+When working from a \textbf{clone}, call them as
+\textbf{\texttt{bin/\textless{}name\textgreater{}}} from the project
+root (or \texttt{./bin/\textless{}name\textgreater{}}). If you install
+the \textbf{gem}, only a subset is guaranteed on your \texttt{PATH} (see
+the gemspec: \textbf{\texttt{galaaz}}, \textbf{\texttt{gstudio}},
+\textbf{\texttt{gknit}}, \textbf{\texttt{grun}},
+\textbf{\texttt{gknit-draft}}); for development and CI, prefer the
+\textbf{\texttt{bin/}} copies so JVM flags and paths stay correct.
+
+Below, \textbf{current (Galaaz 2.0 + JRuby + GNU R)} means the tool is
+wired to \textbf{\texttt{jruby}} and
+\textbf{\texttt{bin/galaaz\_jruby\_env.inc.sh}} (or equivalent logic in
+Ruby via \texttt{lib/galaaz\_jruby.rb}). \textbf{Legacy} means the
+script still targets \textbf{GraalVM} polyglot Ruby / FastR-era
+invocation and is \textbf{not} expected to work on a typical JRuby-only
+setup.
+
+\textbf{Table layout:} names in the first column are
+\textbf{\texttt{bin/}} filenames (run as
+\texttt{bin/\textless{}name\textgreater{}} from the repo root). Long
+options and examples sit \textbf{outside} the tables so PDF columns stay
+readable.
+
+\begin{verbatim}
+## Warning in styling_latex_scale(out, table_info, "down"): Longtable cannot be
+## resized.
+\end{verbatim}
+
+\begingroup\fontsize{9}{11}\selectfont
+
+\begin{longtable}[t]{>{\raggedright\arraybackslash}p{2.5cm}>{\raggedright\arraybackslash}p{9.5cm}>{\raggedright\arraybackslash}p{2.8cm}}
+\toprule
+Script & Role & 2.0?\\
+\midrule
+galaaz-bootstrap & WSL2 helper: Docker checks; optional TinyTeX or poppler for gKnit PDF. & Yes*\\
+galaaz-jruby & JRuby with repo lib/ on LOAD\_PATH and required JVM flags (e.g. Arrow). & Yes\\
+galaaz\_jruby\_env.inc.sh & Sourced by bash wrappers; sets GALAAZ\_REQUIRED\_JRUBY\_J\_ARGS. & Yes†\\
+install-tinytex & Install TinyTeX for PDF output. & Yes\\
+\bottomrule
+\end{longtable}
+\endgroup{}
+
+* Where WSL/Docker apply. \textbf{\texttt{galaaz-bootstrap} flags:}
+\texttt{-\/-check}, \texttt{-\/-apply}, \texttt{-\/-runtime}
+(\texttt{docker} \textbar{} \texttt{local} \textbar{} \texttt{auto}),
+\texttt{-\/-{[}no-{]}prompt-doc-tools}.
+
+† Not run directly.
+
+\textbf{\texttt{galaaz-jruby} examples} (from repo root):
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{bin/galaaz{-}jruby my\_script.rb}
+\NormalTok{bin/galaaz{-}jruby {-}S rspec}
+\end{Highlighting}
+\end{Shaded}
+
+\subsection{Interactive use, examples, and
+Rake}\label{interactive-use-examples-and-rake}
+
+\begin{verbatim}
+## Warning in styling_latex_scale(out, table_info, "down"): Longtable cannot be
+## resized.
+\end{verbatim}
+
+\begingroup\fontsize{9}{11}\selectfont
+
+\begin{longtable}[t]{>{\raggedright\arraybackslash}p{2.5cm}>{\raggedright\arraybackslash}p{9.5cm}>{\raggedright\arraybackslash}p{2.8cm}}
+\toprule
+Script & Role & 2.0?\\
+\midrule
+gstudio & IRB or Pry with Galaaz preloaded (JRuby + JVM flags). & Yes\\
+run\_example & Run one Ruby file using the same JRuby/JVM setup as tests. & Yes\\
+galaaz & Forward arguments to rake (needs rake; usually JRuby). & Yes\\
+\bottomrule
+\end{longtable}
+\endgroup{}
+
+\subsection{gKnit and document drafts}\label{gknit-and-document-drafts}
+
+\begin{verbatim}
+## Warning in styling_latex_scale(out, table_info, "down"): Longtable cannot be
+## resized.
+\end{verbatim}
+
+\begingroup\fontsize{9}{11}\selectfont
+
+\begin{longtable}[t]{>{\raggedright\arraybackslash}p{2.5cm}>{\raggedright\arraybackslash}p{9.5cm}>{\raggedright\arraybackslash}p{2.8cm}}
+\toprule
+Script & Role & 2.0?\\
+\midrule
+gknit & Knit .Rmd via JRuby and R Markdown render. & Yes\\
+gknit-draft & Drafts from rticles-style templates; wrapper still uses legacy polyglot ruby. & Legacy\\
+gknit-draft.rb & Ruby entry: GKnit.draft (use with JRuby + LOAD\_PATH). & JRuby\\
+gknit\_Rscript & Polyglot Rscript launcher; hard-coded LOAD\_PATH sample. & No\\
+\bottomrule
+\end{longtable}
+\endgroup{}
+
+\textbf{\texttt{gknit} CLI} (see \texttt{gknit\ -h}):
+\texttt{-\/-output\_format}, \texttt{-\/-output\_file},
+\texttt{-\/-output\_dir}, \texttt{-\/-bridge\_timeout\_sec},
+\texttt{-\/-callback\_timeout\_ms}. If \texttt{-\/-output\_format} is
+omitted, the \textbf{first} YAML \texttt{output:} target wins.
+
+Prefer \textbf{\texttt{galaaz-jruby}} for \textbf{\texttt{gknit-draft}}
+workflows until that wrapper matches the \textbf{\texttt{gknit}} stack.
+
+\subsection{Tests}\label{tests}
+
+\begin{verbatim}
+## Warning in styling_latex_scale(out, table_info, "down"): Longtable cannot be
+## resized.
+\end{verbatim}
+
+\begingroup\fontsize{9}{11}\selectfont
+
+\begin{longtable}[t]{>{\raggedright\arraybackslash}p{2.5cm}>{\raggedright\arraybackslash}p{9.5cm}>{\raggedright\arraybackslash}p{2.8cm}}
+\toprule
+Script & Role & 2.0?\\
+\midrule
+run\_rspec & Top-level specs/*\_spec.rb with spec\_helper (see docs/testing.md). & Yes\\
+run\_all\_rspec & Compile ext/new\_bridge; run specs/ and new\_bridge\_specs/ together. & Yes\\
+run\_slow\_rspec & Suites under slow-specs/ (read script header for spec\_helper). & Yes\\
+run\_old\_rspec & Legacy suites under old\_specs/. & Yes\\
+run\_rspec\_subset & Numbered subset 1–18 (Documentation/Spec\_Subsets.md). & Yes\\
+\bottomrule
+\end{longtable}
+\endgroup{}
+
+\subsection{Other}\label{other}
+
+\begin{verbatim}
+## Warning in styling_latex_scale(out, table_info, "down"): Longtable cannot be
+## resized.
+\end{verbatim}
+
+\begingroup\fontsize{9}{11}\selectfont
+
+\begin{longtable}[t]{>{\raggedright\arraybackslash}p{2.5cm}>{\raggedright\arraybackslash}p{9.5cm}>{\raggedright\arraybackslash}p{2.8cm}}
+\toprule
+Script & Role & 2.0?\\
+\midrule
+grun & Graal-era launcher: polyglot ruby with --jvm. Use galaaz-jruby -S instead. & No\\
+gstudio\_irb.rb / gstudio\_pry.rb & Loaded by gstudio; not meant to be run standalone. & Yes\\
+\bottomrule
+\end{longtable}
+\endgroup{}
+
+For day-to-day \textbf{2.0} use, rely on
+\textbf{\texttt{bin/galaaz-jruby}}, \textbf{\texttt{bin/gstudio}},
+\textbf{\texttt{bin/gknit}}, \textbf{\texttt{bin/run\_example}},
+\textbf{\texttt{bin/run\_rspec}} /
+\textbf{\texttt{bin/run\_all\_rspec}}, and
+\textbf{\texttt{bin/galaaz-bootstrap}} on WSL when using Dockerized R.
+Treat \textbf{\texttt{grun}}, \textbf{\texttt{gknit\_Rscript}}, and the
+polyglot \textbf{\texttt{ruby}} invocation in
+\textbf{\texttt{gknit-draft}} as \textbf{legacy} until they are ported
+to the same JRuby path as \textbf{\texttt{gknit}}.
+
 \section{System Compatibility}\label{system-compatibility}
 
+Typical development and CI targets:
+
 \begin{itemize}
 \tightlist
 \item
-  Oracle Linux 7
-\item
-  Ubuntu 18.04 LTS
+  \textbf{Linux} --- recent Ubuntu LTS or comparable distributions
+  (x86\_64).
 \item
-  Ubuntu 16.04 LTS
+  \textbf{macOS} --- recent releases with JRuby and GNU R available.
 \item
-  Fedora 28
-\item
-  macOS 10.14 (Mojave)
-\item
-  macOS 10.13 (High Sierra)
+  \textbf{Windows} --- use \textbf{WSL2} (same Linux stack as above);
+  native Windows is not the primary target.
 \end{itemize}
 
+The native \textbf{gatekeeper} component under \texttt{ext/new\_bridge}
+is built with \texttt{make} and a C++ toolchain; see the project
+\texttt{README} if compilation fails on your platform.
+
 \section{Dependencies}\label{dependencies}
 
 \begin{itemize}
 \tightlist
 \item
-  TruffleRuby
+  \textbf{JRuby} --- Ruby implementation on the JVM (Galaaz 2.0 is
+  developed and tested with JRuby).
+\item
+  A \textbf{Java runtime} (JDK) compatible with your JRuby version.
+\item
+  \textbf{GNU R} --- \texttt{R} on your \texttt{PATH}, with ability to
+  install packages (CRAN / Bioconductor as needed).
+\item
+  \textbf{Ruby gems} --- from the Galaaz repository,
+  \texttt{bundle\ install} (see the \texttt{Gemfile} / gemspec).
 \item
-  FastR
+  Optional: \textbf{Docker} --- if you run R in a container (common on
+  WSL2); see bootstrap below.
+\item
+  Optional R packages for examples in this manual ---
+  e.g.~\texttt{ggplot2}, \texttt{dplyr}, \texttt{knitr},
+  \texttt{kableExtra}, \texttt{arrow}, Bioconductor tools such as
+  \textbf{DESeq2} (installed the usual R way).
 \end{itemize}
 
 \section{Installation}\label{installation}
 
-\begin{itemize}
+From a clone of the Galaaz repository:
+
+\begin{enumerate}
+\def\labelenumi{\arabic{enumi}.}
 \tightlist
 \item
-  Install GrallVM (\url{http://www.graalvm.org/})
+  Install \textbf{JRuby} and \textbf{GNU R} using your preferred package
+  manager or Ruby version manager.
 \item
-  Install Ruby (gu install Ruby)
+  Install \textbf{bundler} if needed, then run
+  \textbf{\texttt{bundle\ install}} in the repository root.
 \item
-  Install FastR (gu install R)
+  Build the bridge native code:
+  \textbf{\texttt{make\ -C\ ext/new\_bridge\ all}} (or
+  \textbf{\texttt{rake\ compile\_gatekeeper}}).
 \item
-  Install rake if you want to run the specs and examples (gem install
-  rake)
-\end{itemize}
+  Run Ruby scripts with the project load path and JVM flags the project
+  expects --- the \textbf{\texttt{bin/galaaz-jruby}} wrapper sources
+  \textbf{\texttt{bin/galaaz\_jruby\_env.inc.sh}} and adds
+  \textbf{\texttt{-I\ lib}}. This matters especially for \textbf{Apache
+  Arrow} integration (see \texttt{docs/testing.md}).
+\item
+  Ensure \textbf{\texttt{R}} starts GNU R and can install packages
+  (network access to CRAN mirrors when you first call
+  \texttt{R.install\_and\_loads}).
+\end{enumerate}
 
-\section{Usage}\label{usage}
+For \textbf{gKnit}, \textbf{knitr}, \textbf{rmarkdown}, and LaTeX (PDF
+output), install the corresponding R packages and a TeX distribution if
+you need PDF; the repository includes helpers such as
+\textbf{\texttt{bin/install-tinytex}} where appropriate.
 
-\begin{itemize}
+A \textbf{table of all \texttt{bin/} scripts} (bootstrap, JRuby wrapper,
+gstudio, gknit, test runners, and which ones are legacy) is in the
+section \textbf{Command-line tools (\texttt{bin/})} earlier in this
+manual.
+
+\subsection{Windows + WSL2 (optional: Docker / R in a
+container)}\label{windows-wsl2-optional-docker-r-in-a-container}
+
+If you run Galaaz on Windows through WSL2 and want containerized R
+instances, Docker Desktop is the supported setup.
+
+\begin{enumerate}
+\def\labelenumi{\arabic{enumi}.}
 \tightlist
 \item
-  Interactive shell: use `gstudio' on the command line
-\end{itemize}
+  Install Docker Desktop on Windows:
+
+  \begin{itemize}
+  \tightlist
+  \item
+    \url{https://www.docker.com/products/docker-desktop/}
+  \end{itemize}
+\item
+  Open Docker Desktop and enable WSL integration:
+
+  \begin{itemize}
+  \tightlist
+  \item
+    Settings \textgreater{} Resources \textgreater{} WSL Integration
+  \item
+    Enable integration for your target distro
+  \item
+    Apply \& Restart Docker Desktop
+  \end{itemize}
+\item
+  In WSL, run Galaaz bootstrap:
+\end{enumerate}
 
 \begin{quote}
-gstudio
+ruby bin/galaaz-bootstrap --apply ruby bin/galaaz-bootstrap --check
 \end{quote}
 
+Expected result: - docker CLI available - docker compose available -
+docker daemon reachable (\texttt{docker\ info} works)
+
+If bootstrap reports daemon is unreachable, check Docker Desktop is
+running and WSL integration is enabled for the distro where Galaaz is
+installed.
+
+\section{Usage}\label{usage}
+
+\begin{itemize}
+\item
+  Interactive shell: use `gstudio' on the command line
+
+  \begin{quote}
+  gstudio
+  \end{quote}
+\end{itemize}
+
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{  vec = R.c(}\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{3}\NormalTok{, }\DecValTok{4}\NormalTok{)}
-\NormalTok{  puts vec}
+\NormalTok{  vec }\OperatorTok{=} \ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{3}\NormalTok{, }\DecValTok{4}\NormalTok{)}
+  \FunctionTok{puts}\NormalTok{ vec}
 \end{Highlighting}
 \end{Shaded}
 
@@ -400,68 +659,182 @@ gstudio
 \end{verbatim}
 
 \begin{itemize}
-\tightlist
 \item
   Run all specs
-\end{itemize}
 
-\begin{quote}
-galaaz specs:all
-\end{quote}
-
-\begin{itemize}
-\tightlist
+  \begin{quote}
+  galaaz specs:all
+  \end{quote}
 \item
   Run graphics slideshow (80+ graphics)
+
+  \begin{quote}
+  galaaz sthda:all
+  \end{quote}
+\item
+  Run labs from Introduction to Statistical Learning with R
+
+  \begin{quote}
+  galaaz islr:all
+  \end{quote}
+\item
+  See all available examples
+
+  \begin{quote}
+  galaaz -T
+  \end{quote}
+
+  Shows a list with all available executable tasks. To execute a task,
+  substitute the `rake' word in the list with `galaaz'. For instance,
+  the following line shows up after `galaaz -T'
+
+  rake master\_list:scatter\_plot \# scatter\_plot from:\ldots.
+
+  execute
+
+  \begin{quote}
+  galaaz master\_list:scatter\_plot
+  \end{quote}
 \end{itemize}
 
-\begin{quote}
-galaaz sthda:all
-\end{quote}
+\section{JRuby, multithreading, and the R
+bridge}\label{jruby-multithreading-and-the-r-bridge}
 
-\begin{itemize}
+Galaaz 2.0 runs Ruby on \textbf{JRuby}, so your application can use
+\textbf{real parallel threads} for I/O-bound work (HTTP clients,
+database connections, message consumers, and so on). R itself is still
+executed in a \textbf{single GNU R process} behind the Galaaz bridge.
+
+When several Ruby threads call into R at the same time, the bridge
+\textbf{serializes} those calls: each request is matched to a reply
+using an internal per-call \textbf{queue}, so you do not need to add
+your own mutex around every \texttt{R.foo} from application threads.
+(You should still use normal Ruby synchronization when \textbf{Ruby}
+data structures are shared between threads---for example, when appending
+rows from each thread into a shared array before sending them to R.)
+
+A practical pattern is:
+
+\begin{enumerate}
+\def\labelenumi{\arabic{enumi}.}
 \tightlist
 \item
-  Run labs from Introduction to Statistical Learning with R
-\end{itemize}
+  Use threads (or a connection pool) to read from \textbf{multiple
+  databases or shards} in parallel.
+\item
+  Merge the rows in Ruby under a \texttt{Mutex} if you collect into one
+  structure.
+\item
+  Hand the merged table to R \textbf{once} (for example with
+  \texttt{R::Arrow.from\_ruby\_batches} and dplyr, or by building a data
+  frame) so heavy statistics run in R with fewer bridge round-trips.
+\end{enumerate}
 
-\begin{quote}
-galaaz islr:all
-\end{quote}
+A runnable sketch lives in
+\texttt{examples/multithread\_shards\_to\_r/shards\_to\_r.rb} (simulated
+shard queries; swap in your DB driver). For concurrency tests on the
+bridge itself, see \texttt{specs/bridge\_concurrent\_spec.rb} and
+\texttt{specs/arrow\_from\_ruby\_batches\_spec.rb}.
+
+\subsection{Long-running R calls and a completion
+block}\label{long-running-r-calls-and-a-completion-block}
+
+For R work that can take a long time, the bridge can avoid a Ruby-side
+\textbf{wait timeout} by scheduling the call and resuming in a
+\textbf{block} when the \texttt{RET} arrives.
 
 \begin{itemize}
 \tightlist
 \item
-  See all available examples
+  \textbf{\texttt{R.eval\_r\_async(code,\ timeout:\ nil)\ \{\ \textbar{}result\textbar{}\ ...\ \}}}
+  --- string eval; on success, \texttt{result.value} is the same
+  formatted string as \textbf{\texttt{R.eval\_r}} (use
+  \texttt{timeout:\ nil} for no Ruby-side limit).
+\item
+  \textbf{\texttt{R::Async.\textless{}rname\textgreater{}(...)\ \{\ \textbar{}result\textbar{}\ ...\ \}}}
+  --- same dispatch as
+  \textbf{\texttt{R.\textless{}rname\textgreater{}(...)}}, but async; on
+  success, \texttt{result.value} is an \textbf{\texttt{R::Object}} (or
+  unboxed Ruby value / Symbol), like synchronous
+  \textbf{\texttt{R.\textless{}rname\textgreater{}}}. Optional keyword
+  \textbf{\texttt{timeout:}} applies a Ruby-side wait limit (completion
+  receives \textbf{\texttt{NewBridge::SessionClient::TimeoutError}} if R
+  is too slow).
 \end{itemize}
 
-\begin{quote}
-galaaz -T
-\end{quote}
-
-Shows a list with all available executalbe tasks. To execute a task,
-substitute the `rake' word in the list with `galaaz'. For instance, the
-following line shows up after `galaaz -T'
+\textbf{Important:}
+\textbf{\texttt{R.foo(...)\ \{\ \textbar{}x\textbar{}\ \}}} is already
+used for dplyr-style scopes (\texttt{R::Support.new\_scope}), so async R
+calls must use \textbf{\texttt{R::Async}} or
+\textbf{\texttt{R.eval\_r\_async}}, not a bare \textbf{\texttt{R.foo}
+with a block.}
+
+\texttt{NewBridge::EvalResult} exposes \textbf{\texttt{\#ok?}},
+\textbf{\texttt{\#value}}, and \textbf{\texttt{\#error}}. The completion
+block runs on a \textbf{background thread} (not the bridge reader
+thread).
+
+The example below is \textbf{plain Ruby} (no Rails). The R snippet
+sleeps (standing in for heavy work) and then returns an integer so the
+success branch shows a \textbf{non-nil} value. (\texttt{Sys.sleep} alone
+returns \textbf{NULL} in R; on success \textbf{\texttt{result.value}} is
+then \textbf{\texttt{nil}} in Ruby---that is expected, not a bridge
+error.)
 
-rake master\_list:scatter\_plot \# scatter\_plot from:\ldots{}.
+\begin{Shaded}
+\begin{Highlighting}[]
+\FunctionTok{require} \VerbatimStringTok{\textquotesingle{}thread\textquotesingle{}}
+
+\NormalTok{completion }\OperatorTok{=} \DataTypeTok{Queue}\AttributeTok{.new}
+
+\ConstantTok{R}\AttributeTok{.eval\_r\_async}\NormalTok{(}\VerbatimStringTok{\textquotesingle{}(\{ Sys.sleep(0.3); 42L \})\textquotesingle{}}\NormalTok{, }\WarningTok{timeout:} \DecValTok{nil}\NormalTok{) }\ControlFlowTok{do} \OperatorTok{|}\NormalTok{result}\OperatorTok{|}
+  \ControlFlowTok{if}\NormalTok{ result}\AttributeTok{.ok?}
+    \FunctionTok{puts} \StringTok{"[completion] R finished; eval\_r{-}style value: }\SpecialCharTok{\#\{}\NormalTok{result}\AttributeTok{.value.inspect}\SpecialCharTok{\}}\StringTok{"}
+  \ControlFlowTok{else}
+    \FunctionTok{puts} \StringTok{"[completion] R/bridge error: }\SpecialCharTok{\#\{}\NormalTok{result}\AttributeTok{.error.class}\SpecialCharTok{\}}\StringTok{: }\SpecialCharTok{\#\{}\NormalTok{result}\AttributeTok{.error.message}\SpecialCharTok{\}}\StringTok{"}
+  \ControlFlowTok{end}
+\NormalTok{  completion}\AttributeTok{.push}\NormalTok{(}\WarningTok{:done}\NormalTok{)}
+\ControlFlowTok{end}
+
+\DecValTok{3}\AttributeTok{.times} \ControlFlowTok{do} \OperatorTok{|}\NormalTok{i}\OperatorTok{|}
+  \FunctionTok{puts} \StringTok{"[main] other Ruby work step }\SpecialCharTok{\#\{}\NormalTok{i }\OperatorTok{+} \DecValTok{1}\SpecialCharTok{\}}\StringTok{"}
+  \FunctionTok{sleep} \FloatTok{0.05}
+\ControlFlowTok{end}
+
+\NormalTok{completion}\AttributeTok{.pop}
+\FunctionTok{puts} \StringTok{"[main] R completion has run; exiting."}
+\end{Highlighting}
+\end{Shaded}
 
-execute
+\begin{verbatim}
+## [main] other Ruby work step 1
+## [main] other Ruby work step 2
+## [main] other Ruby work step 3
+## [completion] R finished; eval_r-style value: "[1] 42"
+## [main] R completion has run; exiting.
+\end{verbatim}
 
-\begin{quote}
-galaaz master\_list:scatter\_plot
-\end{quote}
+In a \textbf{web application}, the HTTP response usually ends before R
+finishes, so you would not \texttt{Queue\#pop} in the controller; you
+would persist an identifier, let the completion block write the outcome
+to storage, and notify the client (poll, WebSocket, Turbo Stream, etc.).
+The plain Ruby pattern above is only to show \textbf{when} the result
+exists (inside the block, or after data written there is observed
+elsewhere). Runnable specs live in
+\textbf{\texttt{new\_bridge\_specs/eval\_r\_async\_spec.rb}}.
 
 \section{Accessing R from Ruby}\label{accessing-r-from-ruby}
 
-One of the nice aspects of Galaaz on GraalVM, is that variables and
-functions defined in R, can be easily accessed from Ruby. For instance,
-to access the `mtcars' data frame from R in Ruby, we use the `:mtcar'
-symbol preceded by the `\textasciitilde{}' operator, thus
-`\textasciitilde{}:r\_vec' retrieves the value of the `mtcars' variable.
+One of the nice aspects of Galaaz is that variables and functions
+defined in R can be easily accessed from Ruby. For instance, to access
+the \texttt{mtcars} data frame from R in Ruby, we use the symbol
+\texttt{:mtcars} preceded by the \texttt{\textasciitilde{}} operator:
+\texttt{\textasciitilde{}:mtcars} retrieves the value of the
+\texttt{mtcars} object in R.
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts ~}\StringTok{:mtcars}
+\FunctionTok{puts} \OperatorTok{\textasciitilde{}}\WarningTok{:mtcars}
 \end{Highlighting}
 \end{Shaded}
 
@@ -501,13 +874,13 @@ symbol preceded by the `\textasciitilde{}' operator, thus
 ## Volvo 142E          21.4   4 121.0 109 4.11 2.780 18.60  1  1    4    2
 \end{verbatim}
 
-To access an R function from Ruby, the R function needs to be preceeded
-by `R.' scoping. Bellow we see and example of creating a R::Vector by
-calling the `c' R function
+To access an R function from Ruby, the R function needs to be preceded
+by \texttt{R.} scoping. Below we see an example of creating a R::Vector
+by calling the `c' R function
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts vec = R.c(}\FloatTok{1.0}\NormalTok{, }\FloatTok{2.0}\NormalTok{, }\FloatTok{3.0}\NormalTok{, }\FloatTok{4.0}\NormalTok{)}
+\FunctionTok{puts}\NormalTok{ vec }\OperatorTok{=} \ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\FloatTok{1.0}\NormalTok{, }\FloatTok{2.0}\NormalTok{, }\FloatTok{3.0}\NormalTok{, }\FloatTok{4.0}\NormalTok{)}
 \end{Highlighting}
 \end{Shaded}
 
@@ -519,7 +892,7 @@ Note that `vec' is an object of type R::Vector:
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts vec.class}
+\FunctionTok{puts}\NormalTok{ vec}\AttributeTok{.class}
 \end{Highlighting}
 \end{Shaded}
 
@@ -534,12 +907,12 @@ R::Object:
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts vec.rclass}
+\FunctionTok{puts}\NormalTok{ vec}\AttributeTok{.rclass}
 \end{Highlighting}
 \end{Shaded}
 
 \begin{verbatim}
-## [1] "numeric"
+## numeric
 \end{verbatim}
 
 When working with R::Object(s), it is possible to use the `.' operator
@@ -552,7 +925,7 @@ size one vector):
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts R.c(vec, }\DecValTok{10}\NormalTok{, }\DecValTok{20}\NormalTok{, }\DecValTok{30}\NormalTok{)}
+\FunctionTok{puts} \ConstantTok{R}\AttributeTok{.c}\NormalTok{(vec, }\DecValTok{10}\NormalTok{, }\DecValTok{20}\NormalTok{, }\DecValTok{30}\NormalTok{)}
 \end{Highlighting}
 \end{Shaded}
 
@@ -564,7 +937,7 @@ The call above to the `c' function can also be done using `.' notation:
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts vec.c(}\DecValTok{10}\NormalTok{, }\DecValTok{20}\NormalTok{, }\DecValTok{30}\NormalTok{)}
+\FunctionTok{puts}\NormalTok{ vec}\AttributeTok{.c}\NormalTok{(}\DecValTok{10}\NormalTok{, }\DecValTok{20}\NormalTok{, }\DecValTok{30}\NormalTok{)}
 \end{Highlighting}
 \end{Shaded}
 
@@ -572,12 +945,12 @@ The call above to the `c' function can also be done using `.' notation:
 ## [1]  1  2  3  4 10 20 30
 \end{verbatim}
 
-We will talk about vector indexing in a latter section. But notice here
+We will talk about vector indexing in a later section. But notice here
 that indexing an R::Vector will return another R::Vector:
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts vec[}\DecValTok{1}\NormalTok{]}
+\FunctionTok{puts}\NormalTok{ vec}\KeywordTok{[}\DecValTok{1}\KeywordTok{]}
 \end{Highlighting}
 \end{Shaded}
 
@@ -587,12 +960,12 @@ that indexing an R::Vector will return another R::Vector:
 
 Sometimes we want to index an R::Object and get back a Ruby object that
 is not wrapped in an R::Object, but the native Ruby object. For this, we
-can index the R object with the `\textgreater{}\textgreater{}' operator:
+can index the R object with the `\textgreater\textgreater{}' operator:
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts vec >> }\DecValTok{0}
-\NormalTok{puts vec >> }\DecValTok{2}
+\FunctionTok{puts}\NormalTok{ vec }\OperatorTok{\textgreater{}\textgreater{}} \DecValTok{0}
+\FunctionTok{puts}\NormalTok{ vec }\OperatorTok{\textgreater{}\textgreater{}} \DecValTok{2}
 \end{Highlighting}
 \end{Shaded}
 
@@ -607,7 +980,7 @@ here is an example of creating a `list' with named elements:
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts R.list(}\StringTok{first_name: "Rodrigo"}\NormalTok{, }\StringTok{last_name: "Botafogo"}\NormalTok{)}
+\FunctionTok{puts} \ConstantTok{R}\AttributeTok{.list}\NormalTok{(}\WarningTok{first\_name:} \StringTok{"Rodrigo"}\NormalTok{, }\WarningTok{last\_name:} \StringTok{"Botafogo"}\NormalTok{)}
 \end{Highlighting}
 \end{Shaded}
 
@@ -627,26 +1000,23 @@ element of our previously created vector:
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts vec.map \{ |x| x + }\DecValTok{2}\NormalTok{ \}}
+\FunctionTok{puts}\NormalTok{ vec}\AttributeTok{.map} \OperatorTok{\{} \OperatorTok{|}\NormalTok{x}\OperatorTok{|}\NormalTok{ x }\OperatorTok{+} \DecValTok{2} \OperatorTok{\}}
 \end{Highlighting}
 \end{Shaded}
 
 \begin{verbatim}
-## [1] 3
-## [1] 4
-## [1] 5
-## [1] 6
+## [1] 3 4 5 6
 \end{verbatim}
 
 \section{gKnitting a Document}\label{gknitting-a-document}
 
-This manual has been formatted usign gKnit. gKnit uses Knitr and R
-markdown to knit a document in Ruby or R and output it in any of the
-available formats for R markdown. gKnit runs atop of GraalVM, and
-Galaaz. In gKnit, Ruby variables are persisted between chunks, making it
-an ideal solution for literate programming. Also, since it is based on
-Galaaz, Ruby chunks can have access to R variables and Polyglot
-Programming with Ruby and R is quite natural.
+This manual has been formatted using gKnit. gKnit uses knitr and R
+Markdown to knit a document in Ruby or R and output it in any of the
+available formats for R Markdown. gKnit runs with \textbf{JRuby},
+\textbf{GNU R}, and Galaaz. In gKnit, Ruby variables are persisted
+between chunks, making it an ideal solution for literate programming.
+Also, since it is based on Galaaz, Ruby chunks can have access to R
+variables and combining Ruby with R in one document is natural.
 
 The idea of ``literate programming'' was first introduced by Donald
 Knuth in the 1980's (Knuth 1984). The main intention of this approach
@@ -664,8 +1034,8 @@ in a single document or set of documents that when distributed to peers
 could be rerun generating the same output and reports.
 
 The R community has put a great deal of effort in reproducible research.
-In 2002, Sweave was introduced and it allowed mixing R code with Latex
-generating high quality PDF documents. A Sweave document could include
+In 2002, Sweave was introduced and it allowed mixing R code with LaTeX,
+generating high-quality PDF documents. A Sweave document could include
 code, the results of executing the code, graphics and text such that it
 contained the whole narrative to reproduce the research. In 2012, Knitr,
 developed by Yihui Xie from RStudio was released to replace Sweave and
@@ -674,8 +1044,8 @@ packages that were necessary for Sweave.
 
 With Knitr, \textbf{R markdown} was also developed, an extension to the
 Markdown format. With \textbf{R markdown} and Knitr it is possible to
-generate reports in a multitude of formats such as HTML, markdown,
-Latex, PDF, dvi, etc. \textbf{R markdown} also allows the use of
+generate reports in a multitude of formats such as HTML, Markdown,
+LaTeX, PDF, DVI, etc. \textbf{R markdown} also allows the use of
 multiple programming languages such as R, Ruby, Python, etc. in the same
 document.
 
@@ -701,8 +1071,8 @@ binary format:
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{lst = R.list(}\StringTok{a: }\DecValTok{1}\NormalTok{, }\StringTok{b: }\DecValTok{2}\NormalTok{, }\StringTok{c: }\DecValTok{3}\NormalTok{)}
-\NormalTok{lst.saveRDS(}\StringTok{"lst.rds"}\NormalTok{)}
+\NormalTok{lst }\OperatorTok{=} \ConstantTok{R}\AttributeTok{.list}\NormalTok{(}\WarningTok{a:} \DecValTok{1}\NormalTok{, }\WarningTok{b:} \DecValTok{2}\NormalTok{, }\WarningTok{c:} \DecValTok{3}\NormalTok{)}
+\NormalTok{lst}\AttributeTok{.saveRDS}\NormalTok{(}\StringTok{"lst.rds"}\NormalTok{)}
 \end{Highlighting}
 \end{Shaded}
 
@@ -711,8 +1081,8 @@ back it's value
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{lst = R.readRDS(}\StringTok{"lst.rds"}\NormalTok{)}
-\NormalTok{puts lst}
+\NormalTok{lst }\OperatorTok{=} \ConstantTok{R}\AttributeTok{.readRDS}\NormalTok{(}\StringTok{"lst.rds"}\NormalTok{)}
+\FunctionTok{puts}\NormalTok{ lst}
 \end{Highlighting}
 \end{Shaded}
 
@@ -732,18 +1102,18 @@ and reuse between chunks. Clearly, such an approach becomes quickly
 unmanageable. Probably, because of this problem, it is very rare to see
 any \textbf{R markdown} document in the Ruby community.
 
-When variables can be used accross chunks, then no overhead is needed:
+When variables can be used across chunks, then no overhead is needed:
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{lst = R.list(}\StringTok{a: }\DecValTok{1}\NormalTok{, }\StringTok{b: }\DecValTok{2}\NormalTok{, }\StringTok{c: }\DecValTok{3}\NormalTok{)}
-\CommentTok{# any other code can be added here}
+\NormalTok{lst }\OperatorTok{=} \ConstantTok{R}\AttributeTok{.list}\NormalTok{(}\WarningTok{a:} \DecValTok{1}\NormalTok{, }\WarningTok{b:} \DecValTok{2}\NormalTok{, }\WarningTok{c:} \DecValTok{3}\NormalTok{)}
+\CommentTok{\# any other code can be added here}
 \end{Highlighting}
 \end{Shaded}
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts lst}
+\FunctionTok{puts}\NormalTok{ lst}
 \end{Highlighting}
 \end{Shaded}
 
@@ -759,13 +1129,14 @@ When variables can be used accross chunks, then no overhead is needed:
 \end{verbatim}
 
 In the Python community, the same effort to have code and text in an
-integrated environment started around the first decade of 2000. In 2006
-iPython 0.7.2 was released. In 2014, Fernando Pérez, spun off project
-Jupyter from iPython creating a web-based interactive computation
-environment. Jupyter can now be used with many languages, including Ruby
-with the iruby gem (\url{https://github.com/SciRuby/iruby}). In order to
-have multiple languages in a Jupyter notebook the SoS kernel was
-developed (\url{https://vatlab.github.io/sos-docs/}).
+integrated environment started around the first decade of the 2000s. In
+2006 IPython 0.7.2 was released. In 2014, Fernando Pérez spun off the
+Jupyter project from IPython, creating a web-based interactive
+computation environment. Jupyter can now be used with many languages,
+including Ruby with the iruby gem
+(\url{https://github.com/SciRuby/iruby}). In order to have multiple
+languages in a Jupyter notebook the SoS kernel was developed
+(\url{https://vatlab.github.io/sos-docs/}).
 
 \subsection{\texorpdfstring{gKnit and \textbf{R
 markdown}}{gKnit and R markdown}}\label{gknit-and-r-markdown}
@@ -778,8 +1149,10 @@ in a single document, text and code.
 
 In gKnit, Ruby variables are persisted between chunks, making it an
 ideal solution for literate programming in this language. Also, since it
-is based on Galaaz, Ruby chunks can have access to R variables and
-Polyglot Programming with Ruby and R is quite natural.
+is based on Galaaz, Ruby chunks can access R variables
+(\texttt{\textasciitilde{}:name}, \texttt{R.*}) through the
+\textbf{Galaaz bridge} while knitr drives \textbf{GNU R}---no GraalVM
+polyglot runtime is required.
 
 This is not a blog post on \textbf{R markdown}, and the interested user
 is directed to the following links for detailed information on its
@@ -800,7 +1173,7 @@ markdown}, so the user can start gKnitting Ruby and R documents quickly.
 
 An \textbf{R markdown} document should start with a Yaml header and be
 stored in a file with `.Rmd' extension. This document has the following
-header for gKitting an HTML document.
+header for gKnitting an HTML document.
 
 \begin{verbatim}
 ---
@@ -808,7 +1181,7 @@ title: "How to do reproducible research in Ruby with gKnit"
 author: 
     - "Rodrigo Botafogo"
     - "Daniel Mossé - University of Pittsburgh"
-tags: [Tech, Data Science, Ruby, R, GraalVM]
+tags: [Tech, Data Science, Ruby, R, JRuby, Galaaz]
 date: "20/02/2019"
 output:
   html_document:
@@ -825,6 +1198,73 @@ For more information on the options in the Yaml header,
 \href{https://bookdown.org/yihui/rmarkdown/html-document.html}{check
 here}.
 
+\subsection{Choosing the output format when calling
+gknit}\label{choosing-the-output-format-when-calling-gknit}
+
+Yes: you can select the render target on the \textbf{command line}.
+\textbf{\texttt{bin/gknit}} (or \textbf{\texttt{gknit}} on your
+\texttt{PATH}) forwards options to \textbf{\texttt{rmarkdown::render}}
+via \textbf{\texttt{R::Rmarkdown.render}}.
+
+\begin{itemize}
+\tightlist
+\item
+  \textbf{\texttt{-\/-output\_format\ FORMAT}} --- name of the format,
+  as in the YAML \texttt{output:} block. Examples:
+
+  \begin{itemize}
+  \tightlist
+  \item
+    \textbf{\texttt{html\_document}} --- HTML (often the default you
+    list first under \texttt{output:}).
+  \item
+    \textbf{\texttt{pdf\_document}} --- PDF (you need a working LaTeX
+    setup, e.g.~TinyTeX; see \textbf{\texttt{bin/install-tinytex}}).
+  \item
+    \textbf{\texttt{md\_document}}, \textbf{\texttt{github\_document}},
+    or any other format defined in your YAML.
+  \item
+    \textbf{\texttt{all}} --- render \textbf{every} format declared
+    under \texttt{output:} in the document (same idea as in R Markdown).
+  \end{itemize}
+\end{itemize}
+
+If you \textbf{omit} \textbf{\texttt{-\/-output\_format}}, gknit passes
+\textbf{\texttt{NULL}} for the format argument. In that case
+\textbf{rmarkdown} uses the \textbf{first} format listed under
+\textbf{\texttt{output:}} in the YAML (and if none is specified there,
+behavior follows the usual rmarkdown defaults, typically HTML).
+
+Other useful flags:
+
+\begin{itemize}
+\tightlist
+\item
+  \textbf{\texttt{-\/-output\_file\ NAME}} --- output file name
+  (optional path; see also \textbf{\texttt{-\/-output\_dir}}).
+\item
+  \textbf{\texttt{-\/-output\_dir\ DIR}} --- directory for the rendered
+  file (created if missing).
+\item
+  \textbf{\texttt{-\/-bridge\_timeout\_sec}} /
+  \textbf{\texttt{-\/-callback\_timeout\_ms}} --- longer R or install
+  steps (see elsewhere in this manual).
+\end{itemize}
+
+Examples (run from the directory where paths make sense, or use absolute
+paths):
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{bin/gknit blogs/manual/manual.Rmd}
+\NormalTok{bin/gknit {-}{-}output\_format html\_document blogs/manual/manual.Rmd}
+\NormalTok{bin/gknit {-}{-}output\_format pdf\_document blogs/manual/manual.Rmd}
+\NormalTok{bin/gknit {-}{-}output\_format all blogs/manual/manual.Rmd}
+\end{Highlighting}
+\end{Shaded}
+
+Use \textbf{\texttt{gknit\ -h}} for the full option list.
+
 \subsection{\texorpdfstring{\textbf{R Markdown}
 formatting}{R Markdown formatting}}\label{r-markdown-formatting}
 
@@ -870,8 +1310,8 @@ Running and executing Ruby and R code is actually what really interests
 us is this blog.\\
 Inserting a code chunk is done by adding code in a block delimited by
 three back ticks followed by an open curly brace (`\{') followed with
-the engine name (r, ruby, rb, include, \ldots{}), an any optional
-chunk\_label and options, as shown bellow:
+the engine name (r, ruby, rb, include, \ldots), an any optional
+chunk\_label and options, as shown below:
 
 \begin{verbatim}
 ```{engine_name [chunk_label], [chunk_options]}
@@ -894,8 +1334,8 @@ the result will be:
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{vec <-}\StringTok{ }\KeywordTok{c}\NormalTok{(}\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{3}\NormalTok{)}
-\KeywordTok{print}\NormalTok{(vec)}
+\NormalTok{vec }\OtherTok{\textless{}{-}} \FunctionTok{c}\NormalTok{(}\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{3}\NormalTok{)}
+\FunctionTok{print}\NormalTok{(vec)}
 \end{Highlighting}
 \end{Shaded}
 
@@ -945,10 +1385,10 @@ longer.
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{r_vec <-}\StringTok{ }\KeywordTok{c}\NormalTok{(}\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{3}\NormalTok{, }\DecValTok{4}\NormalTok{, }\DecValTok{5}\NormalTok{)}
+\NormalTok{r\_vec }\OtherTok{\textless{}{-}} \FunctionTok{c}\NormalTok{(}\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{3}\NormalTok{, }\DecValTok{4}\NormalTok{, }\DecValTok{5}\NormalTok{)}
 
-\NormalTok{reduce_sum <-}\StringTok{ }\ControlFlowTok{function}\NormalTok{(...) \{}
-  \KeywordTok{Reduce}\NormalTok{(sum, }\KeywordTok{as.list}\NormalTok{(...))}
+\NormalTok{reduce\_sum }\OtherTok{\textless{}{-}} \ControlFlowTok{function}\NormalTok{(...) \{}
+  \FunctionTok{Reduce}\NormalTok{(sum, }\FunctionTok{as.list}\NormalTok{(...))}
 \NormalTok{\}}
 \end{Highlighting}
 \end{Shaded}
@@ -958,7 +1398,7 @@ function as follows:
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\KeywordTok{print}\NormalTok{(r_vec)}
+\FunctionTok{print}\NormalTok{(r\_vec)}
 \end{Highlighting}
 \end{Shaded}
 
@@ -968,7 +1408,7 @@ function as follows:
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\KeywordTok{print}\NormalTok{(}\KeywordTok{reduce_sum}\NormalTok{(r_vec))}
+\FunctionTok{print}\NormalTok{(}\FunctionTok{reduce\_sum}\NormalTok{(r\_vec))}
 \end{Highlighting}
 \end{Shaded}
 
@@ -989,7 +1429,7 @@ grammar of graphics is to build a graphics by adding layers to the plot.
 More information can be found in
 \url{https://towardsdatascience.com/a-comprehensive-guide-to-the-grammar-of-graphics-for-effective-visualization-of-multi-dimensional-1f92b4ed4149}.
 
-In the plot bellow the `mpg' dataset from base R is used. ``The data
+In the plot below the `mpg' dataset from base R is used. ``The data
 concerns city-cycle fuel consumption in miles per gallon, to be
 predicted in terms of 3 multivalued discrete and 5 continuous
 attributes.'' (Quinlan, 1993)
@@ -1008,38 +1448,28 @@ linear regression line (method = ``lm'') for every manufacturer.
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\CommentTok{# load package and data}
-\KeywordTok{library}\NormalTok{(ggplot2)}
-\end{Highlighting}
-\end{Shaded}
+\CommentTok{\# load package and data}
+\FunctionTok{library}\NormalTok{(ggplot2)}
+\FunctionTok{data}\NormalTok{(mpg, }\AttributeTok{package=}\StringTok{"ggplot2"}\NormalTok{)}
 
-\begin{verbatim}
-## Message:
-##  Registered S3 methods overwritten by 'ggplot2':
-##   method         from 
-##   [.quosures     rlang
-##   c.quosures     rlang
-##   print.quosures rlang
-\end{verbatim}
+\NormalTok{mpg\_select }\OtherTok{\textless{}{-}}\NormalTok{ mpg[mpg}\SpecialCharTok{$}\NormalTok{manufacturer }\SpecialCharTok{\%in\%} \FunctionTok{c}\NormalTok{(}\StringTok{"audi"}\NormalTok{, }\StringTok{"ford"}\NormalTok{, }\StringTok{"honda"}\NormalTok{, }\StringTok{"hyundai"}\NormalTok{), ]}
 
-\begin{Shaded}
-\begin{Highlighting}[]
-\KeywordTok{data}\NormalTok{(mpg, }\DataTypeTok{package=}\StringTok{"ggplot2"}\NormalTok{)}
+\CommentTok{\# Scatterplot}
+\FunctionTok{theme\_set}\NormalTok{(}\FunctionTok{theme\_bw}\NormalTok{())  }\CommentTok{\# pre{-}set the bw theme.}
+\NormalTok{g }\OtherTok{\textless{}{-}} \FunctionTok{ggplot}\NormalTok{(mpg\_select, }\FunctionTok{aes}\NormalTok{(displ, cty)) }\SpecialCharTok{+} 
+  \FunctionTok{labs}\NormalTok{(}\AttributeTok{subtitle=}\StringTok{"mpg: Displacement vs City Mileage"}\NormalTok{,}
+       \AttributeTok{title=}\StringTok{"Bubble chart"}\NormalTok{)}
 
-\NormalTok{mpg_select <-}\StringTok{ }\NormalTok{mpg[mpg}\OperatorTok{$}\NormalTok{manufacturer }\OperatorTok{%in%}\StringTok{ }\KeywordTok{c}\NormalTok{(}\StringTok{"audi"}\NormalTok{, }\StringTok{"ford"}\NormalTok{, }\StringTok{"honda"}\NormalTok{, }\StringTok{"hyundai"}\NormalTok{), ]}
-
-\CommentTok{# Scatterplot}
-\KeywordTok{theme_set}\NormalTok{(}\KeywordTok{theme_bw}\NormalTok{())  }\CommentTok{# pre-set the bw theme.}
-\NormalTok{g <-}\StringTok{ }\KeywordTok{ggplot}\NormalTok{(mpg_select, }\KeywordTok{aes}\NormalTok{(displ, cty)) }\OperatorTok{+}\StringTok{ }
-\StringTok{  }\KeywordTok{labs}\NormalTok{(}\DataTypeTok{subtitle=}\StringTok{"mpg: Displacement vs City Mileage"}\NormalTok{,}
-       \DataTypeTok{title=}\StringTok{"Bubble chart"}\NormalTok{)}
-
-\NormalTok{g }\OperatorTok{+}\StringTok{ }\KeywordTok{geom_jitter}\NormalTok{(}\KeywordTok{aes}\NormalTok{(}\DataTypeTok{col=}\NormalTok{manufacturer, }\DataTypeTok{size=}\NormalTok{hwy)) }\OperatorTok{+}\StringTok{ }
-\StringTok{  }\KeywordTok{geom_smooth}\NormalTok{(}\KeywordTok{aes}\NormalTok{(}\DataTypeTok{col=}\NormalTok{manufacturer), }\DataTypeTok{method=}\StringTok{"lm"}\NormalTok{, }\DataTypeTok{se=}\NormalTok{F)}
+\NormalTok{g }\SpecialCharTok{+} \FunctionTok{geom\_jitter}\NormalTok{(}\FunctionTok{aes}\NormalTok{(}\AttributeTok{col=}\NormalTok{manufacturer, }\AttributeTok{size=}\NormalTok{hwy)) }\SpecialCharTok{+} 
+  \FunctionTok{geom\_smooth}\NormalTok{(}\FunctionTok{aes}\NormalTok{(}\AttributeTok{col=}\NormalTok{manufacturer), }\AttributeTok{method=}\StringTok{"lm"}\NormalTok{, }\AttributeTok{se=}\NormalTok{F)}
 \end{Highlighting}
 \end{Shaded}
 
-\includegraphics{manual_files/figure-latex/bubble-1.png}
+\begin{verbatim}
+## `geom_smooth()` using formula = 'y ~ x'
+\end{verbatim}
+
+\pandocbounded{\includegraphics[keepaspectratio]{manual_files/figure-latex/bubble-1.png}}
 
 \subsection{Ruby chunks}\label{ruby-chunks}
 
@@ -1072,12 +1502,12 @@ text without any code.
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{a = [}\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{3}\NormalTok{]}
-\NormalTok{b = }\StringTok{"US$ 250.000"}
-\NormalTok{c = }\StringTok{"The 'outputs' function"}
+\NormalTok{a }\OperatorTok{=} \KeywordTok{[}\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{3}\KeywordTok{]}
+\NormalTok{b }\OperatorTok{=} \StringTok{"US$ 250.000"}
+\NormalTok{c }\OperatorTok{=} \StringTok{"The \textquotesingle{}outputs\textquotesingle{} function"}
 
-\NormalTok{vec = R.c(}\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{3}\NormalTok{)}
-\NormalTok{vec2 = R.c(}\DecValTok{10}\NormalTok{, }\DecValTok{20}\NormalTok{, }\DecValTok{30}\NormalTok{)}
+\NormalTok{vec }\OperatorTok{=} \ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{3}\NormalTok{)}
+\NormalTok{vec2 }\OperatorTok{=} \ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\DecValTok{10}\NormalTok{, }\DecValTok{20}\NormalTok{, }\DecValTok{30}\NormalTok{)}
 \end{Highlighting}
 \end{Shaded}
 
@@ -1085,8 +1515,8 @@ In the next block, variables `a', `vec' and `vec2' are used and printed.
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts a}
-\NormalTok{puts vec * vec2}
+\FunctionTok{puts}\NormalTok{ a}
+\FunctionTok{puts}\NormalTok{ vec }\OperatorTok{*}\NormalTok{ vec2}
 \end{Highlighting}
 \end{Shaded}
 
@@ -1122,8 +1552,7 @@ Note that it is important not to add any new line before of after the
 code block if we want everything to be in only one line, resulting in
 the following sentence with inline Ruby code.
 
-\subsubsection{\texorpdfstring{The `outputs'
-function}{The outputs function}}\label{the-outputs-function}
+\subsubsection{The `outputs' function}\label{the-outputs-function}
 
 He have previously used the standard `puts' method in Ruby chunks in
 order produce output. The result of a `puts', as seen in all previous
@@ -1139,7 +1568,7 @@ the first line of a file we are going to read. Method `outputs' adds its
 output as if typed in the \textbf{R markdown} document.
 
 Take now a look at variable `c' (it was defined in a previous block
-above) as `c = ``The 'outputs' function''. ``The 'outputs' function'' is
+above) as `c = ``The `outputs' function''. ``The `outputs' function'' is
 actually the name of this section and it was created using the 'outputs'
 function inside a Ruby chunk.
 
@@ -1183,113 +1612,85 @@ document:
 </table>
 \end{verbatim}
 
-\begin{verbatim}
-<th>Firstname</th>
-<th>Lastname</th> 
-<th>Age</th>
-\end{verbatim}
+Firstname
 
-\begin{verbatim}
-<td>Jill</td>
-<td>Smith</td> 
-<td>50</td>
-\end{verbatim}
+Lastname
 
-\begin{verbatim}
-<td>Eve</td>
-<td>Jackson</td> 
-<td>94</td>
-\end{verbatim}
+Age
+
+Jill
+
+Smith
+
+50
+
+Eve
+
+Jackson
+
+94
 
 But manually creating HTML output is not always easy or desirable,
 specially if we intend the document to be rendered in other formats, for
-example, as Latex. Also, The above table looks ugly. The `kableExtra'
+example, as LaTeX. Also, The above table looks ugly. The `kableExtra'
 library is a great library for creating beautiful tables. Take a look at
 \url{https://cran.r-project.org/web/packages/kableExtra/vignettes/awesome_table_in_html.html}
 
 In the next chunk, we output the `mtcars' dataframe from R in a nicely
 formatted table. Note that we retrieve the mtcars dataframe by using
-`\textasciitilde{}:mtcars'.
+`\textasciitilde:mtcars'.
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{R.install_and_loads(}\StringTok{'kableExtra'}\NormalTok{)}
-\NormalTok{outputs (~}\StringTok{:mtcars}\NormalTok{).kable.kable_styling}
+\ConstantTok{R}\AttributeTok{.install\_and\_loads}\NormalTok{(}\VerbatimStringTok{\textquotesingle{}kableExtra\textquotesingle{}}\NormalTok{)}
+\NormalTok{outputs (}\OperatorTok{\textasciitilde{}}\WarningTok{:mtcars}\NormalTok{)}\AttributeTok{.kable.kable\_styling}
 \end{Highlighting}
 \end{Shaded}
 
-\begin{table}[H]
-\centering
-\begin{tabular}{l|r|r|r|r|r|r|r|r|r|r|r}
-\hline
-  & mpg & cyl & disp & hp & drat & wt & qsec & vs & am & gear & carb\\
-\hline
+\begin{longtable}[t]{lrrrrrrrrrrr}
+\toprule
+ & mpg & cyl & disp & hp & drat & wt & qsec & vs & am & gear & carb\\
+\midrule
 Mazda RX4 & 21.0 & 6 & 160.0 & 110 & 3.90 & 2.620 & 16.46 & 0 & 1 & 4 & 4\\
-\hline
 Mazda RX4 Wag & 21.0 & 6 & 160.0 & 110 & 3.90 & 2.875 & 17.02 & 0 & 1 & 4 & 4\\
-\hline
 Datsun 710 & 22.8 & 4 & 108.0 & 93 & 3.85 & 2.320 & 18.61 & 1 & 1 & 4 & 1\\
-\hline
 Hornet 4 Drive & 21.4 & 6 & 258.0 & 110 & 3.08 & 3.215 & 19.44 & 1 & 0 & 3 & 1\\
-\hline
 Hornet Sportabout & 18.7 & 8 & 360.0 & 175 & 3.15 & 3.440 & 17.02 & 0 & 0 & 3 & 2\\
-\hline
+\addlinespace
 Valiant & 18.1 & 6 & 225.0 & 105 & 2.76 & 3.460 & 20.22 & 1 & 0 & 3 & 1\\
-\hline
 Duster 360 & 14.3 & 8 & 360.0 & 245 & 3.21 & 3.570 & 15.84 & 0 & 0 & 3 & 4\\
-\hline
 Merc 240D & 24.4 & 4 & 146.7 & 62 & 3.69 & 3.190 & 20.00 & 1 & 0 & 4 & 2\\
-\hline
 Merc 230 & 22.8 & 4 & 140.8 & 95 & 3.92 & 3.150 & 22.90 & 1 & 0 & 4 & 2\\
-\hline
 Merc 280 & 19.2 & 6 & 167.6 & 123 & 3.92 & 3.440 & 18.30 & 1 & 0 & 4 & 4\\
-\hline
+\addlinespace
 Merc 280C & 17.8 & 6 & 167.6 & 123 & 3.92 & 3.440 & 18.90 & 1 & 0 & 4 & 4\\
-\hline
 Merc 450SE & 16.4 & 8 & 275.8 & 180 & 3.07 & 4.070 & 17.40 & 0 & 0 & 3 & 3\\
-\hline
 Merc 450SL & 17.3 & 8 & 275.8 & 180 & 3.07 & 3.730 & 17.60 & 0 & 0 & 3 & 3\\
-\hline
 Merc 450SLC & 15.2 & 8 & 275.8 & 180 & 3.07 & 3.780 & 18.00 & 0 & 0 & 3 & 3\\
-\hline
 Cadillac Fleetwood & 10.4 & 8 & 472.0 & 205 & 2.93 & 5.250 & 17.98 & 0 & 0 & 3 & 4\\
-\hline
+\addlinespace
 Lincoln Continental & 10.4 & 8 & 460.0 & 215 & 3.00 & 5.424 & 17.82 & 0 & 0 & 3 & 4\\
-\hline
 Chrysler Imperial & 14.7 & 8 & 440.0 & 230 & 3.23 & 5.345 & 17.42 & 0 & 0 & 3 & 4\\
-\hline
 Fiat 128 & 32.4 & 4 & 78.7 & 66 & 4.08 & 2.200 & 19.47 & 1 & 1 & 4 & 1\\
-\hline
 Honda Civic & 30.4 & 4 & 75.7 & 52 & 4.93 & 1.615 & 18.52 & 1 & 1 & 4 & 2\\
-\hline
 Toyota Corolla & 33.9 & 4 & 71.1 & 65 & 4.22 & 1.835 & 19.90 & 1 & 1 & 4 & 1\\
-\hline
+\addlinespace
 Toyota Corona & 21.5 & 4 & 120.1 & 97 & 3.70 & 2.465 & 20.01 & 1 & 0 & 3 & 1\\
-\hline
 Dodge Challenger & 15.5 & 8 & 318.0 & 150 & 2.76 & 3.520 & 16.87 & 0 & 0 & 3 & 2\\
-\hline
 AMC Javelin & 15.2 & 8 & 304.0 & 150 & 3.15 & 3.435 & 17.30 & 0 & 0 & 3 & 2\\
-\hline
 Camaro Z28 & 13.3 & 8 & 350.0 & 245 & 3.73 & 3.840 & 15.41 & 0 & 0 & 3 & 4\\
-\hline
 Pontiac Firebird & 19.2 & 8 & 400.0 & 175 & 3.08 & 3.845 & 17.05 & 0 & 0 & 3 & 2\\
-\hline
+\addlinespace
 Fiat X1-9 & 27.3 & 4 & 79.0 & 66 & 4.08 & 1.935 & 18.90 & 1 & 1 & 4 & 1\\
-\hline
 Porsche 914-2 & 26.0 & 4 & 120.3 & 91 & 4.43 & 2.140 & 16.70 & 0 & 1 & 5 & 2\\
-\hline
 Lotus Europa & 30.4 & 4 & 95.1 & 113 & 3.77 & 1.513 & 16.90 & 1 & 1 & 5 & 2\\
-\hline
 Ford Pantera L & 15.8 & 8 & 351.0 & 264 & 4.22 & 3.170 & 14.50 & 0 & 1 & 5 & 4\\
-\hline
 Ferrari Dino & 19.7 & 6 & 145.0 & 175 & 3.62 & 2.770 & 15.50 & 0 & 1 & 5 & 6\\
-\hline
+\addlinespace
 Maserati Bora & 15.0 & 8 & 301.0 & 335 & 3.54 & 3.570 & 14.60 & 0 & 1 & 5 & 8\\
-\hline
 Volvo 142E & 21.4 & 4 & 121.0 & 109 & 4.11 & 2.780 & 18.60 & 1 & 1 & 4 & 2\\
-\hline
-\end{tabular}
-\end{table}
+\bottomrule
+\end{longtable}
 
 \subsection{Including Ruby files in a
 chunk}\label{including-ruby-files-in-a-chunk}
@@ -1319,8 +1720,8 @@ Ruby's \$LOAD\_PATH is searched to find the file and it is 'require'd.
 ```
 \end{verbatim}
 
-Bellow we include file `model.rb', which is in the same directory of
-this blog.\\
+Below we include file `model.rb', which is in the same directory of this
+blog.\\
 This code uses R `caret' package to split a dataset in a train and test
 sets. The `caret' package is a very important a useful package for doing
 Data Analysis, it has hundreds of functions for all steps of the Data
@@ -1339,73 +1740,73 @@ installed and can take a while.
 ```
 \end{verbatim}
 
-\begin{verbatim}
-require 'galaaz'
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{require \textquotesingle{}galaaz\textquotesingle{}}
 
-# Loads the R 'caret' package.  If not present, installs it 
-R.install_and_loads 'caret'
+\NormalTok{\# Loads the R \textquotesingle{}caret\textquotesingle{} package.  If not present, installs it }
+\NormalTok{R.install\_and\_loads \textquotesingle{}caret\textquotesingle{}}
 
-class Model
+\NormalTok{class Model}
   
-  attr_reader :data
-  attr_reader :test
-  attr_reader :train
+\NormalTok{  attr\_reader :data}
+\NormalTok{  attr\_reader :test}
+\NormalTok{  attr\_reader :train}
 
-  #==========================================================
-  #
-  #==========================================================
+\NormalTok{  \#==========================================================}
+\NormalTok{  \#}
+\NormalTok{  \#==========================================================}
   
-  def initialize(data, percent_train:, seed: 123)
+\NormalTok{  def initialize(data, percent\_train:, seed: 123)}
 
-    R.set__seed(seed)
-    @data = data
-    @percent_train = percent_train
-    @seed = seed
+\NormalTok{    R.set\_\_seed(seed)}
+\NormalTok{    @data = data}
+\NormalTok{    @percent\_train = percent\_train}
+\NormalTok{    @seed = seed}
     
-  end
+\NormalTok{  end}
 
-  #==========================================================
-  #
-  #==========================================================
+\NormalTok{  \#==========================================================}
+\NormalTok{  \#}
+\NormalTok{  \#==========================================================}
 
-  def partition(field)
+\NormalTok{  def partition(field)}
 
-    train_index =
-      R.createDataPartition(@data.send(field), p: @percet_train,
-                            list: false, times: 1)
-    @train = @data[train_index, :all]
-    @test = @data[-train_index, :all]
+\NormalTok{    train\_index =}
+\NormalTok{      R.createDataPartition(@data.send(field), p: @percent\_train,}
+\NormalTok{                            list: false, times: 1)}
+\NormalTok{    @train = @data[train\_index, :all]}
+\NormalTok{    @test = @data[{-}train\_index, :all]}
     
-  end
+\NormalTok{  end}
   
-end
-\end{verbatim}
+\NormalTok{end}
+\end{Highlighting}
+\end{Shaded}
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{mtcars = ~}\StringTok{:mtcars}
-\NormalTok{model = }\DataTypeTok{Model}\NormalTok{.new(mtcars, }\StringTok{percent_train: }\FloatTok{0.8}\NormalTok{)}
-\NormalTok{model.partition(}\StringTok{:mpg}\NormalTok{)}
-\NormalTok{puts model.train.head}
-\NormalTok{puts model.test.head}
+\NormalTok{mtcars }\OperatorTok{=} \OperatorTok{\textasciitilde{}}\WarningTok{:mtcars}
+\NormalTok{model }\OperatorTok{=} \DataTypeTok{Model}\AttributeTok{.new}\NormalTok{(mtcars, }\WarningTok{percent\_train:} \FloatTok{0.8}\NormalTok{)}
+\NormalTok{model}\AttributeTok{.partition}\NormalTok{(}\WarningTok{:mpg}\NormalTok{)}
+\FunctionTok{puts}\NormalTok{ model}\AttributeTok{.train.head}
+\FunctionTok{puts}\NormalTok{ model}\AttributeTok{.test.head}
 \end{Highlighting}
 \end{Shaded}
 
 \begin{verbatim}
-##                mpg cyl  disp  hp drat    wt  qsec vs am gear carb
-## Mazda RX4     21.0   6 160.0 110 3.90 2.620 16.46  0  1    4    4
-## Mazda RX4 Wag 21.0   6 160.0 110 3.90 2.875 17.02  0  1    4    4
-## Valiant       18.1   6 225.0 105 2.76 3.460 20.22  1  0    3    1
-## Merc 280      19.2   6 167.6 123 3.92 3.440 18.30  1  0    4    4
-## Merc 280C     17.8   6 167.6 123 3.92 3.440 18.90  1  0    4    4
-## Merc 450SE    16.4   8 275.8 180 3.07 4.070 17.40  0  0    3    3
 ##                    mpg cyl  disp  hp drat    wt  qsec vs am gear carb
+## Mazda RX4         21.0   6 160.0 110 3.90 2.620 16.46  0  1    4    4
 ## Datsun 710        22.8   4 108.0  93 3.85 2.320 18.61  1  1    4    1
 ## Hornet 4 Drive    21.4   6 258.0 110 3.08 3.215 19.44  1  0    3    1
 ## Hornet Sportabout 18.7   8 360.0 175 3.15 3.440 17.02  0  0    3    2
-## Duster 360        14.3   8 360.0 245 3.21 3.570 15.84  0  0    3    4
+## Valiant           18.1   6 225.0 105 2.76 3.460 20.22  1  0    3    1
 ## Merc 240D         24.4   4 146.7  62 3.69 3.190 20.00  1  0    4    2
-## Merc 230          22.8   4 140.8  95 3.92 3.150 22.90  1  0    4    2
+##                 mpg cyl  disp  hp drat    wt  qsec vs am gear carb
+## Mazda RX4 Wag  21.0   6 160.0 110 3.90 2.875 17.02  0  1    4    4
+## Duster 360     14.3   8 360.0 245 3.21 3.570 15.84  0  0    3    4
+## Toyota Corolla 33.9   4  71.1  65 4.22 1.835 19.90  1  1    4    1
+## Ford Pantera L 15.8   8 351.0 264 4.22 3.170 14.50  0  1    5    4
 \end{verbatim}
 
 \subsection{Documenting Gems}\label{documenting-gems}
@@ -1413,105 +1814,110 @@ end
 gKnit also allows developers to document and load files that are not in
 the same directory of the `.Rmd' file.
 
-Here is an example of loading the `find.rb' file from TruffleRuby. In
-this example, relative is set to FALSE, so Ruby will look for the file
-in its \$LOAD\_PATH, and the user does not need to no it's directory.
+Here is an example of loading Ruby's standard library file
+\texttt{find.rb}. In this example, relative is set to FALSE, so Ruby
+will look for the file in its \texttt{\$LOAD\_PATH}, and the user does
+not need to know its directory on disk.
 
 \begin{verbatim}
 ```{include find, relative = FALSE}
 ```
 \end{verbatim}
 
-\begin{verbatim}
-# frozen_string_literal: true
-#
-# find.rb: the Find module for processing all files under a given directory.
-#
-
-#
-# The +Find+ module supports the top-down traversal of a set of file paths.
-#
-# For example, to total the size of all files under your home directory,
-# ignoring anything in a "dot" directory (e.g. $HOME/.ssh):
-#
-#   require 'find'
-#
-#   total_size = 0
-#
-#   Find.find(ENV["HOME"]) do |path|
-#     if FileTest.directory?(path)
-#       if File.basename(path)[0] == ?.
-#         Find.prune       # Don't look any further into this directory.
-#       else
-#         next
-#       end
-#     else
-#       total_size += FileTest.size(path)
-#     end
-#   end
-#
-module Find
-
-  #
-  # Calls the associated block with the name of every file and directory listed
-  # as arguments, then recursively on their subdirectories, and so on.
-  #
-  # Returns an enumerator if no block is given.
-  #
-  # See the +Find+ module documentation for an example.
-  #
-  def find(*paths, ignore_error: true) # :yield: path
-    block_given? or return enum_for(__method__, *paths, ignore_error: ignore_error)
-
-    fs_encoding = Encoding.find("filesystem")
-
-    paths.collect!{|d| raise Errno::ENOENT, d unless File.exist?(d); d.dup}.each do |path|
-      path = path.to_path if path.respond_to? :to_path
-      enc = path.encoding == Encoding::US_ASCII ? fs_encoding : path.encoding
-      ps = [path]
-      while file = ps.shift
-        catch(:prune) do
-          yield file.dup.taint
-          begin
-            s = File.lstat(file)
-          rescue Errno::ENOENT, Errno::EACCES, Errno::ENOTDIR, Errno::ELOOP, Errno::ENAMETOOLONG
-            raise unless ignore_error
-            next
-          end
-          if s.directory? then
-            begin
-              fs = Dir.children(file, encoding: enc)
-            rescue Errno::ENOENT, Errno::EACCES, Errno::ENOTDIR, Errno::ELOOP, Errno::ENAMETOOLONG
-              raise unless ignore_error
-              next
-            end
-            fs.sort!
-            fs.reverse_each {|f|
-              f = File.join(file, f)
-              ps.unshift f.untaint
-            }
-          end
-        end
-      end
-    end
-    nil
-  end
-
-  #
-  # Skips the current file or directory, restarting the loop with the next
-  # entry. If the current file is a directory, that directory will not be
-  # recursively entered. Meaningful only within the block associated with
-  # Find::find.
-  #
-  # See the +Find+ module documentation for an example.
-  #
-  def prune
-    throw :prune
-  end
-
-  module_function :find, :prune
-end
-\end{verbatim}
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{\# frozen\_string\_literal: true}
+\NormalTok{\#}
+\NormalTok{\# find.rb: the Find module for processing all files under a given directory.}
+\NormalTok{\#}
+
+\NormalTok{\#}
+\NormalTok{\# The +Find+ module supports the top{-}down traversal of a set of file paths.}
+\NormalTok{\#}
+\NormalTok{\# For example, to total the size of all files under your home directory,}
+\NormalTok{\# ignoring anything in a "dot" directory (e.g. $HOME/.ssh):}
+\NormalTok{\#}
+\NormalTok{\#   require \textquotesingle{}find\textquotesingle{}}
+\NormalTok{\#}
+\NormalTok{\#   total\_size = 0}
+\NormalTok{\#}
+\NormalTok{\#   Find.find(ENV["HOME"]) do |path|}
+\NormalTok{\#     if FileTest.directory?(path)}
+\NormalTok{\#       if File.basename(path).start\_with?(\textquotesingle{}.\textquotesingle{})}
+\NormalTok{\#         Find.prune       \# Don\textquotesingle{}t look any further into this directory.}
+\NormalTok{\#       else}
+\NormalTok{\#         next}
+\NormalTok{\#       end}
+\NormalTok{\#     else}
+\NormalTok{\#       total\_size += FileTest.size(path)}
+\NormalTok{\#     end}
+\NormalTok{\#   end}
+\NormalTok{\#}
+\NormalTok{module Find}
+
+\NormalTok{  VERSION = "0.2.0"}
+
+\NormalTok{  \#}
+\NormalTok{  \# Calls the associated block with the name of every file and directory listed}
+\NormalTok{  \# as arguments, then recursively on their subdirectories, and so on.}
+\NormalTok{  \#}
+\NormalTok{  \# Returns an enumerator if no block is given.}
+\NormalTok{  \#}
+\NormalTok{  \# See the +Find+ module documentation for an example.}
+\NormalTok{  \#}
+\NormalTok{  def find(*paths, ignore\_error: true) \# :yield: path}
+\NormalTok{    block\_given? or return enum\_for(\_\_method\_\_, *paths, ignore\_error: ignore\_error)}
+
+\NormalTok{    fs\_encoding = Encoding.find("filesystem")}
+
+\NormalTok{    paths.collect!\{|d| raise Errno::ENOENT, d unless File.exist?(d); d.dup\}.each do |path|}
+\NormalTok{      path = path.to\_path if path.respond\_to? :to\_path}
+\NormalTok{      enc = path.encoding == Encoding::US\_ASCII ? fs\_encoding : path.encoding}
+\NormalTok{      ps = [path]}
+\NormalTok{      while file = ps.shift}
+\NormalTok{        catch(:prune) do}
+\NormalTok{          yield file.dup}
+\NormalTok{          begin}
+\NormalTok{            s = File.lstat(file)}
+\NormalTok{          rescue Errno::ENOENT, Errno::EACCES, Errno::ENOTDIR, Errno::ELOOP, Errno::ENAMETOOLONG, Errno::EINVAL}
+\NormalTok{            raise unless ignore\_error}
+\NormalTok{            next}
+\NormalTok{          end}
+\NormalTok{          if s.directory? then}
+\NormalTok{            begin}
+\NormalTok{              fs = Dir.children(file, encoding: enc)}
+\NormalTok{            rescue Errno::ENOENT, Errno::EACCES, Errno::ENOTDIR, Errno::ELOOP, Errno::ENAMETOOLONG, Errno::EINVAL}
+\NormalTok{              raise unless ignore\_error}
+\NormalTok{              next}
+\NormalTok{            end}
+\NormalTok{            fs.sort!}
+\NormalTok{            fs.reverse\_each \{|f|}
+\NormalTok{              f = File.join(file, f)}
+\NormalTok{              ps.unshift f}
+\NormalTok{            \}}
+\NormalTok{          end}
+\NormalTok{        end}
+\NormalTok{      end}
+\NormalTok{    end}
+\NormalTok{    nil}
+\NormalTok{  end}
+
+\NormalTok{  \#}
+\NormalTok{  \# Skips the current file or directory, restarting the loop with the next}
+\NormalTok{  \# entry. If the current file is a directory, that directory will not be}
+\NormalTok{  \# recursively entered. Meaningful only within the block associated with}
+\NormalTok{  \# Find::find.}
+\NormalTok{  \#}
+\NormalTok{  \# See the +Find+ module documentation for an example.}
+\NormalTok{  \#}
+\NormalTok{  def prune}
+\NormalTok{    throw :prune}
+\NormalTok{  end}
+
+\NormalTok{  module\_function :find, :prune}
+\NormalTok{end}
+\end{Highlighting}
+\end{Shaded}
 
 \subsection{Converting to PDF}\label{converting-to-pdf}
 
@@ -1528,9 +1934,9 @@ format instead of HTML:
 
 \begin{verbatim}
 ---
-title: "gKnit - Ruby and R Knitting with Galaaz in GraalVM"
+title: "gKnit - Ruby and R Knitting with Galaaz"
 author: "Rodrigo Botafogo"
-tags: [Galaaz, Ruby, R, TruffleRuby, FastR, GraalVM, knitr, gknit]
+tags: [Galaaz, Ruby, R, JRuby, knitr, gknit]
 date: "29 October 2018"
 output:
   pdf\_document:
@@ -1543,7 +1949,7 @@ output:
 \subsection{Template based documents
 generation}\label{template-based-documents-generation}
 
-When a document is converted to PDF it follows a certain convertion
+When a document is converted to PDF it follows a certain conversion
 template. We've seen above the use of `galaaz.sty' as a basic template
 to generate a PDF document. Using the `gknit-draft' app that comes with
 Galaaz, the same .Rmd file can be compiled to different looking PDF
@@ -1631,91 +2037,63 @@ gknit-draft --filename my_r_article --template rjournal_article --package rticle
 \section{Accessing R variables}\label{accessing-r-variables}
 
 Galaaz allows Ruby to access variables created in R. For example, the
-`mtcars' data set is available in R and can be accessed from Ruby by
-using the `tilda' operator followed by the symbol for the variable, in
-this case `:mtcar'. In the code bellow method `outputs' is used to
-output the `mtcars' data set nicely formatted in HTML by use of the
-`kable' and `kable\_styling' functions. Method `outputs' is only
-available when used with `gknit'.
+\texttt{mtcars} data set is available in R and can be accessed from Ruby
+by using the tilde operator followed by the symbol for the variable, in
+this case \texttt{:mtcars}. In the code below, method \texttt{outputs}
+is used to output the \texttt{mtcars} data set nicely formatted in HTML
+by use of the \texttt{kable} and \texttt{kable\_styling} functions.
+Method \texttt{outputs} is only available when used with gKnit.
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{outputs (~}\StringTok{:mtcars}\NormalTok{).kable.kable_styling}
+\NormalTok{outputs (}\OperatorTok{\textasciitilde{}}\WarningTok{:mtcars}\NormalTok{)}\AttributeTok{.kable.kable\_styling}
 \end{Highlighting}
 \end{Shaded}
 
-\begin{table}[H]
-\centering
-\begin{tabular}{l|r|r|r|r|r|r|r|r|r|r|r}
-\hline
-  & mpg & cyl & disp & hp & drat & wt & qsec & vs & am & gear & carb\\
-\hline
+\begin{longtable}[t]{lrrrrrrrrrrr}
+\toprule
+ & mpg & cyl & disp & hp & drat & wt & qsec & vs & am & gear & carb\\
+\midrule
 Mazda RX4 & 21.0 & 6 & 160.0 & 110 & 3.90 & 2.620 & 16.46 & 0 & 1 & 4 & 4\\
-\hline
 Mazda RX4 Wag & 21.0 & 6 & 160.0 & 110 & 3.90 & 2.875 & 17.02 & 0 & 1 & 4 & 4\\
-\hline
 Datsun 710 & 22.8 & 4 & 108.0 & 93 & 3.85 & 2.320 & 18.61 & 1 & 1 & 4 & 1\\
-\hline
 Hornet 4 Drive & 21.4 & 6 & 258.0 & 110 & 3.08 & 3.215 & 19.44 & 1 & 0 & 3 & 1\\
-\hline
 Hornet Sportabout & 18.7 & 8 & 360.0 & 175 & 3.15 & 3.440 & 17.02 & 0 & 0 & 3 & 2\\
-\hline
+\addlinespace
 Valiant & 18.1 & 6 & 225.0 & 105 & 2.76 & 3.460 & 20.22 & 1 & 0 & 3 & 1\\
-\hline
 Duster 360 & 14.3 & 8 & 360.0 & 245 & 3.21 & 3.570 & 15.84 & 0 & 0 & 3 & 4\\
-\hline
 Merc 240D & 24.4 & 4 & 146.7 & 62 & 3.69 & 3.190 & 20.00 & 1 & 0 & 4 & 2\\
-\hline
 Merc 230 & 22.8 & 4 & 140.8 & 95 & 3.92 & 3.150 & 22.90 & 1 & 0 & 4 & 2\\
-\hline
 Merc 280 & 19.2 & 6 & 167.6 & 123 & 3.92 & 3.440 & 18.30 & 1 & 0 & 4 & 4\\
-\hline
+\addlinespace
 Merc 280C & 17.8 & 6 & 167.6 & 123 & 3.92 & 3.440 & 18.90 & 1 & 0 & 4 & 4\\
-\hline
 Merc 450SE & 16.4 & 8 & 275.8 & 180 & 3.07 & 4.070 & 17.40 & 0 & 0 & 3 & 3\\
-\hline
 Merc 450SL & 17.3 & 8 & 275.8 & 180 & 3.07 & 3.730 & 17.60 & 0 & 0 & 3 & 3\\
-\hline
 Merc 450SLC & 15.2 & 8 & 275.8 & 180 & 3.07 & 3.780 & 18.00 & 0 & 0 & 3 & 3\\
-\hline
 Cadillac Fleetwood & 10.4 & 8 & 472.0 & 205 & 2.93 & 5.250 & 17.98 & 0 & 0 & 3 & 4\\
-\hline
+\addlinespace
 Lincoln Continental & 10.4 & 8 & 460.0 & 215 & 3.00 & 5.424 & 17.82 & 0 & 0 & 3 & 4\\
-\hline
 Chrysler Imperial & 14.7 & 8 & 440.0 & 230 & 3.23 & 5.345 & 17.42 & 0 & 0 & 3 & 4\\
-\hline
 Fiat 128 & 32.4 & 4 & 78.7 & 66 & 4.08 & 2.200 & 19.47 & 1 & 1 & 4 & 1\\
-\hline
 Honda Civic & 30.4 & 4 & 75.7 & 52 & 4.93 & 1.615 & 18.52 & 1 & 1 & 4 & 2\\
-\hline
 Toyota Corolla & 33.9 & 4 & 71.1 & 65 & 4.22 & 1.835 & 19.90 & 1 & 1 & 4 & 1\\
-\hline
+\addlinespace
 Toyota Corona & 21.5 & 4 & 120.1 & 97 & 3.70 & 2.465 & 20.01 & 1 & 0 & 3 & 1\\
-\hline
 Dodge Challenger & 15.5 & 8 & 318.0 & 150 & 2.76 & 3.520 & 16.87 & 0 & 0 & 3 & 2\\
-\hline
 AMC Javelin & 15.2 & 8 & 304.0 & 150 & 3.15 & 3.435 & 17.30 & 0 & 0 & 3 & 2\\
-\hline
 Camaro Z28 & 13.3 & 8 & 350.0 & 245 & 3.73 & 3.840 & 15.41 & 0 & 0 & 3 & 4\\
-\hline
 Pontiac Firebird & 19.2 & 8 & 400.0 & 175 & 3.08 & 3.845 & 17.05 & 0 & 0 & 3 & 2\\
-\hline
+\addlinespace
 Fiat X1-9 & 27.3 & 4 & 79.0 & 66 & 4.08 & 1.935 & 18.90 & 1 & 1 & 4 & 1\\
-\hline
 Porsche 914-2 & 26.0 & 4 & 120.3 & 91 & 4.43 & 2.140 & 16.70 & 0 & 1 & 5 & 2\\
-\hline
 Lotus Europa & 30.4 & 4 & 95.1 & 113 & 3.77 & 1.513 & 16.90 & 1 & 1 & 5 & 2\\
-\hline
 Ford Pantera L & 15.8 & 8 & 351.0 & 264 & 4.22 & 3.170 & 14.50 & 0 & 1 & 5 & 4\\
-\hline
 Ferrari Dino & 19.7 & 6 & 145.0 & 175 & 3.62 & 2.770 & 15.50 & 0 & 1 & 5 & 6\\
-\hline
+\addlinespace
 Maserati Bora & 15.0 & 8 & 301.0 & 335 & 3.54 & 3.570 & 14.60 & 0 & 1 & 5 & 8\\
-\hline
 Volvo 142E & 21.4 & 4 & 121.0 & 109 & 4.11 & 2.780 & 18.60 & 1 & 1 & 4 & 2\\
-\hline
-\end{tabular}
-\end{table}
+\bottomrule
+\end{longtable}
 
 \section{Basic Data Types}\label{basic-data-types}
 
@@ -1727,19 +2105,22 @@ basic (`atomic') vector types: logical, integer, real, complex, string
 (or character) and raw. The modes and storage modes for the different
 vector types are listed in the following table.
 
+{\def\LTcaptype{none} % do not increment counter
 \begin{longtable}[]{@{}lcr@{}}
-\toprule
-typeof & mode & storage.mode\tabularnewline
-\midrule
+\toprule\noalign{}
+typeof & mode & storage.mode \\
+\midrule\noalign{}
 \endhead
-logical & logical & logical\tabularnewline
-integer & numeric & integer\tabularnewline
-double & numeric & double\tabularnewline
-complex & complex & comples\tabularnewline
-character & character & character\tabularnewline
-raw & raw & raw\tabularnewline
-\bottomrule
+\bottomrule\noalign{}
+\endlastfoot
+logical & logical & logical \\
+integer & numeric & integer \\
+double & numeric & double \\
+complex & complex & complex \\
+character & character & character \\
+raw & raw & raw \\
 \end{longtable}
+}
 
 Single numbers, such as 4.2, and strings, such as ``four point two'' are
 still vectors, of length 1; there are no more basic types. Vectors with
@@ -1752,8 +2133,8 @@ should be used:
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{vec = R.c(}\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{3}\NormalTok{)}
-\NormalTok{puts vec}
+\NormalTok{vec }\OperatorTok{=} \ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{3}\NormalTok{)}
+\FunctionTok{puts}\NormalTok{ vec}
 \end{Highlighting}
 \end{Shaded}
 
@@ -1767,7 +2148,7 @@ printing it out. A data frame, for those not familiar with it, is
 basically a table. Here we create the data frame and add the column name
 by passing named parameters for each column, such as `typeof:', `mode:'
 and 'storage\_\_mode?`. You should also note here that the double
-underscore is converted to a'.`. So, when printed 'storage\_\_mode' will
+underscore is converted to a'.'. So, when printed `storage\_\_mode' will
 actually print as `storage.mode'.
 
 Data frames will later be more carefully described. In R, the method
@@ -1776,8 +2157,8 @@ used to create a data frame is `data.frame', in Galaaz we use
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{df = R.data__frame(}\StringTok{typeof: }\NormalTok{vec.typeof, }\StringTok{mode: }\NormalTok{vec.mode, }\StringTok{storage__mode: }\NormalTok{vec.storage__mode)}
-\NormalTok{puts df}
+\NormalTok{df }\OperatorTok{=} \ConstantTok{R}\AttributeTok{.data\_\_frame}\NormalTok{(}\WarningTok{typeof:}\NormalTok{ vec}\AttributeTok{.typeof}\NormalTok{, }\WarningTok{mode:}\NormalTok{ vec}\AttributeTok{.mode}\NormalTok{, }\WarningTok{storage\_\_mode:}\NormalTok{ vec}\AttributeTok{.storage\_\_mode}\NormalTok{)}
+\FunctionTok{puts}\NormalTok{ df}
 \end{Highlighting}
 \end{Shaded}
 
@@ -1794,8 +2175,8 @@ normal Ruby rules and the number 1 is an integer and 1.0 is a float.
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{vec = R.c(}\FloatTok{1.0}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{3}\NormalTok{)}
-\NormalTok{puts vec}
+\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}
 
@@ -1805,21 +2186,18 @@ normal Ruby rules and the number 1 is an integer and 1.0 is a float.
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{df = R.data__frame(}\StringTok{typeof: }\NormalTok{vec.typeof, }\StringTok{mode: }\NormalTok{vec.mode, }\StringTok{storage__mode: }\NormalTok{vec.storage__mode)}
-\NormalTok{outputs df.kable.kable_styling}
+\NormalTok{df }\OperatorTok{=} \ConstantTok{R}\AttributeTok{.data\_\_frame}\NormalTok{(}\WarningTok{typeof:}\NormalTok{ vec}\AttributeTok{.typeof}\NormalTok{, }\WarningTok{mode:}\NormalTok{ vec}\AttributeTok{.mode}\NormalTok{, }\WarningTok{storage\_\_mode:}\NormalTok{ vec}\AttributeTok{.storage\_\_mode}\NormalTok{)}
+\NormalTok{outputs df}\AttributeTok{.kable.kable\_styling}
 \end{Highlighting}
 \end{Shaded}
 
-\begin{table}[H]
-\centering
-\begin{tabular}{l|l|l}
-\hline
+\begin{longtable}[t]{lll}
+\toprule
 typeof & mode & storage.mode\\
-\hline
+\midrule
 double & numeric & double\\
-\hline
-\end{tabular}
-\end{table}
+\bottomrule
+\end{longtable}
 
 In this next example we try to create a vector with a variable `hello'
 that has not yet being defined. This will raise an exception that is
@@ -1829,43 +2207,32 @@ error.
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{vec = R.c(}\DecValTok{1}\NormalTok{, hello, }\DecValTok{5}\NormalTok{)}
+\NormalTok{vec }\OperatorTok{=} \ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\DecValTok{1}\NormalTok{, hello, }\DecValTok{5}\NormalTok{)}
 \end{Highlighting}
 \end{Shaded}
 
 \begin{verbatim}
-## Message:
-##  undefined local variable or method `hello' for #<RC:0x3d8 @out_list=nil>:RC
+## undefined local variable or method 'hello' for an instance of RC
 \end{verbatim}
 
 \begin{verbatim}
-## Message:
-##  /home/rbotafogo/desenv/galaaz/lib/util/exec_ruby.rb:103:in `get_binding'
-## /home/rbotafogo/desenv/galaaz/lib/util/exec_ruby.rb:102:in `eval'
-## /home/rbotafogo/desenv/galaaz/lib/util/exec_ruby.rb:102:in `exec_ruby'
-## /home/rbotafogo/desenv/galaaz/lib/gknit/knitr_engine.rb:650:in `block in initialize'
-## /home/rbotafogo/desenv/galaaz/lib/R_interface/ruby_callback.rb:77:in `call'
-## /home/rbotafogo/desenv/galaaz/lib/R_interface/ruby_callback.rb:77:in `callback'
-## (eval):3:in `function(...) {\n          rb_method(...)'
-## unknown.r:1:in `in_dir'
-## unknown.r:1:in `block_exec'
-## /usr/local/lib/graalvm-ce-java11-20.0.0/languages/R/library/knitr/R/block.R:92:in `call_block'
-## /usr/local/lib/graalvm-ce-java11-20.0.0/languages/R/library/knitr/R/block.R:6:in `process_group.block'
-## /usr/local/lib/graalvm-ce-java11-20.0.0/languages/R/library/knitr/R/block.R:3:in `<no source>'
-## unknown.r:1:in `withCallingHandlers'
-## unknown.r:1:in `process_file'
-## unknown.r:1:in `<no source>'
-## unknown.r:1:in `<no source>'
-## <REPL>:4:in `<repl wrapper>'
-## <REPL>:1
+## /home/rbotafogo/desenv_linux/galaaz/lib/util/exec_ruby.rb:170:in 'exec_ruby'
+## org/jruby/RubyKernel.java:1268:in 'eval'
+## /home/rbotafogo/desenv_linux/galaaz/lib/util/exec_ruby.rb:169:in 'exec_ruby'
+## /home/rbotafogo/desenv_linux/galaaz/lib/gknit/knitr_engine.rb:777:in 'block in initialize'
+## org/jruby/RubyBasicObject.java:2695:in 'instance_eval'
+## org/jruby/RubyBasicObject.java:2723:in 'instance_eval'
+## /home/rbotafogo/desenv_linux/galaaz/lib/gknit/knitr_engine.rb:748:in 'block in initialize'
+## /home/rbotafogo/desenv_linux/galaaz/lib/R_interface/new_bridge_adapter.rb:358:in 'block in register_callback_proc_stub'
+## /home/rbotafogo/desenv_linux/galaaz/lib/new_bridge/session_client.rb:413:in 'block in handle_call'
 \end{verbatim}
 
 Here is a vector with logical values
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{vec = R.c(}\DecValTok{true}\NormalTok{, }\DecValTok{true}\NormalTok{, }\DecValTok{false}\NormalTok{, }\DecValTok{false}\NormalTok{, }\DecValTok{true}\NormalTok{)}
-\NormalTok{puts vec}
+\NormalTok{vec }\OperatorTok{=} \ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\DecValTok{true}\NormalTok{, }\DecValTok{true}\NormalTok{, }\DecValTok{false}\NormalTok{, }\DecValTok{false}\NormalTok{, }\DecValTok{true}\NormalTok{)}
+\FunctionTok{puts}\NormalTok{ vec}
 \end{Highlighting}
 \end{Shaded}
 
@@ -1880,10 +2247,10 @@ vectors:
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{vec1 = R.c(}\FloatTok{10.0}\NormalTok{, }\FloatTok{20.0}\NormalTok{, }\FloatTok{30.0}\NormalTok{)}
-\NormalTok{vec2 = R.c(}\FloatTok{4.0}\NormalTok{, }\FloatTok{5.0}\NormalTok{, }\FloatTok{6.0}\NormalTok{)}
-\NormalTok{vec = R.c(vec1, vec2)}
-\NormalTok{puts vec}
+\NormalTok{vec1 }\OperatorTok{=} \ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\FloatTok{10.0}\NormalTok{, }\FloatTok{20.0}\NormalTok{, }\FloatTok{30.0}\NormalTok{)}
+\NormalTok{vec2 }\OperatorTok{=} \ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\FloatTok{4.0}\NormalTok{, }\FloatTok{5.0}\NormalTok{, }\FloatTok{6.0}\NormalTok{)}
+\NormalTok{vec }\OperatorTok{=} \ConstantTok{R}\AttributeTok{.c}\NormalTok{(vec1, vec2)}
+\FunctionTok{puts}\NormalTok{ vec}
 \end{Highlighting}
 \end{Shaded}
 
@@ -1892,18 +2259,18 @@ vectors:
 \end{verbatim}
 
 In galaaz, methods can be chainned (somewhat like the pipe operator in R
-\%\textgreater{}\%, but more generic). In this next example, method `c'
-is chainned after `vec1'. This also looks like `c' is a method of the
+\%\textgreater\%, but more generic). In this next example, method `c' is
+chainned after `vec1'. This also looks like `c' is a method of the
 vector, but in reallity, this is actually closer to the pipe operator.
 When Galaaz identifies that `c' is not a method of `vec' it actually
 tries to call `R.c' with `vec1' as the first argument concatenated with
-all the other available arguments. The code bellow is automatically
+all the other available arguments. The code below is automatically
 converted to the code above.
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{vec = vec1.c(vec2)}
-\NormalTok{puts vec}
+\NormalTok{vec }\OperatorTok{=}\NormalTok{ vec1}\AttributeTok{.c}\NormalTok{(vec2)}
+\FunctionTok{puts}\NormalTok{ vec}
 \end{Highlighting}
 \end{Shaded}
 
@@ -1917,7 +2284,7 @@ Arithmetic operations on vectors are performed element by element:
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts vec1 + vec2}
+\FunctionTok{puts}\NormalTok{ vec1 }\OperatorTok{+}\NormalTok{ vec2}
 \end{Highlighting}
 \end{Shaded}
 
@@ -1927,7 +2294,7 @@ Arithmetic operations on vectors are performed element by element:
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts vec1 * }\DecValTok{5}
+\FunctionTok{puts}\NormalTok{ vec1 }\OperatorTok{*} \DecValTok{5}
 \end{Highlighting}
 \end{Shaded}
 
@@ -1940,8 +2307,8 @@ shorter vector:
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{vec3 = R.c(}\FloatTok{1.0}\NormalTok{, }\FloatTok{2.0}\NormalTok{, }\FloatTok{3.0}\NormalTok{, }\FloatTok{4.0}\NormalTok{, }\FloatTok{5.0}\NormalTok{, }\FloatTok{6.0}\NormalTok{, }\FloatTok{7.0}\NormalTok{, }\FloatTok{8.0}\NormalTok{, }\FloatTok{9.0}\NormalTok{)}
-\NormalTok{puts vec4 = vec1 + vec3}
+\NormalTok{vec3 }\OperatorTok{=} \ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\FloatTok{1.0}\NormalTok{, }\FloatTok{2.0}\NormalTok{, }\FloatTok{3.0}\NormalTok{, }\FloatTok{4.0}\NormalTok{, }\FloatTok{5.0}\NormalTok{, }\FloatTok{6.0}\NormalTok{, }\FloatTok{7.0}\NormalTok{, }\FloatTok{8.0}\NormalTok{, }\FloatTok{9.0}\NormalTok{)}
+\FunctionTok{puts}\NormalTok{ vec4 }\OperatorTok{=}\NormalTok{ vec1 }\OperatorTok{+}\NormalTok{ vec3}
 \end{Highlighting}
 \end{Shaded}
 
@@ -1955,7 +2322,7 @@ Vectors can be indexed by using the `{[}{]}' operator:
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts vec4[}\DecValTok{3}\NormalTok{]}
+\FunctionTok{puts}\NormalTok{ vec4}\KeywordTok{[}\DecValTok{3}\KeywordTok{]}
 \end{Highlighting}
 \end{Shaded}
 
@@ -1964,11 +2331,11 @@ Vectors can be indexed by using the `{[}{]}' operator:
 \end{verbatim}
 
 We can also index a vector with another vector. For example, in the code
-bellow, we take elements 1, 3, 5, and 7 from vec3:
+below, we take elements 1, 3, 5, and 7 from vec3:
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts vec4[R.c(}\DecValTok{1}\NormalTok{, }\DecValTok{3}\NormalTok{, }\DecValTok{5}\NormalTok{, }\DecValTok{7}\NormalTok{)]}
+\FunctionTok{puts}\NormalTok{ vec4}\KeywordTok{[}\ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\DecValTok{1}\NormalTok{, }\DecValTok{3}\NormalTok{, }\DecValTok{5}\NormalTok{, }\DecValTok{7}\NormalTok{)}\KeywordTok{]}
 \end{Highlighting}
 \end{Shaded}
 
@@ -1980,7 +2347,7 @@ Repeating an index and having indices out of order is valid code:
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts vec4[R.c(}\DecValTok{1}\NormalTok{, }\DecValTok{3}\NormalTok{, }\DecValTok{3}\NormalTok{, }\DecValTok{1}\NormalTok{)]}
+\FunctionTok{puts}\NormalTok{ vec4}\KeywordTok{[}\ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\DecValTok{1}\NormalTok{, }\DecValTok{3}\NormalTok{, }\DecValTok{3}\NormalTok{, }\DecValTok{1}\NormalTok{)}\KeywordTok{]}
 \end{Highlighting}
 \end{Shaded}
 
@@ -1993,8 +2360,8 @@ vector. In these cases the indexed values are not returned:
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts vec4[-}\DecValTok{3}\NormalTok{]}
-\NormalTok{puts vec4[-R.c(}\DecValTok{1}\NormalTok{, }\DecValTok{3}\NormalTok{, }\DecValTok{5}\NormalTok{, }\DecValTok{7}\NormalTok{)]}
+\FunctionTok{puts}\NormalTok{ vec4}\KeywordTok{[}\OperatorTok{{-}}\DecValTok{3}\KeywordTok{]}
+\FunctionTok{puts}\NormalTok{ vec4}\KeywordTok{[}\OperatorTok{{-}}\ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\DecValTok{1}\NormalTok{, }\DecValTok{3}\NormalTok{, }\DecValTok{5}\NormalTok{, }\DecValTok{7}\NormalTok{)}\KeywordTok{]}
 \end{Highlighting}
 \end{Shaded}
 
@@ -2007,7 +2374,7 @@ If an index is out of range, a missing value (NA) will be reported.
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts vec4[}\DecValTok{30}\NormalTok{]}
+\FunctionTok{puts}\NormalTok{ vec4}\KeywordTok{[}\DecValTok{30}\KeywordTok{]}
 \end{Highlighting}
 \end{Shaded}
 
@@ -2019,7 +2386,7 @@ It is also possible to index a vector by range:
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts vec4[(}\DecValTok{2}\NormalTok{..}\DecValTok{5}\NormalTok{)]}
+\FunctionTok{puts}\NormalTok{ vec4}\KeywordTok{[}\NormalTok{(}\DecValTok{2}\OperatorTok{..}\DecValTok{5}\NormalTok{)}\KeywordTok{]}
 \end{Highlighting}
 \end{Shaded}
 
@@ -2032,9 +2399,9 @@ vector:
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{full_name = R.c(}\StringTok{"Rodrigo"}\NormalTok{, }\StringTok{"A"}\NormalTok{, }\StringTok{"Botafogo"}\NormalTok{)}
-\NormalTok{full_name.names = R.c(}\StringTok{"First"}\NormalTok{, }\StringTok{"Middle"}\NormalTok{, }\StringTok{"Last"}\NormalTok{)}
-\NormalTok{puts full_name}
+\NormalTok{full\_name }\OperatorTok{=} \ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\StringTok{"Rodrigo"}\NormalTok{, }\StringTok{"A"}\NormalTok{, }\StringTok{"Botafogo"}\NormalTok{)}
+\NormalTok{full\_name}\AttributeTok{.names} \OperatorTok{=} \ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\StringTok{"First"}\NormalTok{, }\StringTok{"Middle"}\NormalTok{, }\StringTok{"Last"}\NormalTok{)}
+\FunctionTok{puts}\NormalTok{ full\_name}
 \end{Highlighting}
 \end{Shaded}
 
@@ -2048,8 +2415,8 @@ paramenters:
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{full_name = R.c(}\DataTypeTok{First}\NormalTok{: }\StringTok{"Rodrigo"}\NormalTok{, }\DataTypeTok{Middle}\NormalTok{: }\StringTok{"A"}\NormalTok{, }\DataTypeTok{Last}\NormalTok{: }\StringTok{"Botafogo"}\NormalTok{)}
-\NormalTok{puts full_name}
+\NormalTok{full\_name }\OperatorTok{=} \ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\WarningTok{First:} \StringTok{"Rodrigo"}\NormalTok{, }\WarningTok{Middle:} \StringTok{"A"}\NormalTok{, }\WarningTok{Last:} \StringTok{"Botafogo"}\NormalTok{)}
+\FunctionTok{puts}\NormalTok{ full\_name}
 \end{Highlighting}
 \end{Shaded}
 
@@ -2066,13 +2433,13 @@ noticed that when indexing a vector, a new vector is returned, even if
 this vector has one single element. In order to use R::Vector with other
 ruby classes it might be necessary to extract the actual Ruby native
 type from the vector. In order to do this extraction the
-`\textgreater{}\textgreater{}' operator is used.
+`\textgreater\textgreater{}' operator is used.
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts vec4}
-\NormalTok{puts vec4 >> }\DecValTok{0}
-\NormalTok{puts vec4 >> }\DecValTok{4}
+\FunctionTok{puts}\NormalTok{ vec4}
+\FunctionTok{puts}\NormalTok{ vec4 }\OperatorTok{\textgreater{}\textgreater{}} \DecValTok{0}
+\FunctionTok{puts}\NormalTok{ vec4 }\OperatorTok{\textgreater{}\textgreater{}} \DecValTok{4}
 \end{Highlighting}
 \end{Shaded}
 
@@ -2082,8 +2449,8 @@ type from the vector. In order to do this extraction the
 ## 25.0
 \end{verbatim}
 
-Note that indexing with `\textgreater{}\textgreater{}' starts at 0 and
-not at 1, also, we cannot do negative indexing.
+Note that indexing with `\textgreater\textgreater{}' starts at 0 and not
+at 1, also, we cannot do negative indexing.
 
 \subsection{Matrix}\label{matrix}
 
@@ -2092,11 +2459,11 @@ table. A matrix can be created by the `matrix' function:
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{mat = R.matrix(R.c(}\FloatTok{1.0}\NormalTok{, }\FloatTok{2.0}\NormalTok{, }\FloatTok{3.0}\NormalTok{, }\FloatTok{4.0}\NormalTok{, }\FloatTok{5.0}\NormalTok{, }\FloatTok{6.0}\NormalTok{, }\FloatTok{7.0}\NormalTok{, }\FloatTok{8.0}\NormalTok{, }\FloatTok{9.0}\NormalTok{),}
-               \StringTok{nrow: }\DecValTok{3}\NormalTok{,}
-               \StringTok{ncol: }\DecValTok{3}\NormalTok{)}
+\NormalTok{mat }\OperatorTok{=} \ConstantTok{R}\AttributeTok{.matrix}\NormalTok{(}\ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\FloatTok{1.0}\NormalTok{, }\FloatTok{2.0}\NormalTok{, }\FloatTok{3.0}\NormalTok{, }\FloatTok{4.0}\NormalTok{, }\FloatTok{5.0}\NormalTok{, }\FloatTok{6.0}\NormalTok{, }\FloatTok{7.0}\NormalTok{, }\FloatTok{8.0}\NormalTok{, }\FloatTok{9.0}\NormalTok{),}
+               \WarningTok{nrow:} \DecValTok{3}\NormalTok{,}
+               \WarningTok{ncol:} \DecValTok{3}\NormalTok{)}
 
-\NormalTok{puts mat}
+\FunctionTok{puts}\NormalTok{ mat}
 \end{Highlighting}
 \end{Shaded}
 
@@ -2113,12 +2480,12 @@ organize the matrix memory by row first passing an extra argument to the
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{mat_row = R.matrix(R.c(}\FloatTok{1.0}\NormalTok{, }\FloatTok{2.0}\NormalTok{, }\FloatTok{3.0}\NormalTok{, }\FloatTok{4.0}\NormalTok{, }\FloatTok{5.0}\NormalTok{, }\FloatTok{6.0}\NormalTok{, }\FloatTok{7.0}\NormalTok{, }\FloatTok{8.0}\NormalTok{, }\FloatTok{9.0}\NormalTok{),}
-                   \StringTok{nrow: }\DecValTok{3}\NormalTok{,}
-                   \StringTok{ncol: }\DecValTok{3}\NormalTok{,}
-                   \StringTok{byrow: }\DecValTok{true}\NormalTok{)}
+\NormalTok{mat\_row }\OperatorTok{=} \ConstantTok{R}\AttributeTok{.matrix}\NormalTok{(}\ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\FloatTok{1.0}\NormalTok{, }\FloatTok{2.0}\NormalTok{, }\FloatTok{3.0}\NormalTok{, }\FloatTok{4.0}\NormalTok{, }\FloatTok{5.0}\NormalTok{, }\FloatTok{6.0}\NormalTok{, }\FloatTok{7.0}\NormalTok{, }\FloatTok{8.0}\NormalTok{, }\FloatTok{9.0}\NormalTok{),}
+                   \WarningTok{nrow:} \DecValTok{3}\NormalTok{,}
+                   \WarningTok{ncol:} \DecValTok{3}\NormalTok{,}
+                   \WarningTok{byrow:} \DecValTok{true}\NormalTok{)}
 
-\NormalTok{puts mat_row}
+\FunctionTok{puts}\NormalTok{ mat\_row}
 \end{Highlighting}
 \end{Shaded}
 
@@ -2135,8 +2502,8 @@ A matrix can be indexed by {[}row, column{]}:
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts mat_row[}\DecValTok{1}\NormalTok{, }\DecValTok{1}\NormalTok{]}
-\NormalTok{puts mat_row[}\DecValTok{2}\NormalTok{, }\DecValTok{3}\NormalTok{]}
+\FunctionTok{puts}\NormalTok{ mat\_row}\KeywordTok{[}\DecValTok{1}\NormalTok{, }\DecValTok{1}\KeywordTok{]}
+\FunctionTok{puts}\NormalTok{ mat\_row}\KeywordTok{[}\DecValTok{2}\NormalTok{, }\DecValTok{3}\KeywordTok{]}
 \end{Highlighting}
 \end{Shaded}
 
@@ -2149,8 +2516,8 @@ It is possible to index an entire row or column with the `:all' keyword
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts mat_row[}\DecValTok{1}\NormalTok{, }\StringTok{:all}\NormalTok{]}
-\NormalTok{puts mat_row[}\StringTok{:all}\NormalTok{, }\DecValTok{2}\NormalTok{]}
+\FunctionTok{puts}\NormalTok{ mat\_row}\KeywordTok{[}\DecValTok{1}\NormalTok{, }\WarningTok{:all}\KeywordTok{]}
+\FunctionTok{puts}\NormalTok{ mat\_row}\KeywordTok{[}\WarningTok{:all}\NormalTok{, }\DecValTok{2}\KeywordTok{]}
 \end{Highlighting}
 \end{Shaded}
 
@@ -2165,7 +2532,7 @@ matrix.
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts mat_row[R.c(}\DecValTok{1}\NormalTok{, }\DecValTok{3}\NormalTok{), R.c(}\DecValTok{2}\NormalTok{, }\DecValTok{3}\NormalTok{)]}
+\FunctionTok{puts}\NormalTok{ mat\_row}\KeywordTok{[}\ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\DecValTok{1}\NormalTok{, }\DecValTok{3}\NormalTok{), }\ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\DecValTok{2}\NormalTok{, }\DecValTok{3}\NormalTok{)}\KeywordTok{]}
 \end{Highlighting}
 \end{Shaded}
 
@@ -2179,7 +2546,7 @@ Matrices can be combined with functions `rbind':
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts mat_row.rbind(mat)}
+\FunctionTok{puts}\NormalTok{ mat\_row}\AttributeTok{.rbind}\NormalTok{(mat)}
 \end{Highlighting}
 \end{Shaded}
 
@@ -2197,7 +2564,7 @@ and `cbind':
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts mat_row.cbind(mat)}
+\FunctionTok{puts}\NormalTok{ mat\_row}\AttributeTok{.cbind}\NormalTok{(mat)}
 \end{Highlighting}
 \end{Shaded}
 
@@ -2215,11 +2582,11 @@ while vector and matrix can only hold one type of element.
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{nums = R.c(}\FloatTok{1.0}\NormalTok{, }\FloatTok{2.0}\NormalTok{, }\FloatTok{3.0}\NormalTok{)}
-\NormalTok{strs = R.c(}\StringTok{"a"}\NormalTok{, }\StringTok{"b"}\NormalTok{, }\StringTok{"c"}\NormalTok{, }\StringTok{"d"}\NormalTok{)}
-\NormalTok{bool = R.c(}\DecValTok{true}\NormalTok{, }\DecValTok{true}\NormalTok{, }\DecValTok{false}\NormalTok{)}
-\NormalTok{lst = R.list(}\StringTok{nums: }\NormalTok{nums, }\StringTok{strs: }\NormalTok{strs, }\StringTok{bool: }\NormalTok{bool)}
-\NormalTok{puts lst}
+\NormalTok{nums }\OperatorTok{=} \ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\FloatTok{1.0}\NormalTok{, }\FloatTok{2.0}\NormalTok{, }\FloatTok{3.0}\NormalTok{)}
+\NormalTok{strs }\OperatorTok{=} \ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\StringTok{"a"}\NormalTok{, }\StringTok{"b"}\NormalTok{, }\StringTok{"c"}\NormalTok{, }\StringTok{"d"}\NormalTok{)}
+\NormalTok{bool }\OperatorTok{=} \ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\DecValTok{true}\NormalTok{, }\DecValTok{true}\NormalTok{, }\DecValTok{false}\NormalTok{)}
+\NormalTok{lst }\OperatorTok{=} \ConstantTok{R}\AttributeTok{.list}\NormalTok{(}\WarningTok{nums:}\NormalTok{ nums, }\WarningTok{strs:}\NormalTok{ strs, }\WarningTok{bool:}\NormalTok{ bool)}
+\FunctionTok{puts}\NormalTok{ lst}
 \end{Highlighting}
 \end{Shaded}
 
@@ -2245,7 +2612,7 @@ return one of the sublists.
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts lst[}\DecValTok{1}\NormalTok{]}
+\FunctionTok{puts}\NormalTok{ lst}\KeywordTok{[}\DecValTok{1}\KeywordTok{]}
 \end{Highlighting}
 \end{Shaded}
 
@@ -2260,7 +2627,7 @@ of the list in the given position and not a slice of the original list
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts lst[[}\DecValTok{1}\NormalTok{]]}
+\FunctionTok{puts}\NormalTok{ lst}\KeywordTok{[[}\DecValTok{1}\KeywordTok{]]}
 \end{Highlighting}
 \end{Shaded}
 
@@ -2273,7 +2640,7 @@ name:
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts lst[[}\StringTok{'bool'}\NormalTok{]][[}\DecValTok{1}\NormalTok{]] >> }\DecValTok{0}
+\FunctionTok{puts}\NormalTok{ lst}\KeywordTok{[[}\VerbatimStringTok{\textquotesingle{}bool\textquotesingle{}}\KeywordTok{]][[}\DecValTok{1}\KeywordTok{]]} \OperatorTok{\textgreater{}\textgreater{}} \DecValTok{0}
 \end{Highlighting}
 \end{Shaded}
 
@@ -2292,16 +2659,16 @@ native Ruby type.
 A data frame is a table like structure in which each column has the same
 number of rows. Data frames are the basic structure for storing data for
 data analysis. We have already seen a data frame previously when we
-accessed variable `\textasciitilde{}:mtcars'. In order to create a data
+accessed variable `\textasciitilde:mtcars'. In order to create a data
 frame, function 'data\_\_frame' is used:
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{df = R.data__frame(}
-  \StringTok{year: }\NormalTok{R.c(}\DecValTok{2010}\NormalTok{, }\DecValTok{2011}\NormalTok{, }\DecValTok{2012}\NormalTok{),}
-  \StringTok{income: }\NormalTok{R.c(}\FloatTok{1000.0}\NormalTok{, }\FloatTok{1500.0}\NormalTok{, }\FloatTok{2000.0}\NormalTok{))}
+\NormalTok{df }\OperatorTok{=} \ConstantTok{R}\AttributeTok{.data\_\_frame}\NormalTok{(}
+  \WarningTok{year:} \ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\DecValTok{2010}\NormalTok{, }\DecValTok{2011}\NormalTok{, }\DecValTok{2012}\NormalTok{),}
+  \WarningTok{income:} \ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\FloatTok{1000.0}\NormalTok{, }\FloatTok{1500.0}\NormalTok{, }\FloatTok{2000.0}\NormalTok{))}
 
-\NormalTok{puts df}
+\FunctionTok{puts}\NormalTok{ df}
 \end{Highlighting}
 \end{Shaded}
 
@@ -2320,9 +2687,9 @@ the row or column
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts (~}\StringTok{:mtcars}\NormalTok{).head}
-\NormalTok{puts (~}\StringTok{:mtcars}\NormalTok{)[}\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{]}
-\NormalTok{puts (~}\StringTok{:mtcars}\NormalTok{)[}\StringTok{'Datsun 710'}\NormalTok{, }\StringTok{'mpg'}\NormalTok{]}
+\FunctionTok{puts}\NormalTok{ (}\OperatorTok{\textasciitilde{}}\WarningTok{:mtcars}\NormalTok{)}\AttributeTok{.head}
+\FunctionTok{puts}\NormalTok{ (}\OperatorTok{\textasciitilde{}}\WarningTok{:mtcars}\NormalTok{)}\KeywordTok{[}\DecValTok{1}\NormalTok{, }\DecValTok{2}\KeywordTok{]}
+\FunctionTok{puts}\NormalTok{ (}\OperatorTok{\textasciitilde{}}\WarningTok{:mtcars}\NormalTok{)}\KeywordTok{[}\VerbatimStringTok{\textquotesingle{}Datsun 710\textquotesingle{}}\NormalTok{, }\VerbatimStringTok{\textquotesingle{}mpg\textquotesingle{}}\KeywordTok{]}
 \end{Highlighting}
 \end{Shaded}
 
@@ -2343,14 +2710,14 @@ the double square bracket operator:
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts (~}\StringTok{:mtcars}\NormalTok{)[[}\StringTok{'mpg'}\NormalTok{]]}
+\FunctionTok{puts}\NormalTok{ (}\OperatorTok{\textasciitilde{}}\WarningTok{:mtcars}\NormalTok{)}\KeywordTok{[[}\VerbatimStringTok{\textquotesingle{}mpg\textquotesingle{}}\KeywordTok{]]}
 \end{Highlighting}
 \end{Shaded}
 
 \begin{verbatim}
-##  [1] 21.0 21.0 22.8 21.4 18.7 18.1 14.3 24.4 22.8 19.2 17.8 16.4 17.3 15.2
-## [15] 10.4 10.4 14.7 32.4 30.4 33.9 21.5 15.5 15.2 13.3 19.2 27.3 26.0 30.4
-## [29] 15.8 19.7 15.0 21.4
+##  [1] 21.0 21.0 22.8 21.4 18.7 18.1 14.3 24.4 22.8 19.2 17.8 16.4 17.3 15.2 10.4
+## [16] 10.4 14.7 32.4 30.4 33.9 21.5 15.5 15.2 13.3 19.2 27.3 26.0 30.4 15.8 19.7
+## [31] 15.0 21.4
 \end{verbatim}
 
 A data frame column can also be accessed as if it were an instance
@@ -2358,14 +2725,14 @@ variable of the data frame:
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts (~}\StringTok{:mtcars}\NormalTok{).mpg}
+\FunctionTok{puts}\NormalTok{ (}\OperatorTok{\textasciitilde{}}\WarningTok{:mtcars}\NormalTok{)}\AttributeTok{.mpg}
 \end{Highlighting}
 \end{Shaded}
 
 \begin{verbatim}
-##  [1] 21.0 21.0 22.8 21.4 18.7 18.1 14.3 24.4 22.8 19.2 17.8 16.4 17.3 15.2
-## [15] 10.4 10.4 14.7 32.4 30.4 33.9 21.5 15.5 15.2 13.3 19.2 27.3 26.0 30.4
-## [29] 15.8 19.7 15.0 21.4
+##  [1] 21.0 21.0 22.8 21.4 18.7 18.1 14.3 24.4 22.8 19.2 17.8 16.4 17.3 15.2 10.4
+## [16] 10.4 14.7 32.4 30.4 33.9 21.5 15.5 15.2 13.3 19.2 27.3 26.0 30.4 15.8 19.7
+## [31] 15.0 21.4
 \end{verbatim}
 
 Slicing a data frame can be done by indexing it with a vector (we use
@@ -2373,18 +2740,14 @@ Slicing a data frame can be done by indexing it with a vector (we use
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts (~}\StringTok{:mtcars}\NormalTok{)[R.c(}\StringTok{'mpg'}\NormalTok{, }\StringTok{'hp'}\NormalTok{)].head}
+\FunctionTok{puts}\NormalTok{ (}\OperatorTok{\textasciitilde{}}\WarningTok{:mtcars}\NormalTok{)}\KeywordTok{[}\ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\VerbatimStringTok{\textquotesingle{}mpg\textquotesingle{}}\NormalTok{, }\VerbatimStringTok{\textquotesingle{}hp\textquotesingle{}}\NormalTok{)}\KeywordTok{]}\AttributeTok{.head}
 \end{Highlighting}
 \end{Shaded}
 
 \begin{verbatim}
-##                    mpg  hp
-## Mazda RX4         21.0 110
-## Mazda RX4 Wag     21.0 110
-## Datsun 710        22.8  93
-## Hornet 4 Drive    21.4 110
-## Hornet Sportabout 18.7 175
-## Valiant           18.1 105
+##      mpg cyl disp hp drat wt qsec vs am gear carb
+## NA    NA  NA   NA NA   NA NA   NA NA NA   NA   NA
+## NA.1  NA  NA   NA NA   NA NA   NA NA NA   NA   NA
 \end{verbatim}
 
 A row slice can be obtained by indexing by row and using the `:all'
@@ -2392,7 +2755,7 @@ keyword for the column:
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts (~}\StringTok{:mtcars}\NormalTok{)[R.c(}\StringTok{'Datsun 710'}\NormalTok{, }\StringTok{'Camaro Z28'}\NormalTok{), }\StringTok{:all}\NormalTok{]}
+\FunctionTok{puts}\NormalTok{ (}\OperatorTok{\textasciitilde{}}\WarningTok{:mtcars}\NormalTok{)}\KeywordTok{[}\ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\VerbatimStringTok{\textquotesingle{}Datsun 710\textquotesingle{}}\NormalTok{, }\VerbatimStringTok{\textquotesingle{}Camaro Z28\textquotesingle{}}\NormalTok{), }\WarningTok{:all}\KeywordTok{]}
 \end{Highlighting}
 \end{Shaded}
 
@@ -2405,21 +2768,21 @@ keyword for the column:
 Finally, a data frame can also be indexed with a logical vector. In this
 next example, the `am' column of :mtcars is compared with 0 (with method
 `eq'). When `am' is equal to 0 the car is automatic. So, by doing
-`(\textasciitilde{}:mtcars).am.eq 0' a logical vector is created with
+`(\textasciitilde:mtcars).am.eq 0' a logical vector is created with
 `true' whenever `am' is 0 and `false' otherwise.
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\CommentTok{# obtain a vector with 'true' for cars with automatic transmission}
-\NormalTok{automatic = (~}\StringTok{:mtcars}\NormalTok{).am.eq }\DecValTok{0}
-\NormalTok{puts automatic}
+\CommentTok{\# obtain a vector with \textquotesingle{}true\textquotesingle{} for cars with automatic transmission}
+\NormalTok{automatic }\OperatorTok{=}\NormalTok{ (}\OperatorTok{\textasciitilde{}}\WarningTok{:mtcars}\NormalTok{)}\AttributeTok{.am.eq} \DecValTok{0}
+\FunctionTok{puts}\NormalTok{ automatic}
 \end{Highlighting}
 \end{Shaded}
 
 \begin{verbatim}
-##  [1] FALSE FALSE FALSE  TRUE  TRUE  TRUE  TRUE  TRUE  TRUE  TRUE  TRUE
-## [12]  TRUE  TRUE  TRUE  TRUE  TRUE  TRUE FALSE FALSE FALSE  TRUE  TRUE
-## [23]  TRUE  TRUE  TRUE FALSE FALSE FALSE FALSE FALSE FALSE FALSE
+##  [1] FALSE FALSE FALSE  TRUE  TRUE  TRUE  TRUE  TRUE  TRUE  TRUE  TRUE  TRUE
+## [13]  TRUE  TRUE  TRUE  TRUE  TRUE FALSE FALSE FALSE  TRUE  TRUE  TRUE  TRUE
+## [25]  TRUE FALSE FALSE FALSE FALSE FALSE FALSE FALSE
 \end{verbatim}
 
 Using this logical vector, the data frame is indexed, returning a new
@@ -2427,8 +2790,8 @@ data frame in which all cars have automatic transmission.
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\CommentTok{# slice the data frame by using this vector}
-\NormalTok{puts (~}\StringTok{:mtcars}\NormalTok{)[automatic, }\StringTok{:all}\NormalTok{]}
+\CommentTok{\# slice the data frame by using this vector}
+\FunctionTok{puts}\NormalTok{ (}\OperatorTok{\textasciitilde{}}\WarningTok{:mtcars}\NormalTok{)}\KeywordTok{[}\NormalTok{automatic, }\WarningTok{:all}\KeywordTok{]}
 \end{Highlighting}
 \end{Shaded}
 
@@ -2465,12 +2828,12 @@ a look at some of those expressions.
 \subsection{Expressions from
 operators}\label{expressions-from-operators}
 
-The code bellow creates an expression summing two symbols
+The code below creates an expression summing two symbols
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{exp1 = }\StringTok{:a}\NormalTok{ + }\StringTok{:b}
-\NormalTok{puts exp1}
+\NormalTok{exp1 }\OperatorTok{=} \WarningTok{:a} \OperatorTok{+} \WarningTok{:b}
+\FunctionTok{puts}\NormalTok{ exp1}
 \end{Highlighting}
 \end{Shaded}
 
@@ -2482,21 +2845,21 @@ We can build any complex mathematical expression
 
 \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}
+\NormalTok{exp2 }\OperatorTok{=}\NormalTok{ (}\WarningTok{:a} \OperatorTok{+} \WarningTok{:b}\NormalTok{) }\OperatorTok{*} \FloatTok{2.0} \OperatorTok{+} \WarningTok{:c} \OperatorTok{**} \DecValTok{2} \OperatorTok{/} \WarningTok{:z}
+\FunctionTok{puts}\NormalTok{ exp2}
 \end{Highlighting}
 \end{Shaded}
 
 \begin{verbatim}
-## (a + b) * 2 + c^2L/z
+## a + b * 2.0 + c ^ 2L / z
 \end{verbatim}
 
 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}
+\NormalTok{exp3 }\OperatorTok{=}\NormalTok{ (}\WarningTok{:a} \OperatorTok{+} \WarningTok{:b}\NormalTok{) }\OperatorTok{\textgreater{}=} \WarningTok{:z}
+\FunctionTok{puts}\NormalTok{ exp3}
 \end{Highlighting}
 \end{Shaded}
 
@@ -2505,14 +2868,14 @@ It is also possible to use inequality operators in building expressions
 \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
+(\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}
+\NormalTok{exp4 }\OperatorTok{=}\NormalTok{ (}\WarningTok{:a} \OperatorTok{+} \WarningTok{:b}\NormalTok{)}\AttributeTok{.ge} \OperatorTok{:}\NormalTok{z}
+\FunctionTok{puts}\NormalTok{ exp4}
 \end{Highlighting}
 \end{Shaded}
 
@@ -2527,8 +2890,8 @@ 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}
+\NormalTok{exp5 }\OperatorTok{=}\NormalTok{ (}\WarningTok{:a} \OperatorTok{+} \WarningTok{:b}\NormalTok{)}\AttributeTok{.eq} \OperatorTok{:}\NormalTok{z}
+\FunctionTok{puts}\NormalTok{ exp5}
 \end{Highlighting}
 \end{Shaded}
 
@@ -2538,8 +2901,8 @@ the method `.eq' and for `=' we need the function `.assign'
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{exp6 = }\StringTok{:y}\NormalTok{.assign }\StringTok{:a}\NormalTok{ + }\StringTok{:b}
-\NormalTok{puts exp6}
+\NormalTok{exp6 }\OperatorTok{=} \WarningTok{:y}\AttributeTok{.assign} \OperatorTok{:}\NormalTok{a }\OperatorTok{+} \WarningTok{:b}
+\FunctionTok{puts}\NormalTok{ exp6}
 \end{Highlighting}
 \end{Shaded}
 
@@ -2553,8 +2916,8 @@ expressions such as
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{exp_wrong = (}\StringTok{:a}\NormalTok{ + }\StringTok{:b}\NormalTok{) == }\StringTok{:z}
-\NormalTok{puts exp_wrong}
+\NormalTok{exp\_wrong }\OperatorTok{=}\NormalTok{ (}\WarningTok{:a} \OperatorTok{+} \WarningTok{:b}\NormalTok{) }\OperatorTok{==} \WarningTok{:z}
+\FunctionTok{puts}\NormalTok{ exp\_wrong}
 \end{Highlighting}
 \end{Shaded}
 
@@ -2580,8 +2943,8 @@ such as `E.sin(x)'
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{exp7 = }\StringTok{:y}\NormalTok{.assign E.sin(}\StringTok{:x}\NormalTok{)}
-\NormalTok{puts exp7}
+\NormalTok{exp7 }\OperatorTok{=} \WarningTok{:y}\AttributeTok{.assign} \ConstantTok{E}\AttributeTok{.sin}\NormalTok{(}\WarningTok{:x}\NormalTok{)}
+\FunctionTok{puts}\NormalTok{ exp7}
 \end{Highlighting}
 \end{Shaded}
 
@@ -2593,8 +2956,8 @@ Expressions can also be written using `.' notation:
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{exp8 = }\StringTok{:y}\NormalTok{.assign }\StringTok{:x}\NormalTok{.sin}
-\NormalTok{puts exp8}
+\NormalTok{exp8 }\OperatorTok{=} \WarningTok{:y}\AttributeTok{.assign} \OperatorTok{:}\NormalTok{x}\AttributeTok{.sin}
+\FunctionTok{puts}\NormalTok{ exp8}
 \end{Highlighting}
 \end{Shaded}
 
@@ -2607,8 +2970,8 @@ the `.':
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{exp9 = }\StringTok{:x}\NormalTok{.c(}\StringTok{:y}\NormalTok{)}
-\NormalTok{puts exp9}
+\NormalTok{exp9 }\OperatorTok{=} \WarningTok{:x}\AttributeTok{.c}\NormalTok{(}\WarningTok{:y}\NormalTok{)}
+\FunctionTok{puts}\NormalTok{ exp9}
 \end{Highlighting}
 \end{Shaded}
 
@@ -2623,37 +2986,37 @@ 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{))}
+\NormalTok{exp }\OperatorTok{=}\NormalTok{ (}\WarningTok{:a} \OperatorTok{+} \WarningTok{:b}\NormalTok{) }\OperatorTok{*} \FloatTok{2.0} \OperatorTok{+} \WarningTok{:c} \OperatorTok{**} \DecValTok{2} \OperatorTok{/} \WarningTok{:z}
+\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] 82.5
+## [1] 72.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{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{))}
 
-\NormalTok{puts exp.eval(df)}
+\FunctionTok{puts}\NormalTok{ exp}\AttributeTok{.eval}\NormalTok{(df)}
 \end{Highlighting}
 \end{Shaded}
 
 \begin{verbatim}
-## [1] 32 64 96
+## [1] 31 62 93
 \end{verbatim}
 
 \section{Manipulating Data}\label{manipulating-data}
 
 One of the major benefits of Galaaz is to bring strong data manipulation
-to Ruby. The following examples were extracted from Hardley's ``R for
+to Ruby. The following examples were extracted from Hadley's ``R for
 Data Science'' (\url{https://r4ds.had.co.nz/}). This is a highly
 recommended book for those not already familiar with the `tidyverse'
 style of programming in R. In the sections to follow, we will limit
@@ -2666,39 +3029,38 @@ and if not, installs it. This data frame contains all 336,776 flights
 that departed from New York City in 2013. The data comes from the US
 Bureau of Transportation Statistics.
 
-Dplyr uses `tibbles' in place of data frames; unfortunately, tibbles do
-not print yet properly in Galaaz due to a bug in fastR. In order to
-print a tibble we need to convert it to a data frame using the
-'as\_\_data\_\_frame' method.
+Dplyr often uses \textbf{tibbles} in place of classic data frames. In
+Galaaz, printing may differ from the R console; if you need a classic
+tabular printout, convert with \textbf{\texttt{as\_\_data\_\_frame}} (or
+use \texttt{head} / \texttt{str} in R via \texttt{R} calls).
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{R.install_and_loads(}\StringTok{'nycflights13'}\NormalTok{)}
-\NormalTok{R.library(}\StringTok{'dplyr'}\NormalTok{)}
+\ConstantTok{R}\AttributeTok{.install\_and\_loads}\NormalTok{(}\VerbatimStringTok{\textquotesingle{}nycflights13\textquotesingle{}}\NormalTok{)}
+\ConstantTok{R}\AttributeTok{.library}\NormalTok{(}\VerbatimStringTok{\textquotesingle{}dplyr\textquotesingle{}}\NormalTok{)}
 \end{Highlighting}
 \end{Shaded}
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{flights = ~}\StringTok{:flights}
-\NormalTok{puts flights.head}
+\NormalTok{flights }\OperatorTok{=} \OperatorTok{\textasciitilde{}}\WarningTok{:flights}
+\FunctionTok{puts}\NormalTok{ flights}\AttributeTok{.head}
 \end{Highlighting}
 \end{Shaded}
 
 \begin{verbatim}
 ## # A tibble: 6 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
-## # ... with 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>
+##    year month   day dep_time sched_dep_time dep_delay arr_time sched_arr_time
+##   <int> <int> <int>    <int>          <int>     <dbl>    <int>          <int>
+## 1  2013     1     1      517            515         2      830            819
+## 2  2013     1     1      533            529         4      850            830
+## 3  2013     1     1      542            540         2      923            850
+## 4  2013     1     1      544            545        -1     1004           1022
+## 5  2013     1     1      554            600        -6      812            837
+## 6  2013     1     1      554            558        -4      740            728
+## # i 11 more variables: 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{Filtering rows with
@@ -2709,24 +3071,23 @@ function two expressions: the first :month.eq 1
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts flights.filter((}\StringTok{:month}\NormalTok{.eq }\DecValTok{1}\NormalTok{), (}\StringTok{:day}\NormalTok{.eq }\DecValTok{1}\NormalTok{)).head}
+\FunctionTok{puts}\NormalTok{ flights}\AttributeTok{.filter}\NormalTok{((}\WarningTok{:month}\AttributeTok{.eq} \DecValTok{1}\NormalTok{), (}\WarningTok{:day}\AttributeTok{.eq} \DecValTok{1}\NormalTok{))}\AttributeTok{.head}
 \end{Highlighting}
 \end{Shaded}
 
 \begin{verbatim}
 ## # A tibble: 6 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
-## # ... with 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>
+##    year month   day dep_time sched_dep_time dep_delay arr_time sched_arr_time
+##   <int> <int> <int>    <int>          <int>     <dbl>    <int>          <int>
+## 1  2013     1     1      517            515         2      830            819
+## 2  2013     1     1      533            529         4      850            830
+## 3  2013     1     1      542            540         2      923            850
+## 4  2013     1     1      544            545        -1     1004           1022
+## 5  2013     1     1      554            600        -6      812            837
+## 6  2013     1     1      554            558        -4      740            728
+## # i 11 more variables: 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{Logical Operators}\label{logical-operators}
@@ -2735,52 +3096,50 @@ All flights that departed in November of December
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts flights.filter((}\StringTok{:month}\NormalTok{.eq }\DecValTok{11}\NormalTok{) | (}\StringTok{:month}\NormalTok{.eq }\DecValTok{12}\NormalTok{)).head}
+\FunctionTok{puts}\NormalTok{ flights}\AttributeTok{.filter}\NormalTok{((}\WarningTok{:month}\AttributeTok{.eq} \DecValTok{11}\NormalTok{) }\OperatorTok{|}\NormalTok{ (}\WarningTok{:month}\AttributeTok{.eq} \DecValTok{12}\NormalTok{))}\AttributeTok{.head}
 \end{Highlighting}
 \end{Shaded}
 
 \begin{verbatim}
 ## # A tibble: 6 x 19
-##    year month   day dep_time sched_dep_time dep_delay arr_time
-##   <int> <int> <int>    <int>          <int>     <dbl>    <int>
-## 1  2013    11     1        5           2359         6      352
-## 2  2013    11     1       35           2250       105      123
-## 3  2013    11     1      455            500        -5      641
-## 4  2013    11     1      539            545        -6      856
-## 5  2013    11     1      542            545        -3      831
-## 6  2013    11     1      549            600       -11      912
-## # ... with 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>
+##    year month   day dep_time sched_dep_time dep_delay arr_time sched_arr_time
+##   <int> <int> <int>    <int>          <int>     <dbl>    <int>          <int>
+## 1  2013    11     1        5           2359         6      352            345
+## 2  2013    11     1       35           2250       105      123           2356
+## 3  2013    11     1      455            500        -5      641            651
+## 4  2013    11     1      539            545        -6      856            827
+## 5  2013    11     1      542            545        -3      831            855
+## 6  2013    11     1      549            600       -11      912            923
+## # i 11 more variables: 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}
 
 The same as above, but using the `in' operator. In R, it is possible to
 define many operators by doing \%\%. The \%in\% operator checks if a
 value is in a vector. In order to use those operators from Galaaz the
-'.\_`method is used, where the first argument is the operator's symbol,
-in this case':in' and the second argument is the vector:
+`.\_' method is used, where the first argument is the operator's symbol,
+in this case `:in' and the second argument is the vector:
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts flights.filter(}\StringTok{:month}\NormalTok{._ }\StringTok{:in}\NormalTok{, R.c(}\DecValTok{11}\NormalTok{, }\DecValTok{12}\NormalTok{)).head}
+\FunctionTok{puts}\NormalTok{ flights}\AttributeTok{.filter}\NormalTok{(}\WarningTok{:month}\AttributeTok{.\_} \OperatorTok{:}\ControlFlowTok{in}\NormalTok{, }\ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\DecValTok{11}\NormalTok{, }\DecValTok{12}\NormalTok{))}\AttributeTok{.head}
 \end{Highlighting}
 \end{Shaded}
 
 \begin{verbatim}
 ## # A tibble: 6 x 19
-##    year month   day dep_time sched_dep_time dep_delay arr_time
-##   <int> <int> <int>    <int>          <int>     <dbl>    <int>
-## 1  2013    11     1        5           2359         6      352
-## 2  2013    11     1       35           2250       105      123
-## 3  2013    11     1      455            500        -5      641
-## 4  2013    11     1      539            545        -6      856
-## 5  2013    11     1      542            545        -3      831
-## 6  2013    11     1      549            600       -11      912
-## # ... with 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>
+##    year month   day dep_time sched_dep_time dep_delay arr_time sched_arr_time
+##   <int> <int> <int>    <int>          <int>     <dbl>    <int>          <int>
+## 1  2013    11     1        5           2359         6      352            345
+## 2  2013    11     1       35           2250       105      123           2356
+## 3  2013    11     1      455            500        -5      641            651
+## 4  2013    11     1      539            545        -6      856            827
+## 5  2013    11     1      542            545        -3      831            855
+## 6  2013    11     1      549            600       -11      912            923
+## # i 11 more variables: 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{Filtering with NA (Not
@@ -2794,8 +3153,8 @@ from data frame.
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{df = R.tibble(}\StringTok{x: }\NormalTok{R.c(}\DecValTok{1}\NormalTok{, R::}\DataTypeTok{NA}\NormalTok{, }\DecValTok{3}\NormalTok{))}
-\NormalTok{puts df}
+\NormalTok{df }\OperatorTok{=} \ConstantTok{R}\AttributeTok{.tibble}\NormalTok{(}\WarningTok{x:} \ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\DecValTok{1}\NormalTok{, }\ConstantTok{R}\OperatorTok{::}\ConstantTok{NA}\NormalTok{, }\DecValTok{3}\NormalTok{))}
+\FunctionTok{puts}\NormalTok{ df}
 \end{Highlighting}
 \end{Shaded}
 
@@ -2804,7 +3163,7 @@ from data frame.
 ##       x
 ##   <int>
 ## 1     1
-## 2      
+## 2    NA
 ## 3     3
 \end{verbatim}
 
@@ -2813,7 +3172,7 @@ condition, where the row with R:NA does not.
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts df.filter(}\StringTok{:x}\NormalTok{ > }\DecValTok{1}\NormalTok{)}
+\FunctionTok{puts}\NormalTok{ df}\AttributeTok{.filter}\NormalTok{(}\WarningTok{:x} \OperatorTok{\textgreater{}} \DecValTok{1}\NormalTok{)}
 \end{Highlighting}
 \end{Shaded}
 
@@ -2828,7 +3187,7 @@ To match an NA use method 'is\_\_na'
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts df.filter((}\StringTok{:x}\NormalTok{.is__na) | (}\StringTok{:x}\NormalTok{ > }\DecValTok{1}\NormalTok{))}
+\FunctionTok{puts}\NormalTok{ df}\AttributeTok{.filter}\NormalTok{((}\WarningTok{:x}\AttributeTok{.is\_\_na}\NormalTok{) }\OperatorTok{|}\NormalTok{ (}\WarningTok{:x} \OperatorTok{\textgreater{}} \DecValTok{1}\NormalTok{))}
 \end{Highlighting}
 \end{Shaded}
 
@@ -2836,7 +3195,7 @@ To match an NA use method 'is\_\_na'
 ## # A tibble: 2 x 1
 ##       x
 ##   <int>
-## 1      
+## 1    NA
 ## 2     3
 \end{verbatim}
 
@@ -2846,48 +3205,46 @@ Arrange reorders the rows of a data frame by the given arguments.
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts flights.arrange(}\StringTok{:year}\NormalTok{, }\StringTok{:month}\NormalTok{, }\StringTok{:day}\NormalTok{).head}
+\FunctionTok{puts}\NormalTok{ flights}\AttributeTok{.arrange}\NormalTok{(}\WarningTok{:year}\NormalTok{, }\WarningTok{:month}\NormalTok{, }\WarningTok{:day}\NormalTok{)}\AttributeTok{.head}
 \end{Highlighting}
 \end{Shaded}
 
 \begin{verbatim}
 ## # A tibble: 6 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
-## # ... with 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>
+##    year month   day dep_time sched_dep_time dep_delay arr_time sched_arr_time
+##   <int> <int> <int>    <int>          <int>     <dbl>    <int>          <int>
+## 1  2013     1     1      517            515         2      830            819
+## 2  2013     1     1      533            529         4      850            830
+## 3  2013     1     1      542            540         2      923            850
+## 4  2013     1     1      544            545        -1     1004           1022
+## 5  2013     1     1      554            600        -6      812            837
+## 6  2013     1     1      554            558        -4      740            728
+## # i 11 more variables: 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}
 
 To arrange in descending order, use function `desc'
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts flights.arrange(}\StringTok{:dep_delay}\NormalTok{.desc).head}
+\FunctionTok{puts}\NormalTok{ flights}\AttributeTok{.arrange}\NormalTok{(}\WarningTok{:dep\_delay}\AttributeTok{.desc}\NormalTok{)}\AttributeTok{.head}
 \end{Highlighting}
 \end{Shaded}
 
 \begin{verbatim}
 ## # A tibble: 6 x 19
-##    year month   day dep_time sched_dep_time dep_delay arr_time
-##   <int> <int> <int>    <int>          <int>     <dbl>    <int>
-## 1  2013     1     9      641            900      1301     1242
-## 2  2013     6    15     1432           1935      1137     1607
-## 3  2013     1    10     1121           1635      1126     1239
-## 4  2013     9    20     1139           1845      1014     1457
-## 5  2013     7    22      845           1600      1005     1044
-## 6  2013     4    10     1100           1900       960     1342
-## # ... with 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>
+##    year month   day dep_time sched_dep_time dep_delay arr_time sched_arr_time
+##   <int> <int> <int>    <int>          <int>     <dbl>    <int>          <int>
+## 1  2013     1     9      641            900      1301     1242           1530
+## 2  2013     6    15     1432           1935      1137     1607           2120
+## 3  2013     1    10     1121           1635      1126     1239           1810
+## 4  2013     9    20     1139           1845      1014     1457           2210
+## 5  2013     7    22      845           1600      1005     1044           1815
+## 6  2013     4    10     1100           1900       960     1342           2211
+## # i 11 more variables: 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{Selecting columns}\label{selecting-columns}
@@ -2896,7 +3253,7 @@ To select specific columns from a dataset we use function `select':
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts flights.select(}\StringTok{:year}\NormalTok{, }\StringTok{:month}\NormalTok{, }\StringTok{:day}\NormalTok{).head}
+\FunctionTok{puts}\NormalTok{ flights}\AttributeTok{.select}\NormalTok{(}\WarningTok{:year}\NormalTok{, }\WarningTok{:month}\NormalTok{, }\WarningTok{:day}\NormalTok{)}\AttributeTok{.head}
 \end{Highlighting}
 \end{Shaded}
 
@@ -2916,7 +3273,7 @@ It is also possible to select column in a given range
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts flights.select(}\StringTok{:year}\NormalTok{.up_to }\StringTok{:day}\NormalTok{).head}
+\FunctionTok{puts}\NormalTok{ flights}\AttributeTok{.select}\NormalTok{(}\WarningTok{:year}\AttributeTok{.up\_to} \OperatorTok{:}\NormalTok{day)}\AttributeTok{.head}
 \end{Highlighting}
 \end{Shaded}
 
@@ -2936,7 +3293,7 @@ Select all columns that start with a given name sequence
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts flights.select(E.starts_with(}\StringTok{'arr'}\NormalTok{)).head}
+\FunctionTok{puts}\NormalTok{ flights}\AttributeTok{.select}\NormalTok{(}\ConstantTok{E}\AttributeTok{.starts\_with}\NormalTok{(}\VerbatimStringTok{\textquotesingle{}arr\textquotesingle{}}\NormalTok{))}\AttributeTok{.head}
 \end{Highlighting}
 \end{Shaded}
 
@@ -2960,7 +3317,7 @@ Other functions that can be used:
 \item
   contains(``ijk''): matches names that contain ``ijk''.
 \item
-  matches(``(.)\textbackslash{}1''): selects variables that match a
+  matches(``(.)\textbackslash1''): selects variables that match a
   regular expression. This one matches any variables that contain
   repeated characters.
 \item
@@ -2972,38 +3329,37 @@ column order is `Everything':
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts flights.select(}\StringTok{:year}\NormalTok{, }\StringTok{:month}\NormalTok{, }\StringTok{:day}\NormalTok{, E.everything).head}
+\FunctionTok{puts}\NormalTok{ flights}\AttributeTok{.select}\NormalTok{(}\WarningTok{:year}\NormalTok{, }\WarningTok{:month}\NormalTok{, }\WarningTok{:day}\NormalTok{, }\ConstantTok{E}\AttributeTok{.everything}\NormalTok{)}\AttributeTok{.head}
 \end{Highlighting}
 \end{Shaded}
 
 \begin{verbatim}
 ## # A tibble: 6 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
-## # ... with 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{Add variables to a dataframe with
-`mutate'}{Add variables to a dataframe with mutate}}\label{add-variables-to-a-dataframe-with-mutate}
+##    year month   day dep_time sched_dep_time dep_delay arr_time sched_arr_time
+##   <int> <int> <int>    <int>          <int>     <dbl>    <int>          <int>
+## 1  2013     1     1      517            515         2      830            819
+## 2  2013     1     1      533            529         4      850            830
+## 3  2013     1     1      542            540         2      923            850
+## 4  2013     1     1      544            545        -1     1004           1022
+## 5  2013     1     1      554            600        -6      812            837
+## 6  2013     1     1      554            558        -4      740            728
+## # i 11 more variables: 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{Add variables to a dataframe with
+`mutate'}\label{add-variables-to-a-dataframe-with-mutate}
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{flights_sm = flights.}
-\NormalTok{               select((}\StringTok{:year}\NormalTok{.up_to }\StringTok{:day}\NormalTok{),}
-\NormalTok{                      E.ends_with(}\StringTok{'delay'}\NormalTok{),}
-                      \StringTok{:distance}\NormalTok{,}
-                      \StringTok{:air_time}\NormalTok{)}
+\NormalTok{flights\_sm }\OperatorTok{=}\NormalTok{ flights}\AttributeTok{.}
+               \AttributeTok{select}\NormalTok{((}\WarningTok{:year}\AttributeTok{.up\_to} \OperatorTok{:}\NormalTok{day),}
+                      \ConstantTok{E}\AttributeTok{.ends\_with}\NormalTok{(}\VerbatimStringTok{\textquotesingle{}delay\textquotesingle{}}\NormalTok{),}
+                      \WarningTok{:distance}\NormalTok{,}
+                      \WarningTok{:air\_time}\NormalTok{)}
 
-\NormalTok{puts flights_sm.head}
+\FunctionTok{puts}\NormalTok{ flights\_sm}\AttributeTok{.head}
 \end{Highlighting}
 \end{Shaded}
 
@@ -3021,10 +3377,10 @@ column order is `Everything':
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{flights_sm = flights_sm.}
-\NormalTok{               mutate(}\StringTok{gain: :dep_delay}\NormalTok{ - }\StringTok{:arr_delay}\NormalTok{,}
-                      \StringTok{speed: :distance}\NormalTok{ / }\StringTok{:air_time}\NormalTok{ * }\DecValTok{60}\NormalTok{)}
-\NormalTok{puts flights_sm.head}
+\NormalTok{flights\_sm }\OperatorTok{=}\NormalTok{ flights\_sm}\AttributeTok{.}
+               \AttributeTok{mutate}\NormalTok{(}\WarningTok{gain:} \WarningTok{:dep\_delay} \OperatorTok{{-}} \WarningTok{:arr\_delay}\NormalTok{,}
+                      \WarningTok{speed:} \WarningTok{:distance} \OperatorTok{/} \WarningTok{:air\_time} \OperatorTok{*} \DecValTok{60}\NormalTok{)}
+\FunctionTok{puts}\NormalTok{ flights\_sm}\AttributeTok{.head}
 \end{Highlighting}
 \end{Shaded}
 
@@ -3047,7 +3403,7 @@ Function `summarise' calculates summaries for the data frame. When no
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts flights.summarise(}\StringTok{delay: }\NormalTok{E.mean(}\StringTok{:dep_delay}\NormalTok{, }\StringTok{na__rm: }\DecValTok{true}\NormalTok{))}
+\FunctionTok{puts}\NormalTok{ flights}\AttributeTok{.summarise}\NormalTok{(}\WarningTok{delay:} \ConstantTok{E}\AttributeTok{.mean}\NormalTok{(}\WarningTok{:dep\_delay}\NormalTok{, }\WarningTok{na\_\_rm:} \DecValTok{true}\NormalTok{))}
 \end{Highlighting}
 \end{Shaded}
 
@@ -3063,8 +3419,8 @@ given group:
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{by_day = flights.group_by(}\StringTok{:year}\NormalTok{, }\StringTok{:month}\NormalTok{, }\StringTok{:day}\NormalTok{)}
-\NormalTok{puts by_day.summarise(}\StringTok{delay: :dep_delay}\NormalTok{.mean(}\StringTok{na__rm: }\DecValTok{true}\NormalTok{)).head}
+\NormalTok{by\_day }\OperatorTok{=}\NormalTok{ flights}\AttributeTok{.group\_by}\NormalTok{(}\WarningTok{:year}\NormalTok{, }\WarningTok{:month}\NormalTok{, }\WarningTok{:day}\NormalTok{)}
+\FunctionTok{puts}\NormalTok{ by\_day}\AttributeTok{.summarise}\NormalTok{(}\WarningTok{delay:} \WarningTok{:dep\_delay}\AttributeTok{.mean}\NormalTok{(}\WarningTok{na\_\_rm:} \DecValTok{true}\NormalTok{))}\AttributeTok{.head}
 \end{Highlighting}
 \end{Shaded}
 
@@ -3072,7 +3428,7 @@ given group:
 ## # A tibble: 6 x 4
 ## # Groups:   year, month [1]
 ##    year month   day delay
-## * <int> <int> <int> <dbl>
+##   <int> <int> <int> <dbl>
 ## 1  2013     1     1 11.5 
 ## 2  2013     1     2 13.9 
 ## 3  2013     1     3 11.0 
@@ -3086,15 +3442,15 @@ other:
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{delays = flights.}
-\NormalTok{           group_by(}\StringTok{:dest}\NormalTok{).}
-\NormalTok{           summarise(}
-             \StringTok{count: }\NormalTok{E.n,}
-             \StringTok{dist: :distance}\NormalTok{.mean(}\StringTok{na__rm: }\DecValTok{true}\NormalTok{),}
-             \StringTok{delay: :arr_delay}\NormalTok{.mean(}\StringTok{na__rm: }\DecValTok{true}\NormalTok{)).}
-\NormalTok{           filter(}\StringTok{:count}\NormalTok{ > }\DecValTok{20}\NormalTok{, }\StringTok{:dest}\NormalTok{ != }\StringTok{"NHL"}\NormalTok{)}
-
-\NormalTok{puts delays.head}
+\NormalTok{delays }\OperatorTok{=}\NormalTok{ flights}\AttributeTok{.}
+           \AttributeTok{group\_by}\NormalTok{(}\WarningTok{:dest}\NormalTok{)}\AttributeTok{.}
+           \AttributeTok{summarise}\NormalTok{(}
+             \WarningTok{count:} \ConstantTok{E}\AttributeTok{.n}\NormalTok{,}
+             \WarningTok{dist:} \WarningTok{:distance}\AttributeTok{.mean}\NormalTok{(}\WarningTok{na\_\_rm:} \DecValTok{true}\NormalTok{),}
+             \WarningTok{delay:} \WarningTok{:arr\_delay}\AttributeTok{.mean}\NormalTok{(}\WarningTok{na\_\_rm:} \DecValTok{true}\NormalTok{))}\AttributeTok{.}
+           \AttributeTok{filter}\NormalTok{(}\WarningTok{:count} \OperatorTok{\textgreater{}} \DecValTok{20}\NormalTok{, }\WarningTok{:dest} \OperatorTok{!=} \StringTok{"NHL"}\NormalTok{)}
+
+\FunctionTok{puts}\NormalTok{ delays}\AttributeTok{.head}
 \end{Highlighting}
 \end{Shaded}
 
@@ -3112,133 +3468,155 @@ other:
 
 \section{Using Data Table}\label{using-data-table}
 
+The next chunk reads the \textbf{flights14} sample (same file as the
+data.table vignette). Prefer \textbf{downloading in Ruby} and
+\textbf{\texttt{R.fread} on a local path}:
+\texttt{data.table::fread("https://…")} runs the HTTP transfer
+\textbf{inside R} while the Galaaz bridge waits on a \textbf{single}
+eval; if the remote server stalls, that looks like an intermittent
+``hang'' and eventually hits the \textbf{per-eval} bridge timeout.
+Ruby's \textbf{\texttt{Net::HTTP}} \texttt{open\_timeout} /
+\texttt{read\_timeout} fail fast with a clear error instead. The chunk
+passes \textbf{\texttt{nrows:}} to \textbf{\texttt{fread}} so a single
+bridge eval does not have to materialize the full
+\textasciitilde1.2M-row table during a gknit run.
+
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{R.library(}\StringTok{'data.table'}\NormalTok{)}
-\NormalTok{R.install_and_loads(}\StringTok{'curl'}\NormalTok{)}
-
-\NormalTok{input = }\StringTok{"https://raw.githubusercontent.com/Rdatatable/data.table/master/vignettes/flights14.csv"}
-\NormalTok{flights = R.fread(input)}
-\NormalTok{puts flights}
-\NormalTok{puts flights.dim}
+\FunctionTok{require} \VerbatimStringTok{\textquotesingle{}net/http\textquotesingle{}}
+\FunctionTok{require} \VerbatimStringTok{\textquotesingle{}uri\textquotesingle{}}
+\FunctionTok{require} \VerbatimStringTok{\textquotesingle{}tmpdir\textquotesingle{}}
+
+\ConstantTok{R}\AttributeTok{.library}\NormalTok{(}\VerbatimStringTok{\textquotesingle{}data.table\textquotesingle{}}\NormalTok{)}
+
+\NormalTok{url }\OperatorTok{=} \ConstantTok{URI}\NormalTok{(}\VerbatimStringTok{\textquotesingle{}https://raw.githubusercontent.com/Rdatatable/data.table/master/vignettes/flights14.csv\textquotesingle{}}\NormalTok{)}
+\NormalTok{csv }\OperatorTok{=} \DataTypeTok{File}\AttributeTok{.join}\NormalTok{(}\DataTypeTok{Dir}\AttributeTok{.tmpdir}\NormalTok{, }\StringTok{"galaaz\_manual\_flights14\_}\SpecialCharTok{\#\{}\DataTypeTok{Process}\AttributeTok{.pid}\SpecialCharTok{\}}\StringTok{.csv"}\NormalTok{)}
+\ControlFlowTok{begin}
+  \DataTypeTok{Net}\OperatorTok{::}\ConstantTok{HTTP}\AttributeTok{.start}\NormalTok{(url}\AttributeTok{.host}\NormalTok{, url}\AttributeTok{.port}\NormalTok{, }\WarningTok{use\_ssl:} \DecValTok{true}\NormalTok{, }\WarningTok{open\_timeout:} \DecValTok{25}\NormalTok{, }\WarningTok{read\_timeout:} \DecValTok{120}\NormalTok{) }\ControlFlowTok{do} \OperatorTok{|}\NormalTok{http}\OperatorTok{|}
+\NormalTok{    resp }\OperatorTok{=}\NormalTok{ http}\AttributeTok{.request\_get}\NormalTok{(url}\AttributeTok{.request\_uri}\NormalTok{)}
+    \FunctionTok{raise} \StringTok{"HTTP }\SpecialCharTok{\#\{}\NormalTok{resp}\AttributeTok{.code}\SpecialCharTok{\}}\StringTok{"} \ControlFlowTok{unless}\NormalTok{ resp}\AttributeTok{.is\_a?}\NormalTok{(}\DataTypeTok{Net}\OperatorTok{::}\DataTypeTok{HTTPSuccess}\NormalTok{)}
+
+    \DataTypeTok{File}\AttributeTok{.binwrite}\NormalTok{(csv, resp}\AttributeTok{.body}\NormalTok{)}
+  \ControlFlowTok{end}
+
+  \CommentTok{\# Cap rows so one bridge eval stays short on slow disks (full file is \textasciitilde{}1.2M rows).}
+\NormalTok{  flights }\OperatorTok{=} \ConstantTok{R}\AttributeTok{.fread}\NormalTok{(csv, }\WarningTok{nrows:} \DecValTok{120\_000}\NormalTok{)}
+  \FunctionTok{puts}\NormalTok{ flights}\AttributeTok{.dim}
+  \FunctionTok{puts} \ConstantTok{R}\AttributeTok{.head}\NormalTok{(flights, }\DecValTok{12}\NormalTok{)}
+\ControlFlowTok{ensure}
+  \DataTypeTok{File}\AttributeTok{.unlink}\NormalTok{(csv) }\ControlFlowTok{if}\NormalTok{ csv }\OperatorTok{\&\&} \DataTypeTok{File}\AttributeTok{.exist?}\NormalTok{(csv)}
+\ControlFlowTok{end}
 \end{Highlighting}
 \end{Shaded}
 
 \begin{verbatim}
-##         year month day dep_delay arr_delay carrier origin dest air_time
-##      1: 2014     1   1        14        13      AA    JFK  LAX      359
-##      2: 2014     1   1        -3        13      AA    JFK  LAX      363
-##      3: 2014     1   1         2         9      AA    JFK  LAX      351
-##      4: 2014     1   1        -8       -26      AA    LGA  PBI      157
-##      5: 2014     1   1         2         1      AA    JFK  LAX      350
-##     ---                                                                
-## 253312: 2014    10  31         1       -30      UA    LGA  IAH      201
-## 253313: 2014    10  31        -5       -14      UA    EWR  IAH      189
-## 253314: 2014    10  31        -8        16      MQ    LGA  RDU       83
-## 253315: 2014    10  31        -4        15      MQ    LGA  DTW       75
-## 253316: 2014    10  31        -5         1      MQ    LGA  SDF      110
-##         distance hour
-##      1:     2475    9
-##      2:     2475   11
-##      3:     2475   19
-##      4:     1035    7
-##      5:     2475   13
-##     ---              
-## 253312:     1416   14
-## 253313:     1400    8
-## 253314:      431   11
-## 253315:      502   11
-## 253316:      659    8
-## [1] 253316     11
+## [1] 120000     11
+##      year month   day dep_delay arr_delay carrier origin   dest air_time
+##     <int> <int> <int>     <int>     <int>  <char> <char> <char>    <int>
+##  1:  2014     1     1        14        13      AA    JFK    LAX      359
+##  2:  2014     1     1        -3        13      AA    JFK    LAX      363
+##  3:  2014     1     1         2         9      AA    JFK    LAX      351
+##  4:  2014     1     1        -8       -26      AA    LGA    PBI      157
+##  5:  2014     1     1         2         1      AA    JFK    LAX      350
+##  6:  2014     1     1         4         0      AA    EWR    LAX      339
+##  7:  2014     1     1        -2       -18      AA    JFK    LAX      338
+##  8:  2014     1     1        -3       -14      AA    JFK    LAX      356
+##  9:  2014     1     1        -1       -17      AA    JFK    MIA      161
+## 10:  2014     1     1        -2       -14      AA    JFK    SEA      349
+## 11:  2014     1     1        -5       -17      AA    EWR    MIA      161
+## 12:  2014     1     1         7        -5      AA    JFK    SFO      365
+##     distance  hour
+##        <int> <int>
+##  1:     2475     9
+##  2:     2475    11
+##  3:     2475    19
+##  4:     1035     7
+##  5:     2475    13
+##  6:     2454    18
+##  7:     2475    21
+##  8:     2475    15
+##  9:     1089    15
+## 10:     2422    18
+## 11:     1085    16
+## 12:     2586    17
 \end{verbatim}
 
 \begin{Shaded}
 \begin{Highlighting}[]
-
-\NormalTok{data_table = R.data__table(}
-  \DataTypeTok{ID}\NormalTok{: R.c(}\StringTok{"b"}\NormalTok{,}\StringTok{"b"}\NormalTok{,}\StringTok{"b"}\NormalTok{,}\StringTok{"a"}\NormalTok{,}\StringTok{"a"}\NormalTok{,}\StringTok{"c"}\NormalTok{),}
-  \StringTok{a: }\NormalTok{(}\DecValTok{1}\NormalTok{..}\DecValTok{6}\NormalTok{),}
-  \StringTok{b: }\NormalTok{(}\DecValTok{7}\NormalTok{..}\DecValTok{12}\NormalTok{),}
-  \StringTok{c: }\NormalTok{(}\DecValTok{13}\NormalTok{..}\DecValTok{18}\NormalTok{)}
+\NormalTok{data\_table }\OperatorTok{=} \ConstantTok{R}\AttributeTok{.data\_\_table}\NormalTok{(}
+  \WarningTok{ID:} \ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\StringTok{"b"}\NormalTok{,}\StringTok{"b"}\NormalTok{,}\StringTok{"b"}\NormalTok{,}\StringTok{"a"}\NormalTok{,}\StringTok{"a"}\NormalTok{,}\StringTok{"c"}\NormalTok{),}
+  \WarningTok{a:}\NormalTok{ (}\DecValTok{1}\OperatorTok{..}\DecValTok{6}\NormalTok{),}
+  \WarningTok{b:}\NormalTok{ (}\DecValTok{7}\OperatorTok{..}\DecValTok{12}\NormalTok{),}
+  \WarningTok{c:}\NormalTok{ (}\DecValTok{13}\OperatorTok{..}\DecValTok{18}\NormalTok{)}
 \NormalTok{)}
 
-\NormalTok{puts data_table}
-\NormalTok{puts data_table.}\DataTypeTok{ID}
+\FunctionTok{puts}\NormalTok{ data\_table}
+\FunctionTok{puts}\NormalTok{ data\_table}\AttributeTok{.}\ConstantTok{ID}
 \end{Highlighting}
 \end{Shaded}
 
 \begin{verbatim}
-##    ID a  b  c
-## 1:  b 1  7 13
-## 2:  b 2  8 14
-## 3:  b 3  9 15
-## 4:  a 4 10 16
-## 5:  a 5 11 17
-## 6:  c 6 12 18
+##        ID     a     b     c
+##    <char> <int> <int> <int>
+## 1:      b     1     7    13
+## 2:      b     2     8    14
+## 3:      b     3     9    15
+## 4:      a     4    10    16
+## 5:      a     5    11    17
+## 6:      c     6    12    18
 ## [1] "b" "b" "b" "a" "a" "c"
 \end{verbatim}
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\CommentTok{# subset rows in i}
-\NormalTok{ans = flights[(}\StringTok{:origin}\NormalTok{.eq }\StringTok{"JFK"}\NormalTok{) & (}\StringTok{:month}\NormalTok{.eq }\DecValTok{6}\NormalTok{)]}
-\NormalTok{puts ans.head}
-
-\CommentTok{# Get the first two rows from flights.}
+\CommentTok{\# subset rows in i}
+\NormalTok{ans }\OperatorTok{=}\NormalTok{ flights}\KeywordTok{[}\NormalTok{(}\WarningTok{:origin}\AttributeTok{.eq} \StringTok{"JFK"}\NormalTok{) }\OperatorTok{\&}\NormalTok{ (}\WarningTok{:month}\AttributeTok{.eq} \DecValTok{6}\NormalTok{)}\KeywordTok{]}
+\FunctionTok{puts}\NormalTok{ ans}\AttributeTok{.head}
 
-\NormalTok{ans = flights[(}\DecValTok{1}\NormalTok{..}\DecValTok{2}\NormalTok{)]}
-\NormalTok{puts ans}
+\CommentTok{\# Get the first two rows from flights.}
 
-\CommentTok{# Sort flights first by column origin in ascending order, and then by dest in descending order:}
+\NormalTok{ans }\OperatorTok{=}\NormalTok{ flights}\KeywordTok{[}\NormalTok{(}\DecValTok{1}\OperatorTok{..}\DecValTok{2}\NormalTok{)}\KeywordTok{]}
+\FunctionTok{puts}\NormalTok{ ans}
 
-\CommentTok{# ans = flights[E.order(:origin, -(:dest))]}
-\CommentTok{# puts ans.head}
+\CommentTok{\# Sort by origin asc, then dest desc (example kept commented):}
+\CommentTok{\# ans = flights[E.order(:origin, {-}(:dest))]}
+\CommentTok{\# puts ans.head}
 \end{Highlighting}
 \end{Shaded}
 
 \begin{verbatim}
-##    year month day dep_delay arr_delay carrier origin dest air_time
-## 1: 2014     6   1        -9        -5      AA    JFK  LAX      324
-## 2: 2014     6   1       -10       -13      AA    JFK  LAX      329
-## 3: 2014     6   1        18        -1      AA    JFK  LAX      326
-## 4: 2014     6   1        -6       -16      AA    JFK  LAX      320
-## 5: 2014     6   1        -4       -45      AA    JFK  LAX      326
-## 6: 2014     6   1        -6       -23      AA    JFK  LAX      329
-##    distance hour
-## 1:     2475    8
-## 2:     2475   12
-## 3:     2475    7
-## 4:     2475   10
-## 5:     2475   18
-## 6:     2475   14
-##    year month day dep_delay arr_delay carrier origin dest air_time
-## 1: 2014     1   1        14        13      AA    JFK  LAX      359
-## 2: 2014     1   1        -3        13      AA    JFK  LAX      363
-##    distance hour
-## 1:     2475    9
-## 2:     2475   11
+## Empty data.table (0 rows and 11 cols): year,month,day,dep_delay,arr_delay,carrier...
+##     year month   day dep_delay arr_delay carrier origin   dest air_time
+##    <int> <int> <int>     <int>     <int>  <char> <char> <char>    <int>
+## 1:  2014     1     1        14        13      AA    JFK    LAX      359
+## 2:  2014     1     1        -3        13      AA    JFK    LAX      363
+##    distance  hour
+##       <int> <int>
+## 1:     2475     9
+## 2:     2475    11
 \end{verbatim}
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\CommentTok{# Select column(s) in j}
-\CommentTok{# select arr_delay column, but return it as a vector.}
+\CommentTok{\# Select column(s) in j}
+\CommentTok{\# select arr\_delay column, but return it as a vector.}
 
-\NormalTok{ans = flights[}\StringTok{:all}\NormalTok{, }\StringTok{:arr_delay}\NormalTok{]}
-\NormalTok{puts ans.head}
+\NormalTok{ans }\OperatorTok{=}\NormalTok{ flights}\KeywordTok{[}\WarningTok{:all}\NormalTok{, }\WarningTok{:arr\_delay}\KeywordTok{]}
+\FunctionTok{puts}\NormalTok{ ans}\AttributeTok{.head}
 
-\CommentTok{# Select arr_delay column, but return as a data.table instead.}
+\CommentTok{\# arr\_delay as data.table (not plain vector).}
 
-\NormalTok{ans = flights[}\StringTok{:all}\NormalTok{, }\StringTok{:arr_delay}\NormalTok{.list]}
-\NormalTok{puts ans.head}
+\NormalTok{ans }\OperatorTok{=}\NormalTok{ flights}\KeywordTok{[}\WarningTok{:all}\NormalTok{, }\WarningTok{:arr\_delay}\AttributeTok{.list}\KeywordTok{]}
+\FunctionTok{puts}\NormalTok{ ans}\AttributeTok{.head}
 
-\NormalTok{ans = flights[}\StringTok{:all}\NormalTok{, E.list(}\StringTok{:arr_delay}\NormalTok{, }\StringTok{:dep_delay}\NormalTok{)]}
+\NormalTok{ans }\OperatorTok{=}\NormalTok{ flights}\KeywordTok{[}\WarningTok{:all}\NormalTok{, }\ConstantTok{E}\AttributeTok{.list}\NormalTok{(}\WarningTok{:arr\_delay}\NormalTok{, }\WarningTok{:dep\_delay}\NormalTok{)}\KeywordTok{]}
 \end{Highlighting}
 \end{Shaded}
 
 \begin{verbatim}
 ## [1]  13  13   9 -26   1   0
 ##    arr_delay
+##        <int>
 ## 1:        13
 ## 2:        13
 ## 3:         9
@@ -3247,44 +3625,361 @@ other:
 ## 6:         0
 \end{verbatim}
 
+\section{Apache Arrow}\label{apache-arrow}
+
+\href{https://arrow.apache.org/}{Apache Arrow} is a \textbf{columnar}
+in-memory format used heavily in R and Python for analytics. In Galaaz,
+\textbf{Ruby does not hold an Arrow C++ table itself}; instead you build
+ordinary Ruby structures (arrays of row hashes), and
+\textbf{\texttt{R::Arrow.from\_ruby\_batches}} creates a real
+\textbf{Arrow \texttt{Table} inside GNU R}. From there you use R's
+\textbf{\texttt{arrow}} and \textbf{\texttt{dplyr}} packages as usual:
+\textbf{\texttt{group\_by}} on the Arrow table,
+\textbf{\texttt{summarise}} for aggregates, then
+\textbf{\texttt{collect()}} to materialize a tibble when you need
+in-memory R rows.
+
+That pattern matches production use: \textbf{JRuby threads} (or
+sequential code) assemble many rows in Ruby; you pay \textbf{one}
+bridge-heavy handoff to R; \textbf{dplyr} runs vectorised work on the
+Arrow table in R.
+
+\textbf{Prerequisites:} install R packages \textbf{\texttt{arrow}} and
+\textbf{\texttt{dplyr}}. Run scripts with
+\textbf{\texttt{bin/galaaz-jruby}} (or the same JVM flags as in
+\textbf{\texttt{docs/testing.md}}) so the Arrow JNI stack is available.
+
+\subsection{\texorpdfstring{Other \texttt{R::Arrow}
+helpers}{Other R::Arrow helpers}}\label{other-rarrow-helpers}
+
+The Ruby module \textbf{\texttt{R::Arrow}} (see
+\texttt{lib/R\_interface/r\_arrow.rb}) also includes:
+
+\begin{itemize}
+\tightlist
+\item
+  \textbf{\texttt{R::Arrow.table\_from(df)}} --- wrap an R
+  \texttt{data.frame} / tibble as an Arrow table.
+\item
+  \textbf{\texttt{R::Arrow.read\_feather} / \texttt{write\_feather}},
+  \textbf{\texttt{read\_parquet}}, \textbf{\texttt{dataset(path)}} ---
+  file and dataset IO on paths visible to R.
+\end{itemize}
+
+\subsection{Example: many Ruby rows → Arrow in R → grouped
+statistics}\label{example-many-ruby-rows-arrow-in-r-grouped-statistics}
+
+The repository test
+\textbf{\texttt{slow-specs/arrow\_large\_pipeline\_spec.rb}} builds
+\textbf{200k rows} in parallel (eight threads × 25,000 rows), pushes
+them through \textbf{\texttt{R::Arrow.from\_ruby\_batches}}, then checks
+that \textbf{dplyr} group summaries match a Ruby reference calculation.
+The same logic appears below at a \textbf{smaller scale} so this manual
+can knit quickly; increase \texttt{thread\_count} and
+\texttt{rows\_per\_thread} when experimenting locally.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\CommentTok{\# Scaled{-}down version of slow{-}specs/arrow\_large\_pipeline\_spec.rb.}
+\ControlFlowTok{unless} \ConstantTok{R}\OperatorTok{::}\DataTypeTok{Support}\AttributeTok{.eval}\NormalTok{(}\StringTok{"requireNamespace(\textquotesingle{}arrow\textquotesingle{}, quietly=TRUE) \&\& requireNamespace(\textquotesingle{}dplyr\textquotesingle{}, quietly=TRUE)"}\NormalTok{) }\OperatorTok{==} \DecValTok{true}
+  \FunctionTok{puts} \VerbatimStringTok{\textquotesingle{}(Skip: need arrow + dplyr in R; use bin/galaaz{-}jruby outside gKnit.)\textquotesingle{}}
+\ControlFlowTok{else}
+\NormalTok{  thread\_count }\OperatorTok{=} \DecValTok{4}
+\NormalTok{  rows\_per\_thread }\OperatorTok{=} \DecValTok{500}
+\NormalTok{  group\_count }\OperatorTok{=} \DecValTok{5}
+
+\NormalTok{  batches }\OperatorTok{=} \KeywordTok{[]}
+\NormalTok{  mutex }\OperatorTok{=} \DataTypeTok{Mutex}\AttributeTok{.new}
+\NormalTok{  threads }\OperatorTok{=} \KeywordTok{[]}
+
+\NormalTok{  thread\_count}\AttributeTok{.times} \ControlFlowTok{do} \OperatorTok{|}\NormalTok{tid}\OperatorTok{|}
+\NormalTok{    threads }\OperatorTok{\textless{}\textless{}} \DataTypeTok{Thread}\AttributeTok{.new} \ControlFlowTok{do}
+\NormalTok{      start }\OperatorTok{=}\NormalTok{ tid }\OperatorTok{*}\NormalTok{ rows\_per\_thread}
+\NormalTok{      local }\OperatorTok{=}\NormalTok{ (start}\OperatorTok{...}\NormalTok{(start }\OperatorTok{+}\NormalTok{ rows\_per\_thread))}\AttributeTok{.map} \ControlFlowTok{do} \OperatorTok{|}\NormalTok{i}\OperatorTok{|}
+        \OperatorTok{\{}
+          \WarningTok{id:}\NormalTok{ i,}
+          \WarningTok{grp:} \StringTok{"g}\SpecialCharTok{\#\{}\NormalTok{i }\OperatorTok{\%}\NormalTok{ group\_count}\SpecialCharTok{\}}\StringTok{"}\NormalTok{,}
+          \WarningTok{value:}\NormalTok{ (i }\OperatorTok{\%} \DecValTok{17}\NormalTok{) }\OperatorTok{+} \DecValTok{1}\NormalTok{,}
+          \WarningTok{weight:}\NormalTok{ ((i }\OperatorTok{\%} \DecValTok{5}\NormalTok{) }\OperatorTok{+} \DecValTok{1}\NormalTok{) }\OperatorTok{*} \FloatTok{0.5}
+        \OperatorTok{\}}
+      \ControlFlowTok{end}
+\NormalTok{      mutex}\AttributeTok{.synchronize} \OperatorTok{\{}\NormalTok{ batches }\OperatorTok{\textless{}\textless{}}\NormalTok{ local }\OperatorTok{\}}
+    \ControlFlowTok{end}
+  \ControlFlowTok{end}
+\NormalTok{  threads}\AttributeTok{.each}\NormalTok{(}\OperatorTok{\&}\WarningTok{:join}\NormalTok{)}
+
+\NormalTok{  tbl }\OperatorTok{=} \ConstantTok{R}\OperatorTok{::}\DataTypeTok{Arrow}\AttributeTok{.from\_ruby\_batches}\NormalTok{(batches)}
+  \FunctionTok{puts} \StringTok{"R class after from\_ruby\_batches: }\SpecialCharTok{\#\{}\NormalTok{tbl}\AttributeTok{.rclass}\SpecialCharTok{\}}\StringTok{"}
+
+\NormalTok{  grouped }\OperatorTok{=} \ConstantTok{R}\AttributeTok{.dplyr\_\_\_group\_by}\NormalTok{(tbl, }\WarningTok{:grp}\NormalTok{)}
+\NormalTok{  summarised }\OperatorTok{=} \ConstantTok{R}\AttributeTok{.dplyr\_\_\_summarise}\NormalTok{(}
+\NormalTok{    grouped,}
+    \WarningTok{n:} \ConstantTok{E}\AttributeTok{.n}\NormalTok{(),}
+    \WarningTok{total:} \ConstantTok{E}\AttributeTok{.sum}\NormalTok{(}\WarningTok{:value}\NormalTok{),}
+    \WarningTok{wsum:} \ConstantTok{E}\AttributeTok{.sum}\NormalTok{(}\WarningTok{:value} \OperatorTok{*} \WarningTok{:weight}\NormalTok{)}
+\NormalTok{  )}
+\NormalTok{  out }\OperatorTok{=} \ConstantTok{R}\AttributeTok{.dplyr\_\_\_collect}\NormalTok{(summarised)}
+
+  \FunctionTok{puts} \VerbatimStringTok{\textquotesingle{}Per{-}group summary (first rows):\textquotesingle{}}
+  \FunctionTok{puts} \ConstantTok{R}\AttributeTok{.as\_\_data\_\_frame}\NormalTok{(out)}\AttributeTok{.head}\NormalTok{(}\DecValTok{10}\NormalTok{)}
+
+\NormalTok{  total\_n }\OperatorTok{=} \DecValTok{0}
+\NormalTok{  (}\DecValTok{1}\OperatorTok{..}\NormalTok{(out}\AttributeTok{.nrow} \OperatorTok{\textgreater{}\textgreater{}} \DecValTok{0}\NormalTok{))}\AttributeTok{.each} \OperatorTok{\{} \OperatorTok{|}\NormalTok{i}\OperatorTok{|}\NormalTok{ total\_n }\OperatorTok{+=}\NormalTok{ (out}\KeywordTok{[[}\CharTok{\textquotesingle{}n\textquotesingle{}}\KeywordTok{]][}\NormalTok{i}\KeywordTok{]} \OperatorTok{\textgreater{}\textgreater{}} \DecValTok{0}\NormalTok{) }\OperatorTok{\}}
+  \FunctionTok{puts} \StringTok{"Sum of group counts n (should equal }\SpecialCharTok{\#\{}\NormalTok{thread\_count }\OperatorTok{*}\NormalTok{ rows\_per\_thread}\SpecialCharTok{\}}\StringTok{): }\SpecialCharTok{\#\{}\NormalTok{total\_n}\SpecialCharTok{\}}\StringTok{"}
+\ControlFlowTok{end}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## R class after from_ruby_batches: Table
+## Per-group summary (first rows):
+##   grp   n total   wsum
+## 1  g0 400  3589 1794.5
+## 2  g1 400  3598 3598.0
+## 3  g2 400  3590 5385.0
+## 4  g3 400  3599 7198.0
+## 5  g4 400  3591 8977.5
+## Sum of group counts n (should equal 2000): 2000
+\end{verbatim}
+
+\textbf{What to notice:} (1) Ruby only sees \textbf{\texttt{Hash}} rows
+and Ruby \textbf{\texttt{Thread}} objects; (2) a single
+\textbf{\texttt{from\_ruby\_batches}} call creates the Arrow table in R;
+(3) \textbf{\texttt{dplyr\_\_\_group\_by}} /
+\textbf{\texttt{dplyr\_\_\_summarise}} /
+\textbf{\texttt{dplyr\_\_\_collect}} mirror
+\textbf{\texttt{dplyr::group\_by}} / \textbf{\texttt{dplyr::summarise}}
+/ \textbf{\texttt{dplyr::collect}} on an Arrow-backed table. For a
+lighter test, see
+\textbf{\texttt{specs/arrow\_from\_ruby\_batches\_spec.rb}}; for the
+full-size benchmark, run
+\textbf{\texttt{bin/run\_slow\_rspec\ slow-specs/arrow\_large\_pipeline\_spec.rb}}.
+
+\section{Bioconductor and DESeq2}\label{bioconductor-and-deseq2}
+
+\textbf{Bioconductor} packages are ordinary R packages installed from
+the Bioconductor repositories. Galaaz does not treat them specially:
+once installed in \textbf{GNU R}, you load them with
+\textbf{\texttt{R.library}} like any CRAN package.
+
+\subsection{Installing Bioconductor
+packages}\label{installing-bioconductor-packages}
+
+From an R session (or
+\texttt{R\ -e\ \textquotesingle{}...\textquotesingle{}}), use
+\textbf{BiocManager} (see
+\href{https://bioconductor.org/install/}{bioconductor.org}):
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\ControlFlowTok{if}\NormalTok{ (}\SpecialCharTok{!}\FunctionTok{requireNamespace}\NormalTok{(}\StringTok{"BiocManager"}\NormalTok{, }\AttributeTok{quietly =} \ConstantTok{TRUE}\NormalTok{))}
+  \FunctionTok{install.packages}\NormalTok{(}\StringTok{"BiocManager"}\NormalTok{)}
+\NormalTok{BiocManager}\SpecialCharTok{::}\FunctionTok{install}\NormalTok{(}\FunctionTok{c}\NormalTok{(}\StringTok{"DESeq2"}\NormalTok{, }\StringTok{"airway"}\NormalTok{))}
+\end{Highlighting}
+\end{Shaded}
+
+The \textbf{\texttt{airway}} package ships the example
+\textbf{\texttt{SummarizedExperiment}} used below. \textbf{DESeq2} pulls
+in several dependencies; the first install can take several minutes.
+
+\subsection{Example: DESeq2 on the airway
+dataset}\label{example-deseq2-on-the-airway-dataset}
+
+The script
+\textbf{\texttt{examples/bioconductor\_deseq2\_airway/deseq2\_airway\_galaaz.rb}}
+is the canonical version in the repository. Run it from the
+\textbf{Galaaz repository root} with JRuby, for example:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{bin/galaaz{-}jruby examples/bioconductor\_deseq2\_airway/deseq2\_airway\_galaaz.rb}
+\end{Highlighting}
+\end{Shaded}
+
+The workflow in Ruby mirrors a standard DESeq2 vignette:
+
+\begin{enumerate}
+\def\labelenumi{\arabic{enumi}.}
+\tightlist
+\item
+  \textbf{\texttt{R.library(\textquotesingle{}DESeq2\textquotesingle{})}}
+  and
+  \textbf{\texttt{R.library(\textquotesingle{}airway\textquotesingle{})}},
+  then
+  \textbf{\texttt{R.data(\textquotesingle{}airway\textquotesingle{})}}
+  so the object exists in R's global environment.
+\item
+  \textbf{\texttt{airway\ =\ \textasciitilde{}:airway}} pulls the
+  experiment into a Galaaz wrapper so you can pass it to R functions as
+  a Ruby value.
+\item
+  \textbf{\texttt{R.DESeqDataSet(...,\ design:\ (:all.til\ :cell\ +\ :dex))}}
+  builds the \textbf{\texttt{DESeqDataSet}}. The
+  \textbf{\texttt{(:all.til\ :cell\ +\ :dex)}} form is Galaaz's way of
+  passing the one-sided formula
+  \textbf{\texttt{\textasciitilde{}\ cell\ +\ dex}} (adjust for the
+  design you need).
+\item
+  Prefilter rows with almost no counts:
+  \textbf{\texttt{keep\ =\ R.rowSums(R.counts(dds))\ \textgreater{}=\ 10}}
+  and \textbf{\texttt{dds\ =\ dds{[}keep,\ :all{]}}}.
+\item
+  \textbf{\texttt{dds\ =\ R.DESeq(dds)}} fits the model;
+  \textbf{\texttt{res\ =\ R.results(dds,\ contrast:\ R.c(\textquotesingle{}dex\textquotesingle{},\ \textquotesingle{}trt\textquotesingle{},\ \textquotesingle{}untrt\textquotesingle{}))}}
+  extracts the treatment contrast (adjust \textbf{\texttt{contrast}} for
+  your experiment).
+\item
+  Summaries use normal Ruby string interpolation on
+  \textbf{\texttt{R.nrow}}, \textbf{\texttt{R.ncol}},
+  \textbf{\texttt{R.colnames}}, etc.
+\item
+  \textbf{\texttt{R.pdf(...);\ R.plotMA(res,\ ...);\ R.dev\_\_off}}
+  writes DESeq2's MA plot (path is relative to the process working
+  directory---use the repo root when running the bundled script).
+\end{enumerate}
+
+Related benchmarks and warm-run notes live under
+\textbf{\texttt{docs/deseq2\_airway\_benchmark.md}} and
+\textbf{\texttt{examples/bioconductor\_deseq2\_airway/bench\_*.rb}}.
+
+Below is the full listing (same as the file in the repository). It is
+\textbf{not} executed while this manual is knitted, because
+\textbf{DESeq2} is heavy and may be absent on the build machine.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\CommentTok{\# Canonical script: examples/bioconductor\_deseq2\_airway/deseq2\_airway\_galaaz.rb}
+\CommentTok{\# Run: bin/galaaz{-}jruby examples/.../deseq2\_airway\_galaaz.rb (repo root).}
+
+\FunctionTok{require} \VerbatimStringTok{\textquotesingle{}galaaz\textquotesingle{}}
+
+\ConstantTok{R}\AttributeTok{.library}\NormalTok{(}\VerbatimStringTok{\textquotesingle{}DESeq2\textquotesingle{}}\NormalTok{)}
+\ConstantTok{R}\AttributeTok{.library}\NormalTok{(}\VerbatimStringTok{\textquotesingle{}airway\textquotesingle{}}\NormalTok{)}
+\ConstantTok{R}\AttributeTok{.data}\NormalTok{(}\VerbatimStringTok{\textquotesingle{}airway\textquotesingle{}}\NormalTok{)}
+
+\NormalTok{airway }\OperatorTok{=} \OperatorTok{\textasciitilde{}}\WarningTok{:airway}
+
+\CommentTok{\# Build DESeq2 dataset with one{-}sided formula: \textasciitilde{} cell + dex.}
+\NormalTok{dds }\OperatorTok{=} \ConstantTok{R}\AttributeTok{.}\DataTypeTok{DESeqDataSet}\NormalTok{(airway, }\WarningTok{design:}\NormalTok{ (}\WarningTok{:all}\AttributeTok{.til} \OperatorTok{:}\NormalTok{cell }\OperatorTok{+} \WarningTok{:dex}\NormalTok{))}
+
+\CommentTok{\# Prefilter genes with almost no counts.}
+\NormalTok{keep }\OperatorTok{=} \ConstantTok{R}\AttributeTok{.rowSums}\NormalTok{(}\ConstantTok{R}\AttributeTok{.counts}\NormalTok{(dds)) }\OperatorTok{\textgreater{}=} \DecValTok{10}
+\NormalTok{dds }\OperatorTok{=}\NormalTok{ dds}\KeywordTok{[}\NormalTok{keep, }\WarningTok{:all}\KeywordTok{]}
+
+\CommentTok{\# Fit DE model and extract treatment effect.}
+\NormalTok{dds }\OperatorTok{=} \ConstantTok{R}\AttributeTok{.}\DataTypeTok{DESeq}\NormalTok{(dds)}
+\NormalTok{res }\OperatorTok{=} \ConstantTok{R}\AttributeTok{.results}\NormalTok{(dds, }\WarningTok{contrast:} \ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\VerbatimStringTok{\textquotesingle{}dex\textquotesingle{}}\NormalTok{, }\VerbatimStringTok{\textquotesingle{}trt\textquotesingle{}}\NormalTok{, }\VerbatimStringTok{\textquotesingle{}untrt\textquotesingle{}}\NormalTok{))}
+
+\CommentTok{\# Compact sanity outputs for quick verification.}
+\FunctionTok{puts} \StringTok{"Samples: }\SpecialCharTok{\#\{}\ConstantTok{R}\AttributeTok{.ncol}\NormalTok{(dds)}\SpecialCharTok{\}}\StringTok{"}
+\FunctionTok{puts} \StringTok{"Genes after prefilter: }\SpecialCharTok{\#\{}\ConstantTok{R}\AttributeTok{.nrow}\NormalTok{(dds)}\SpecialCharTok{\}}\StringTok{"}
+\FunctionTok{puts} \StringTok{"Result rows: }\SpecialCharTok{\#\{}\ConstantTok{R}\AttributeTok{.nrow}\NormalTok{(res)}\SpecialCharTok{\}}\StringTok{"}
+\FunctionTok{puts} \StringTok{"Result columns: }\SpecialCharTok{\#\{}\ConstantTok{R}\AttributeTok{.colnames}\NormalTok{(res)}\SpecialCharTok{\}}\StringTok{"}
+\FunctionTok{puts} \StringTok{"Significant genes (padj \textless{} 0.05): }\SpecialCharTok{\#\{}\ConstantTok{R}\AttributeTok{.sum}\NormalTok{(res}\AttributeTok{.padj} \OperatorTok{\textless{}} \FloatTok{0.05}\NormalTok{, }\WarningTok{na\_\_rm:} \DecValTok{true}\NormalTok{)}\SpecialCharTok{\}}\StringTok{"}
+
+\NormalTok{res\_ordered }\OperatorTok{=}\NormalTok{ res}\KeywordTok{[}\ConstantTok{R}\AttributeTok{.order}\NormalTok{(res}\AttributeTok{.padj}\NormalTok{), }\WarningTok{:all}\KeywordTok{]}
+\FunctionTok{puts} \ConstantTok{R}\AttributeTok{.head}\NormalTok{(}\ConstantTok{R}\AttributeTok{.as\_\_data\_\_frame}\NormalTok{(res\_ordered), }\DecValTok{10}\NormalTok{)}
+
+\CommentTok{\# Standard DESeq2 plot call written to file.}
+\ConstantTok{R}\AttributeTok{.pdf}\NormalTok{(}\VerbatimStringTok{\textquotesingle{}examples/bioconductor\_deseq2\_airway/plotMA\_galaaz.pdf\textquotesingle{}}\NormalTok{)}
+\ConstantTok{R}\AttributeTok{.plotMA}\NormalTok{(res, }\WarningTok{ylim:} \ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\OperatorTok{{-}}\DecValTok{5}\NormalTok{, }\DecValTok{5}\NormalTok{))}
+\ConstantTok{R}\AttributeTok{.dev\_\_off}
+\end{Highlighting}
+\end{Shaded}
+
+If \textbf{DESeq2} and \textbf{airway} are installed, the next chunk
+loads the data and prints a short preview (it does \textbf{not} run
+\textbf{\texttt{DESeq}} so the manual knits quickly).
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\ControlFlowTok{unless} \ConstantTok{R}\OperatorTok{::}\DataTypeTok{Support}\AttributeTok{.eval}\NormalTok{(}\StringTok{"requireNamespace(\textquotesingle{}DESeq2\textquotesingle{}, quietly=TRUE) \&\& requireNamespace(\textquotesingle{}airway\textquotesingle{}, quietly=TRUE)"}\NormalTok{)}
+  \FunctionTok{puts} \VerbatimStringTok{\textquotesingle{}(Skip: install DESeq2 and airway via BiocManager in R to run the full example.)\textquotesingle{}}
+\ControlFlowTok{else}
+  \ConstantTok{R}\AttributeTok{.library}\NormalTok{(}\VerbatimStringTok{\textquotesingle{}DESeq2\textquotesingle{}}\NormalTok{)}
+  \ConstantTok{R}\AttributeTok{.library}\NormalTok{(}\VerbatimStringTok{\textquotesingle{}airway\textquotesingle{}}\NormalTok{)}
+  \ConstantTok{R}\AttributeTok{.data}\NormalTok{(}\VerbatimStringTok{\textquotesingle{}airway\textquotesingle{}}\NormalTok{)}
+\NormalTok{  airway }\OperatorTok{=} \OperatorTok{\textasciitilde{}}\WarningTok{:airway}
+  \FunctionTok{puts} \VerbatimStringTok{\textquotesingle{}airway object (head of assay / dims via R):\textquotesingle{}}
+  \FunctionTok{puts} \StringTok{"ncol(samples): }\SpecialCharTok{\#\{}\ConstantTok{R}\AttributeTok{.ncol}\NormalTok{(airway)}\SpecialCharTok{\}}\StringTok{"}
+  \FunctionTok{puts} \ConstantTok{R}\AttributeTok{.head}\NormalTok{(}\ConstantTok{R}\AttributeTok{.assay}\NormalTok{(airway), }\DecValTok{3}\NormalTok{)}
+\ControlFlowTok{end}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{verbatim}
+## airway object (head of assay / dims via R):
+## ncol(samples): [1] 8
+##                 SRR1039508 SRR1039509 SRR1039512 SRR1039513 SRR1039516
+## ENSG00000000003        679        448        873        408       1138
+## ENSG00000000005          0          0          0          0          0
+## ENSG00000000419        467        515        621        365        587
+##                 SRR1039517 SRR1039520 SRR1039521
+## ENSG00000000003       1047        770        572
+## ENSG00000000005          0          0          0
+## ENSG00000000419        799        417        508
+\end{verbatim}
+
+\section{Performance}\label{performance}
+
+For realistic analyses, \textbf{most wall-clock time is spent inside GNU
+R} (model fitting, I/O inside R, graphics). The Galaaz \textbf{bridge}
+adds overhead mainly from \textbf{starting a session},
+\textbf{serializing requests}, and \textbf{wrapping results} in Ruby
+objects---not from reimplementing R's numerical work.
+
+Practical tips:
+
+\begin{itemize}
+\tightlist
+\item
+  Keep \textbf{hot loops} in R or vectorized code when possible; use
+  Ruby for orchestration, I/O, and glue.
+\item
+  \textbf{Reuse one process}: running many short scripts cold-starts
+  Ruby, the JVM, and R each time; a long-lived process or repeated calls
+  in one run amortize setup (see benchmarks below).
+\item
+  \textbf{Batch data}: merge shards in Ruby, then call
+  \textbf{\texttt{R::Arrow.from\_ruby\_batches}} (or build one data
+  frame) instead of millions of tiny R calls.
+\end{itemize}
+
+For measured discussion (including DESeq2-style workloads and warm
+comparisons), see \textbf{\texttt{docs/performance.md}} and
+\textbf{\texttt{docs/deseq2\_airway\_benchmark.md}} in the Galaaz
+repository.
+
 \section{Graphics in Galaaz}\label{graphics-in-galaaz}
 
 Creating graphics in Galaaz is quite easy, as it can use all the power
-of ggplot2. There are many resources in the web that teaches ggplot, so
+of ggplot2. There are many resources on the web that teach ggplot, so
 here we give a quick example of ggplot integration with Ruby. We
 continue to use the :mtcars dataset and we will plot a diverging bar
-plot, showing cars that have `above' or `below' gas consuption. Let's
+plot, showing cars that have `above' or `below' gas consumption. Let's
 first prepare the data frame with the necessary data:
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\CommentTok{# copy the R variable :mtcars to the Ruby mtcars variable}
-\NormalTok{mtcars = ~}\StringTok{:mtcars}
+\CommentTok{\# :mtcars {-}\textgreater{} Ruby handle}
+\NormalTok{mtcars }\OperatorTok{=} \OperatorTok{\textasciitilde{}}\WarningTok{:mtcars}
 
-\CommentTok{# create a new column 'car_name' to store the car names so that it can be}
-\CommentTok{# used for plotting. The 'rownames' of the data frame cannot be used as}
-\CommentTok{# data for plotting}
-\NormalTok{mtcars.car_name = R.rownames(}\StringTok{:mtcars}\NormalTok{)}
+\CommentTok{\# Row labels are not a plot column; copy them to car\_name.}
+\NormalTok{mtcars}\AttributeTok{.car\_name} \OperatorTok{=} \ConstantTok{R}\AttributeTok{.rownames}\NormalTok{(}\WarningTok{:mtcars}\NormalTok{)}
 
-\CommentTok{# compute normalized mpg and add it to a new column called mpg_z}
-\CommentTok{# Note that the mean value for mpg can be obtained by calling the 'mean'}
-\CommentTok{# function on the vector 'mtcars.mpg'.  The same with the standard}
-\CommentTok{# deviation 'sd'.  The vector is then rounded to two digits with 'round 2'}
-\NormalTok{mtcars.mpg_z = ((mtcars.mpg - mtcars.mpg.mean)/mtcars.mpg.sd).round }\DecValTok{2}
+\CommentTok{\# Z{-}score mpg (mean/sd on mtcars.mpg); round to 2 decimals.}
+\NormalTok{mtcars}\AttributeTok{.mpg\_z} \OperatorTok{=}\NormalTok{ ((mtcars}\AttributeTok{.mpg} \OperatorTok{{-}}\NormalTok{ mtcars}\AttributeTok{.mpg.mean}\NormalTok{)}\OperatorTok{/}\NormalTok{mtcars}\AttributeTok{.mpg.sd}\NormalTok{)}\AttributeTok{.round} \DecValTok{2}
 
-\CommentTok{# create a new column 'mpg_type'. Function 'ifelse' is a vectorized function}
-\CommentTok{# that looks at every element of the mpg_z vector and if the value is below}
-\CommentTok{# 0, returns 'below', otherwise returns 'above'}
-\NormalTok{mtcars.mpg_type = (mtcars.mpg_z < }\DecValTok{0}\NormalTok{).ifelse(}\StringTok{"below"}\NormalTok{, }\StringTok{"above"}\NormalTok{)}
+\CommentTok{\# ifelse is vectorized: below / above average mpg\_z.}
+\NormalTok{mtcars}\AttributeTok{.mpg\_type} \OperatorTok{=}\NormalTok{ (mtcars}\AttributeTok{.mpg\_z} \OperatorTok{\textless{}} \DecValTok{0}\NormalTok{)}\AttributeTok{.ifelse}\NormalTok{(}\StringTok{"below"}\NormalTok{, }\StringTok{"above"}\NormalTok{)}
 
-\CommentTok{# order the mtcar data set by the mpg_z vector from smaler to larger values}
-\NormalTok{mtcars = mtcars[mtcars.mpg_z.order, }\StringTok{:all}\NormalTok{]}
+\CommentTok{\# Sort rows by mpg\_z.}
+\NormalTok{mtcars }\OperatorTok{=}\NormalTok{ mtcars}\KeywordTok{[}\NormalTok{mtcars}\AttributeTok{.mpg\_z.order}\NormalTok{, }\WarningTok{:all}\KeywordTok{]}
 
-\CommentTok{# convert the car_name column to a factor to retain sorted order in plot}
-\NormalTok{mtcars.car_name = mtcars.car_name.factor }\StringTok{levels: }\NormalTok{mtcars.car_name}
+\CommentTok{\# Factor car\_name so plot order follows sort.}
+\NormalTok{mtcars}\AttributeTok{.car\_name} \OperatorTok{=}\NormalTok{ mtcars}\AttributeTok{.car\_name.factor} \WarningTok{levels:}\NormalTok{ mtcars}\AttributeTok{.car\_name}
 
-\CommentTok{# let's look at the final data frame}
-\NormalTok{puts mtcars.head}
+\FunctionTok{puts}\NormalTok{ mtcars}\AttributeTok{.head}
 \end{Highlighting}
 \end{Shaded}
 
@@ -3305,53 +4000,54 @@ first prepare the data frame with the necessary data:
 ## Maserati Bora             Maserati Bora -0.84    below
 \end{verbatim}
 
-Now, lets plot the diverging bar plot. When using gKnit, there is no
-need to call `R.awt' to create a plotting device, since gKnit does take
-care of it. Galaaz provides integration with ggplot. The interested
-reader should check online for more information on ggplot, since it is
-outside the scope of this manual describing how ggplot works. We give
-here but a brief description on how this plot is generated.
+Now, let's plot the diverging bar plot. When using gKnit, you normally
+do \textbf{not} need to open a graphics device manually; gKnit arranges
+the figure device for chunk output. Galaaz provides integration with
+ggplot. The interested reader should check online for more information
+on ggplot, since it is outside the scope of this manual describing how
+ggplot works. Here we give only a brief description of how this plot is
+generated.
 
 ggplot implements the `grammar of graphics'. In this approach, plots are
-build by adding layers to the plot. On the first layer we describe what
+built by adding layers to the plot. On the first layer we describe what
 we want on the `x' and `y' axis of the plot. In this case, we have
 `car\_name' on the `x' axis and `mpg\_z' on the `y' axis. Then the type
 of graph is specified by adding `geom\_bar' (for a bar graph). We
 specify that our bars should be filled using `mpg\_type', which is
-either `above' or `bellow' giving then two colours for filling. On the
+either `above' or `below' giving then two colours for filling. On the
 next layer we specify the labels for the graph, then we add the title
 and subtitle. Finally, in a bar chart usually bars go on the vertical
-direction, but in this graph we want the bars to be horizontally layed
-so we add `coord\_flip'.
+direction, but in this graph we want the bars to be horizontally laid so
+we add `coord\_flip'.
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{require }\StringTok{'ggplot'}
-
-\NormalTok{puts mtcars.ggplot(E.aes(}\StringTok{x: :car_name}\NormalTok{, }\StringTok{y: :mpg_z}\NormalTok{, }\StringTok{label: :mpg_z}\NormalTok{)) +}
-\NormalTok{     R.geom_bar(E.aes(}\StringTok{fill: :mpg_type}\NormalTok{), }\StringTok{stat: 'identity'}\NormalTok{, }\StringTok{width: }\FloatTok{0.5}\NormalTok{) +}
-\NormalTok{     R.scale_fill_manual(}\StringTok{name: 'Mileage'}\NormalTok{,}
-                         \StringTok{labels: }\NormalTok{R.c(}\StringTok{'Above Average'}\NormalTok{, }\StringTok{'Below Average'}\NormalTok{),}
-                         \StringTok{values: }\NormalTok{R.c(}\StringTok{'above'}\NormalTok{: }\StringTok{'#00ba38'}\NormalTok{, }\StringTok{'below'}\NormalTok{: }\StringTok{'#f8766d'}\NormalTok{)) +}
-\NormalTok{     R.labs(}\StringTok{subtitle: "Normalised mileage from 'mtcars'"}\NormalTok{,}
-            \StringTok{title: "Diverging Bars"}\NormalTok{) + }
-\NormalTok{     R.coord_flip}
+\FunctionTok{require} \VerbatimStringTok{\textquotesingle{}ggplot\textquotesingle{}}
+
+\FunctionTok{puts}\NormalTok{ mtcars}\AttributeTok{.ggplot}\NormalTok{(}\ConstantTok{E}\AttributeTok{.aes}\NormalTok{(}\WarningTok{x:} \WarningTok{:car\_name}\NormalTok{, }\WarningTok{y:} \WarningTok{:mpg\_z}\NormalTok{, }\WarningTok{label:} \WarningTok{:mpg\_z}\NormalTok{)) }\OperatorTok{+}
+     \ConstantTok{R}\AttributeTok{.geom\_bar}\NormalTok{(}\ConstantTok{E}\AttributeTok{.aes}\NormalTok{(}\WarningTok{fill:} \WarningTok{:mpg\_type}\NormalTok{), }\WarningTok{stat:} \VerbatimStringTok{\textquotesingle{}identity\textquotesingle{}}\NormalTok{, }\WarningTok{width:} \FloatTok{0.5}\NormalTok{) }\OperatorTok{+}
+     \ConstantTok{R}\AttributeTok{.scale\_fill\_manual}\NormalTok{(}\WarningTok{name:} \VerbatimStringTok{\textquotesingle{}Mileage\textquotesingle{}}\NormalTok{,}
+                         \WarningTok{labels:} \ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\VerbatimStringTok{\textquotesingle{}Above Average\textquotesingle{}}\NormalTok{, }\VerbatimStringTok{\textquotesingle{}Below Average\textquotesingle{}}\NormalTok{),}
+                         \WarningTok{values:} \ConstantTok{R}\AttributeTok{.c}\NormalTok{(}\VerbatimStringTok{\textquotesingle{}above\textquotesingle{}}\WarningTok{:} \VerbatimStringTok{\textquotesingle{}\#00ba38\textquotesingle{}}\NormalTok{, }\VerbatimStringTok{\textquotesingle{}below\textquotesingle{}}\WarningTok{:} \VerbatimStringTok{\textquotesingle{}\#f8766d\textquotesingle{}}\NormalTok{)) }\OperatorTok{+}
+     \ConstantTok{R}\AttributeTok{.labs}\NormalTok{(}\WarningTok{subtitle:} \StringTok{"Normalised mileage from \textquotesingle{}mtcars\textquotesingle{}"}\NormalTok{,}
+            \WarningTok{title:} \StringTok{"Diverging Bars"}\NormalTok{) }\OperatorTok{+} 
+     \ConstantTok{R}\AttributeTok{.coord\_flip}
 \end{Highlighting}
 \end{Shaded}
 
-\includegraphics{manual_files/figure-latex/diverging_bar.pdf}
+\pandocbounded{\includegraphics[keepaspectratio]{manual_files/figure-latex/diverging_bar.pdf}}
 
 \section{Coding with Tidyverse}\label{coding-with-tidyverse}
 
 In R, and when coding with `tidyverse', arguments to a function are
-usually not \emph{referencially transparent}. That is, you can't replace
+usually not \emph{referentially transparent}. That is, you can't replace
 a value with a seemingly equivalent object that you've defined
 elsewhere. To see the problem, let's first define a data frame:
 
 \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}
+\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}
 
@@ -3366,15 +4062,15 @@ and now, let's look at this code:
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{my_var <-}\StringTok{ }\NormalTok{x}
-\KeywordTok{filter}\NormalTok{(df, my_var }\OperatorTok{==}\StringTok{ }\DecValTok{1}\NormalTok{)}
+\NormalTok{my\_var }\OtherTok{\textless{}{-}}\NormalTok{ x}
+\FunctionTok{filter}\NormalTok{(df, my\_var }\SpecialCharTok{==} \DecValTok{1}\NormalTok{)}
 \end{Highlighting}
 \end{Shaded}
 
 It 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
+However, in Galaaz, arguments are referentially transparent as can be
+seen by the code below. Note initially 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
@@ -3382,8 +4078,8 @@ my\_var is a variable that resolves to `:x' and it becomes equivalent to
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{my_var = }\StringTok{:x}
-\NormalTok{puts df.filter(my_var.eq }\DecValTok{1}\NormalTok{)}
+\NormalTok{my\_var }\OperatorTok{=} \WarningTok{:x}
+\FunctionTok{puts}\NormalTok{ df}\AttributeTok{.filter}\NormalTok{(my\_var}\AttributeTok{.eq} \DecValTok{1}\NormalTok{)}
 \end{Highlighting}
 \end{Shaded}
 
@@ -3392,7 +4088,7 @@ my\_var is a variable that resolves to `:x' and it becomes equivalent to
 ## 1 1 3
 \end{verbatim}
 
-As stated by Hardley
+As stated by Hadley
 
 \begin{quote}
 dplyr code is ambiguous. Depending on what variables are defined where,
@@ -3416,11 +4112,11 @@ chunks of code:
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{y = }\DecValTok{1}
-\NormalTok{x = }\DecValTok{2}
+\NormalTok{y }\OperatorTok{=} \DecValTok{1}
+\NormalTok{x }\OperatorTok{=} \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{)}
+\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{(}\WarningTok{:x}\AttributeTok{.eq} \OperatorTok{:}\NormalTok{y)}
 \end{Highlighting}
 \end{Shaded}
 
@@ -3431,9 +4127,9 @@ chunks of code:
 
 \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)}
+\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{(}\WarningTok{:x}\AttributeTok{.eq}\NormalTok{ y)}
 \end{Highlighting}
 \end{Shaded}
 
@@ -3471,14 +4167,14 @@ 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
+In Galaaz the method mutate\_y below 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}
+\ControlFlowTok{def}\NormalTok{ mutate\_y(df)}
+\NormalTok{  df}\AttributeTok{.mutate}\NormalTok{(}\WarningTok{:y}\AttributeTok{.assign} \OperatorTok{:}\NormalTok{a }\OperatorTok{+} \WarningTok{:x}\NormalTok{)}
+\ControlFlowTok{end}
 \end{Highlighting}
 \end{Shaded}
 
@@ -3486,8 +4182,8 @@ 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}
+\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}
 
@@ -3498,48 +4194,44 @@ Here we create a data frame that has only one column named `x':
 ## 3 3
 \end{verbatim}
 
-Note that method mutate\_y will fail independetly from the fact that
+Note that method mutate\_y will fail independently 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)}
+\NormalTok{a }\OperatorTok{=} \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
+## Error in strsplit(path, "/") : non-character argument
+## Calls: mutate ... .rlang_purrr_map_mold -> vapply -> FUN -> path_trim_prefix -> strsplit
 \end{verbatim}
 
 \subsection{Different expressions}\label{different-expressions}
 
-Let's move to the next problem as presented by Hardley where trying to
+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. Bellow we create 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}[]
-\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{)}
+\FunctionTok{library}\NormalTok{(dplyr)}
+\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{)}
 
-\KeywordTok{as.data.frame}\NormalTok{(df) }
+\FunctionTok{as.data.frame}\NormalTok{(df) }
 \end{Highlighting}
 \end{Shaded}
 
@@ -3554,11 +4246,11 @@ variable and summarises it by an expression:
 
 \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))}
+\NormalTok{d2 }\OtherTok{\textless{}{-}}\NormalTok{ df }\SpecialCharTok{\%\textgreater{}\%}
+  \FunctionTok{group\_by}\NormalTok{(g1) }\SpecialCharTok{\%\textgreater{}\%}
+  \FunctionTok{summarise}\NormalTok{(}\AttributeTok{a =} \FunctionTok{mean}\NormalTok{(a))}
            
-\KeywordTok{as.data.frame}\NormalTok{(d2)          }
+\FunctionTok{as.data.frame}\NormalTok{(d2)          }
 \end{Highlighting}
 \end{Shaded}
 
@@ -3570,11 +4262,11 @@ variable and summarises it by an expression:
 
 \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))}
+\NormalTok{d2 }\OtherTok{\textless{}{-}}\NormalTok{ df }\SpecialCharTok{\%\textgreater{}\%}
+  \FunctionTok{group\_by}\NormalTok{(g2) }\SpecialCharTok{\%\textgreater{}\%}
+  \FunctionTok{summarise}\NormalTok{(}\AttributeTok{a =} \FunctionTok{mean}\NormalTok{(a))}
            
-\KeywordTok{as.data.frame}\NormalTok{(d2)          }
+\FunctionTok{as.data.frame}\NormalTok{(d2)          }
 \end{Highlighting}
 \end{Shaded}
 
@@ -3584,35 +4276,35 @@ variable and summarises it by an expression:
 ## 2  2 3
 \end{verbatim}
 
-As shown by Hardley, one might expect this function to do the trick:
+As shown by Hadley, 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{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{#> Error: Column `group_var` is unknown}
+\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 Hardley the explanation on how to use all those functions.
+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 tilda operator
-`\textasciitilde{}' applied to the R variable name as symbol, i.e.,
-`:df'.
+access an R variable from Galaaz, we use the tilde operator
+\texttt{\textasciitilde{}} applied to the R variable name as a symbol,
+e.g.~\texttt{:df}).
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts ~}\StringTok{:df}
+\FunctionTok{puts} \OperatorTok{\textasciitilde{}}\WarningTok{:df}
 \end{Highlighting}
 \end{Shaded}
 
@@ -3630,12 +4322,12 @@ frame and the group by variable `:g1':
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\KeywordTok{def}\NormalTok{ my_summarize(df, group_var)}
-\NormalTok{  df.group_by(group_var).}
-\NormalTok{    summarize(}\StringTok{a: :a}\NormalTok{.mean)}
-\KeywordTok{end}
+\ControlFlowTok{def}\NormalTok{ my\_summarize(df, group\_var)}
+\NormalTok{  df}\AttributeTok{.group\_by}\NormalTok{(group\_var)}\AttributeTok{.}
+    \AttributeTok{summarize}\NormalTok{(}\WarningTok{a:} \WarningTok{:a}\AttributeTok{.mean}\NormalTok{)}
+\ControlFlowTok{end}
 
-\NormalTok{puts my_summarize(}\StringTok{:df}\NormalTok{, }\StringTok{:g1}\NormalTok{)}
+\FunctionTok{puts}\NormalTok{ my\_summarize(}\WarningTok{:df}\NormalTok{, }\WarningTok{:g1}\NormalTok{)}
 \end{Highlighting}
 \end{Shaded}
 
@@ -3651,7 +4343,7 @@ 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{)}
+\FunctionTok{puts}\NormalTok{ my\_summarize(}\WarningTok{:df}\NormalTok{, }\WarningTok{:g2}\NormalTok{)}
 \end{Highlighting}
 \end{Shaded}
 
@@ -3674,9 +4366,9 @@ 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:
+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())
@@ -3696,17 +4388,18 @@ 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}
+\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{  )}
-\KeywordTok{end}
+\ControlFlowTok{end}
 
-\NormalTok{puts my_summarise2((~}\StringTok{:df}\NormalTok{), }\StringTok{:a}\NormalTok{)}
-\NormalTok{puts }\StringTok{"\textbackslash{}n"}
-\NormalTok{puts my_summarise2((~}\StringTok{:df}\NormalTok{), }\StringTok{:a}\NormalTok{ * }\StringTok{:b}\NormalTok{)}
+\FunctionTok{puts}\NormalTok{ my\_summarise2((}\OperatorTok{\textasciitilde{}}\WarningTok{:df}\NormalTok{), }\WarningTok{:a}\NormalTok{)}
+\FunctionTok{puts} \StringTok{"}
+\StringTok{"}
+\FunctionTok{puts}\NormalTok{ my\_summarise2((}\OperatorTok{\textasciitilde{}}\WarningTok{:df}\NormalTok{), }\WarningTok{:a} \OperatorTok{*} \WarningTok{:b}\NormalTok{)}
 \end{Highlighting}
 \end{Shaded}
 
@@ -3725,7 +4418,7 @@ from functions `mean', `sum' and `n'.
 \subsection{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
+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
@@ -3753,25 +4446,26 @@ mutate(df, mean_b = mean(b), sum_b = sum(b))
 #> # … 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
+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}[]
-\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 }\StringTok{"\textbackslash{}n"}
-\NormalTok{puts my_mutate((~}\StringTok{:df}\NormalTok{), }\StringTok{:b}\NormalTok{)}
+\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{}}\WarningTok{:df}\NormalTok{), }\WarningTok{:a}\NormalTok{)}
+\FunctionTok{puts} \StringTok{"}
+\StringTok{"}
+\FunctionTok{puts}\NormalTok{ my\_mutate((}\OperatorTok{\textasciitilde{}}\WarningTok{:df}\NormalTok{), }\WarningTok{:b}\NormalTok{)}
 \end{Highlighting}
 \end{Shaded}
 
@@ -3794,38 +4488,38 @@ Here is our Ruby code:
 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.
+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{}.{]}
+{[}explain\ldots.{]}
 
 \subsection{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.
+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}[]
-\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}
+\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}
 
-\NormalTok{puts my_summarise3((~}\StringTok{:df}\NormalTok{), }\StringTok{:g1}\NormalTok{, }\StringTok{:g2}\NormalTok{)}
+\FunctionTok{puts}\NormalTok{ my\_summarise3((}\OperatorTok{\textasciitilde{}}\WarningTok{:df}\NormalTok{), }\WarningTok{:g1}\NormalTok{, }\WarningTok{:g2}\NormalTok{)}
 \end{Highlighting}
 \end{Shaded}
 
 \begin{verbatim}
 ## # A tibble: 4 x 3
-## # Groups:   g1 [?]
+## # Groups:   g1 [2]
 ##      g1    g2     a
 ##   <dbl> <dbl> <dbl>
 ## 1     1     1     3
@@ -3895,41 +4589,59 @@ the Starwars movies:
 
 \begin{Shaded}
 \begin{Highlighting}[]
-\NormalTok{puts (~}\StringTok{:starwars}\NormalTok{).head}
+\FunctionTok{puts}\NormalTok{ (}\OperatorTok{\textasciitilde{}}\WarningTok{:starwars}\NormalTok{)}\AttributeTok{.head}
 \end{Highlighting}
 \end{Shaded}
 
 \begin{verbatim}
-## # A tibble: 6 x 13
-##   name  height  mass hair_color skin_color eye_color birth_year gender
-##   <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   <NA>  
-## 3 R2-D2     96    32 <NA>       white, bl~ red             33   <NA>  
-## 4 Dart~    202   136 none       white      yellow          41.9 male  
-## 5 Leia~    150    49 brown      light      brown           19   female
-## 6 Owen~    178   120 brown, gr~ light      blue            52   male  
-## # ... with 5 more variables: homeworld <chr>, species <chr>, films <list>,
+## # A tibble: 6 x 14
+##   name      height  mass hair_color skin_color eye_color birth_year sex   gender
+##   <chr>      <int> <dbl> <chr>      <chr>      <chr>          <dbl> <chr> <chr> 
+## 1 Luke Sky~    172    77 blond      fair       blue            19   male  mascu~
+## 2 C-3PO        167    75 <NA>       gold       yellow         112   none  mascu~
+## 3 R2-D2         96    32 <NA>       white, bl~ red             33   none  mascu~
+## 4 Darth Va~    202   136 none       white      yellow          41.9 male  mascu~
+## 5 Leia Org~    150    49 brown      light      brown           19   fema~ femin~
+## 6 Owen Lars    178   120 brown, gr~ light      blue            52   male  mascu~
+## # i 5 more variables: homeworld <chr>, species <chr>, films <list>,
 ## #   vehicles <list>, starships <list>
 \end{verbatim}
 
-The grouped\_mean function bellow will receive a grouping variable and
+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 <-}\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{, .)))}
+\FunctionTok{library}\NormalTok{(dplyr)}
+\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 =}\StringTok{ }\NormalTok{starwars }\OperatorTok{%>%}\StringTok{ }
-\StringTok{   }\KeywordTok{grouped_mean}\NormalTok{(}\StringTok{"eye_color"}\NormalTok{, }\KeywordTok{c}\NormalTok{(}\StringTok{"mass"}\NormalTok{, }\StringTok{"birth_year"}\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}
 
-\KeywordTok{as.data.frame}\NormalTok{(gm)   }
+\begin{Shaded}
+\begin{Highlighting}[]
+\FunctionTok{as.data.frame}\NormalTok{(gm)   }
 \end{Highlighting}
 \end{Shaded}
 
@@ -3956,15 +4668,15 @@ 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{))}
+\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{), }\OperatorTok{\textasciitilde{}}\WarningTok{:mean}\NormalTok{, }\WarningTok{na\_\_rm:} \DecValTok{true}\NormalTok{)}\AttributeTok{.}
+    \AttributeTok{rename\_at}\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((}\OperatorTok{\textasciitilde{}}\WarningTok{:starwars}\NormalTok{), }\StringTok{"eye\_color"}\NormalTok{, }\ConstantTok{E}\AttributeTok{.c}\NormalTok{(}\StringTok{"mass"}\NormalTok{, }\StringTok{"birth\_year"}\NormalTok{))}
 \end{Highlighting}
 \end{Shaded}
 
@@ -3989,7 +4701,11 @@ The same code with Galaaz, becomes:
 ## 15 yellow             81.1            76.4    11
 \end{verbatim}
 
-{[}TO BE CONTINUED\ldots{}{]}
+The examples above cover programmatic dplyr with string column names and
+\texttt{\_at} helpers. The same Galaaz patterns (symbols, \texttt{E.*}
+for expression-safe functions, and Ruby methods on R-backed objects)
+extend to other tidyverse workflows; consult R package documentation for
+function-specific arguments.
 
 \section{Contributing}\label{contributing}
 
@@ -3998,29 +4714,35 @@ The same code with Galaaz, becomes:
 \item
   Fork it
 \item
-  Create your feature branch (git checkout -b my-new-feature)
+  Create your feature branch
+  (\texttt{git\ checkout\ -b\ my-new-feature})
 \item
-  Write Tests!
+  Write tests --- use \textbf{\texttt{bin/run\_rspec}} or
+  \textbf{\texttt{bin/run\_all\_rspec}} with \textbf{JRuby} so JVM flags
+  and the load path match \textbf{\texttt{docs/testing.md}}
 \item
-  Commit your changes (git commit -am `Add some feature')
+  Commit your changes
+  (\texttt{git\ commit\ -am\ \textquotesingle{}Add\ some\ feature\textquotesingle{}})
 \item
-  Push to the branch (git push origin my-new-feature)
+  Push to the branch (\texttt{git\ push\ origin\ my-new-feature})
 \item
-  Create new Pull Request
+  Open a pull request
 \end{itemize}
 
 \section*{References}\label{references}
 \addcontentsline{toc}{section}{References}
 
-\hypertarget{refs}{}
-\hypertarget{ref-Knuth:literate_programming}{}
-Knuth, Donald E. 1984. ``Literate Programming.'' \emph{Comput. J.} 27
-(2). Oxford, UK: Oxford University Press: 97--111.
-doi:\href{https://doi.org/10.1093/comjnl/27.2.97}{10.1093/comjnl/27.2.97}.
+\protect\phantomsection\label{refs}
+\begin{CSLReferences}{1}{1}
+\bibitem[\citeproctext]{ref-Knuth:literate_programming}
+Knuth, Donald E. 1984. {``Literate Programming.''} \emph{Comput. J.}
+(Oxford, UK) 27 (2): 97--111.
+\url{https://doi.org/10.1093/comjnl/27.2.97}.
 
-\hypertarget{ref-Wilkinson:grammar_of_graphics}{}
+\bibitem[\citeproctext]{ref-Wilkinson:grammar_of_graphics}
 Wilkinson, Leland. 2005. \emph{The Grammar of Graphics (Statistics and
-Computing)}. Berlin, Heidelberg: Springer-Verlag.
+Computing)}. Springer-Verlag.
 
+\end{CSLReferences}
 
 \end{document}