diff --git a/DESCRIPTION b/DESCRIPTION
index f084af3..fd5f9bb 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -30,7 +30,6 @@ URL: https://github.com/datashield/DSLite/,
     https://datashield.org/,
     https://doi.org/10.1093/ije/dyu188
 BugReports: https://github.com/datashield/DSLite/issues/
-RoxygenNote: 7.3.2
 Roxygen: list(markdown = TRUE)
 VignetteBuilder: knitr
 Encoding: UTF-8
@@ -55,3 +54,4 @@ Collate:
     'setupDSLiteServer.R'
     'setupSURVIVALTest.R'
     'testParse.R'
+Config/roxygen2/version: 8.1.0
diff --git a/R/DSLiteServer.R b/R/DSLiteServer.R
index dc09765..d80d90d 100644
--- a/R/DSLiteServer.R
+++ b/R/DSLiteServer.R
@@ -536,8 +536,8 @@ DSLiteServer <- R6::R6Class(
           }
         }
         
-        if (!is.null(self$children)) {
-          for (child in self$children) {
+        if (!is.null(node$children)) {
+          for (child in node$children) {
             if (!is.null(child)) {
               replaceFunctionNode(child)
             }
diff --git a/R/lex-yacc.R b/R/lex-yacc.R
index 31389b2..8f88ae1 100644
--- a/R/lex-yacc.R
+++ b/R/lex-yacc.R
@@ -8,7 +8,7 @@ Lexer <- R6::R6Class(
     tokens = TOKENS,
     literals = LITERALS,
     
-    t_NAME = '[a-zA-Z_][a-zA-Z\\d_\\$\\.-]*',
+    t_NAME = '[a-zA-Z_][a-zA-Z\\d_\\$\\.]*',
     
     t_STRING = '\'[a-zA-Z\\d_+-;:\\$]*\'',
     
@@ -16,9 +16,9 @@ Lexer <- R6::R6Class(
     
     t_INTEGER = '\\d+L',
     
-    t_NUMBER = '[+-]?\\d+(\\.\\d+)?([eE][+-]?\\d+)?',
+    t_NUMBER = '\\d+(\\.\\d+)?([eE][+-]?\\d+)?',
     
-    t_PCTOP = '%[a-z]+%',
+    t_PCTOP = '%[a-z*/]*%',
     
     t_NOTOP = '!',
     
@@ -38,10 +38,17 @@ Parser <- R6::R6Class(
     tokens = TOKENS,
     literals = LITERALS,
     # Parsing rules
+    # From the loosest to the tightest binding, see ?Syntax
     precedence = list(
+      c('right', '='),
+      c('left', '~'),
+      c('right', 'NOTOP'),
       c('left', '+', '-'),
-      c('left', '*', '/', 'PCTOP', ':', '^'),
-      c('right', 'UMINUS', 'NOTOP')
+      c('left', '*', '/'),
+      c('left', 'PCTOP'),
+      c('left', ':'),
+      c('right', 'UMINUS'),
+      c('right', '^')
     ),
     
     p_expression_named = function(doc='expression : NAME "=" expression', p) {
@@ -51,49 +58,23 @@ Parser <- R6::R6Class(
       p$set(1, op)
     },
     
-    p_expression_formula = function(doc='expression : NAME "~" formula_term', p) {
+    p_expression_formula = function(doc='expression : expression "~" expression', p) {
       op <- FormulaNode$new(p$get(3))
-      op$add_child(SymbolNode$new(p$get(2)))
-      op$add_child(p$get(4))
-      p$set(1, op)
-    },
-    
-    p_formula_term_binop = function(doc="formula_term : formula_term '+' formula_term
-                                                      | formula_term '-' formula_term
-                                                      | formula_term '*' formula_term
-                                                      | formula_term ':' formula_term
-                                                      | formula_term '^' formula_term
-                                                      | formula_term PCTOP formula_term", p) {
-      op <- BinaryOpNode$new(p$get(3))
       op$add_child(p$get(2))
       op$add_child(p$get(4))
+      # formulas are not mapped to the configured methods
+      op$accept(list(visit = function(node) {
+        if (inherits(node, c("FunctionNode", "StringNode")))
+          stop(sprintf("Syntax error in formula at '%s'", node$name))
+      }))
       p$set(1, op)
     },
     
-    p_formula_term_name = function(doc='formula_term : NAME', p) {
-      p$set(1, SymbolNode$new(p$get(2)))
-    },
-    
-    p_formula_term_number = function(doc='formula_term : NUMBER', p) {
-      p$set(1, NumericNode$new(p$get(2)))
-    },
-    
-    p_formula_term_not = function(doc='formula_term : NOTOP formula_term', p) {
-      op <- UnaryOpNode$new("!")
-      op$add_child(p$get(3))
-      p$set(1, op)
-    },
-    
-    p_formula_term_group = function(doc="formula_term : '(' formula_term ')'", p) {
-      gn <- GroupNode$new()
-      gn$add_child(p$get(3))
-      p$set(1, gn)
-    },
-    
     p_expression_binop = function(doc="expression : expression '+' expression
                                                   | expression '-' expression
                                                   | expression '*' expression
                                                   | expression '/' expression
+                                                  | expression '^' expression
                                                   | expression ':' expression
                                                   | expression PCTOP expression", p) {
       if (p$get(3) == ':') {
@@ -109,8 +90,9 @@ Parser <- R6::R6Class(
       }
     },
     
-    p_expression_uminus = function(doc="expression : '-' expression %prec UMINUS", p) {
-      op <- UnaryOpNode$new("-")
+    p_expression_uminus = function(doc="expression : '-' expression %prec UMINUS
+                                                  | '+' expression %prec UMINUS", p) {
+      op <- UnaryOpNode$new(p$get(2))
       op$add_child(p$get(3))
       p$set(1, op)
     },
diff --git a/man/BinaryOpNode.Rd b/man/BinaryOpNode.Rd
index 84d9268..54ba961 100644
--- a/man/BinaryOpNode.Rd
+++ b/man/BinaryOpNode.Rd
@@ -8,7 +8,7 @@
 AST node that represents a binary operation (such as '+', '-' etc.), and therefore having two child nodes.
 }
 \seealso{
-Other parser items: 
+Other parser items:
 \code{\link{FormulaNode}},
 \code{\link{FunctionNode}},
 \code{\link{GroupNode}},
@@ -22,68 +22,72 @@ Other parser items:
 }
 \concept{parser items}
 \section{Super class}{
-\code{\link[DSLite:Node]{DSLite::Node}} -> \code{BinaryOpNode}
+\code{\link[DSLite:Node]{Node}} -> \code{BinaryOpNode}
 }
 \section{Methods}{
 \subsection{Public methods}{
-\itemize{
-\item \href{#method-BinaryOpNode-add_child}{\code{BinaryOpNode$add_child()}}
-\item \href{#method-BinaryOpNode-to_string}{\code{BinaryOpNode$to_string()}}
-\item \href{#method-BinaryOpNode-clone}{\code{BinaryOpNode$clone()}}
+  \itemize{
+    \item \href{#method-BinaryOpNode-add_child}{\code{BinaryOpNode$add_child()}}
+    \item \href{#method-BinaryOpNode-to_string}{\code{BinaryOpNode$to_string()}}
+    \item \href{#method-BinaryOpNode-clone}{\code{BinaryOpNode$clone()}}
+  }
 }
-}
-\if{html}{\out{
-<details open><summary>Inherited methods</summary>
+\if{html}{\out{<details open><summary>Inherited methods</summary>
 <ul>
-<li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="accept"><a href='../../DSLite/html/Node.html#method-Node-accept'><code>DSLite::Node$accept()</code></a></span></li>
-<li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="initialize"><a href='../../DSLite/html/Node.html#method-Node-initialize'><code>DSLite::Node$initialize()</code></a></span></li>
-<li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="set_parent"><a href='../../DSLite/html/Node.html#method-Node-set_parent'><code>DSLite::Node$set_parent()</code></a></span></li>
-<li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="to_string_children"><a href='../../DSLite/html/Node.html#method-Node-to_string_children'><code>DSLite::Node$to_string_children()</code></a></span></li>
+  <li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="accept"><a href='../../DSLite/html/Node.html#method-Node-accept'><code>Node$accept()</code></a></span></li>
+  <li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="initialize"><a href='../../DSLite/html/Node.html#method-Node-initialize'><code>Node$initialize()</code></a></span></li>
+  <li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="set_parent"><a href='../../DSLite/html/Node.html#method-Node-set_parent'><code>Node$set_parent()</code></a></span></li>
+  <li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="to_string_children"><a href='../../DSLite/html/Node.html#method-Node-to_string_children'><code>Node$to_string_children()</code></a></span></li>
 </ul>
-</details>
-}}
+</details>}}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-BinaryOpNode-add_child"></a>}}
 \if{latex}{\out{\hypertarget{method-BinaryOpNode-add_child}{}}}
-\subsection{Method \code{add_child()}}{
-Two children
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{BinaryOpNode$add_child(val)}\if{html}{\out{</div>}}
+\subsection{\code{BinaryOpNode$add_child()}}{
+  Two children
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{BinaryOpNode$add_child(val)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{val}}{Child Node}
+    }
+    \if{html}{\out{</div>}}
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{val}}{Child Node}
-}
-\if{html}{\out{</div>}}
-}
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-BinaryOpNode-to_string"></a>}}
 \if{latex}{\out{\hypertarget{method-BinaryOpNode-to_string}{}}}
-\subsection{Method \code{to_string()}}{
-Get the string representation of the BinaryOpNode
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{BinaryOpNode$to_string()}\if{html}{\out{</div>}}
+\subsection{\code{BinaryOpNode$to_string()}}{
+  Get the string representation of the BinaryOpNode
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{BinaryOpNode$to_string()}
+    \if{html}{\out{</div>}}
+  }
 }
 
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-BinaryOpNode-clone"></a>}}
 \if{latex}{\out{\hypertarget{method-BinaryOpNode-clone}{}}}
-\subsection{Method \code{clone()}}{
-The objects of this class are cloneable with this method.
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{BinaryOpNode$clone(deep = FALSE)}\if{html}{\out{</div>}}
+\subsection{\code{BinaryOpNode$clone()}}{
+  The objects of this class are cloneable with this method.
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{BinaryOpNode$clone(deep = FALSE)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{deep}}{Whether to make a deep clone.}
+    }
+    \if{html}{\out{</div>}}
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{deep}}{Whether to make a deep clone.}
-}
-\if{html}{\out{</div>}}
-}
-}
 }
diff --git a/man/DSLiteServer.Rd b/man/DSLiteServer.Rd
index c356cf1..d358e22 100644
--- a/man/DSLiteServer.Rd
+++ b/man/DSLiteServer.Rd
@@ -10,665 +10,706 @@ DataSHIELD-like functions: aggregate and assign. A DataSHIELD session is a R
 environment where the assignment and the operations happen.
 }
 \seealso{
-Other server-side items: 
-\code{\link{newDSLiteServer}()}
+Other server-side items:
+\code{\link[=newDSLiteServer]{newDSLiteServer()}}
 }
 \concept{server-side items}
 \section{Methods}{
 \subsection{Public methods}{
-\itemize{
-\item \href{#method-DSLiteServer-new}{\code{DSLiteServer$new()}}
-\item \href{#method-DSLiteServer-config}{\code{DSLiteServer$config()}}
-\item \href{#method-DSLiteServer-profile}{\code{DSLiteServer$profile()}}
-\item \href{#method-DSLiteServer-strict}{\code{DSLiteServer$strict()}}
-\item \href{#method-DSLiteServer-home}{\code{DSLiteServer$home()}}
-\item \href{#method-DSLiteServer-workspaces}{\code{DSLiteServer$workspaces()}}
-\item \href{#method-DSLiteServer-workspace_save}{\code{DSLiteServer$workspace_save()}}
-\item \href{#method-DSLiteServer-workspace_restore}{\code{DSLiteServer$workspace_restore()}}
-\item \href{#method-DSLiteServer-workspace_rm}{\code{DSLiteServer$workspace_rm()}}
-\item \href{#method-DSLiteServer-aggregateMethods}{\code{DSLiteServer$aggregateMethods()}}
-\item \href{#method-DSLiteServer-aggregateMethod}{\code{DSLiteServer$aggregateMethod()}}
-\item \href{#method-DSLiteServer-assignMethods}{\code{DSLiteServer$assignMethods()}}
-\item \href{#method-DSLiteServer-assignMethod}{\code{DSLiteServer$assignMethod()}}
-\item \href{#method-DSLiteServer-options}{\code{DSLiteServer$options()}}
-\item \href{#method-DSLiteServer-option}{\code{DSLiteServer$option()}}
-\item \href{#method-DSLiteServer-newSession}{\code{DSLiteServer$newSession()}}
-\item \href{#method-DSLiteServer-hasSession}{\code{DSLiteServer$hasSession()}}
-\item \href{#method-DSLiteServer-getSession}{\code{DSLiteServer$getSession()}}
-\item \href{#method-DSLiteServer-getSessionIds}{\code{DSLiteServer$getSessionIds()}}
-\item \href{#method-DSLiteServer-getSessionData}{\code{DSLiteServer$getSessionData()}}
-\item \href{#method-DSLiteServer-closeSession}{\code{DSLiteServer$closeSession()}}
-\item \href{#method-DSLiteServer-tableNames}{\code{DSLiteServer$tableNames()}}
-\item \href{#method-DSLiteServer-hasTable}{\code{DSLiteServer$hasTable()}}
-\item \href{#method-DSLiteServer-resourceNames}{\code{DSLiteServer$resourceNames()}}
-\item \href{#method-DSLiteServer-hasResource}{\code{DSLiteServer$hasResource()}}
-\item \href{#method-DSLiteServer-symbols}{\code{DSLiteServer$symbols()}}
-\item \href{#method-DSLiteServer-symbol_rm}{\code{DSLiteServer$symbol_rm()}}
-\item \href{#method-DSLiteServer-assignTable}{\code{DSLiteServer$assignTable()}}
-\item \href{#method-DSLiteServer-assignResource}{\code{DSLiteServer$assignResource()}}
-\item \href{#method-DSLiteServer-assignExpr}{\code{DSLiteServer$assignExpr()}}
-\item \href{#method-DSLiteServer-aggregate}{\code{DSLiteServer$aggregate()}}
-\item \href{#method-DSLiteServer-clone}{\code{DSLiteServer$clone()}}
-}
-}
-\if{html}{\out{<hr>}}
-\if{html}{\out{<a id="method-DSLiteServer-new"></a>}}
-\if{latex}{\out{\hypertarget{method-DSLiteServer-new}{}}}
-\subsection{Method \code{new()}}{
-Create new DSLiteServer instance. See \link{defaultDSConfiguration} function for including or excluding packages
+  \itemize{
+    \item \href{#method-DSLiteServer-initialize}{\code{DSLiteServer$new()}}
+    \item \href{#method-DSLiteServer-config}{\code{DSLiteServer$config()}}
+    \item \href{#method-DSLiteServer-profile}{\code{DSLiteServer$profile()}}
+    \item \href{#method-DSLiteServer-strict}{\code{DSLiteServer$strict()}}
+    \item \href{#method-DSLiteServer-home}{\code{DSLiteServer$home()}}
+    \item \href{#method-DSLiteServer-workspaces}{\code{DSLiteServer$workspaces()}}
+    \item \href{#method-DSLiteServer-workspace_save}{\code{DSLiteServer$workspace_save()}}
+    \item \href{#method-DSLiteServer-workspace_restore}{\code{DSLiteServer$workspace_restore()}}
+    \item \href{#method-DSLiteServer-workspace_rm}{\code{DSLiteServer$workspace_rm()}}
+    \item \href{#method-DSLiteServer-aggregateMethods}{\code{DSLiteServer$aggregateMethods()}}
+    \item \href{#method-DSLiteServer-aggregateMethod}{\code{DSLiteServer$aggregateMethod()}}
+    \item \href{#method-DSLiteServer-assignMethods}{\code{DSLiteServer$assignMethods()}}
+    \item \href{#method-DSLiteServer-assignMethod}{\code{DSLiteServer$assignMethod()}}
+    \item \href{#method-DSLiteServer-options}{\code{DSLiteServer$options()}}
+    \item \href{#method-DSLiteServer-option}{\code{DSLiteServer$option()}}
+    \item \href{#method-DSLiteServer-newSession}{\code{DSLiteServer$newSession()}}
+    \item \href{#method-DSLiteServer-hasSession}{\code{DSLiteServer$hasSession()}}
+    \item \href{#method-DSLiteServer-getSession}{\code{DSLiteServer$getSession()}}
+    \item \href{#method-DSLiteServer-getSessionIds}{\code{DSLiteServer$getSessionIds()}}
+    \item \href{#method-DSLiteServer-getSessionData}{\code{DSLiteServer$getSessionData()}}
+    \item \href{#method-DSLiteServer-closeSession}{\code{DSLiteServer$closeSession()}}
+    \item \href{#method-DSLiteServer-tableNames}{\code{DSLiteServer$tableNames()}}
+    \item \href{#method-DSLiteServer-hasTable}{\code{DSLiteServer$hasTable()}}
+    \item \href{#method-DSLiteServer-resourceNames}{\code{DSLiteServer$resourceNames()}}
+    \item \href{#method-DSLiteServer-hasResource}{\code{DSLiteServer$hasResource()}}
+    \item \href{#method-DSLiteServer-symbols}{\code{DSLiteServer$symbols()}}
+    \item \href{#method-DSLiteServer-symbol_rm}{\code{DSLiteServer$symbol_rm()}}
+    \item \href{#method-DSLiteServer-assignTable}{\code{DSLiteServer$assignTable()}}
+    \item \href{#method-DSLiteServer-assignResource}{\code{DSLiteServer$assignResource()}}
+    \item \href{#method-DSLiteServer-assignExpr}{\code{DSLiteServer$assignExpr()}}
+    \item \href{#method-DSLiteServer-aggregate}{\code{DSLiteServer$aggregate()}}
+    \item \href{#method-DSLiteServer-clone}{\code{DSLiteServer$clone()}}
+  }
+}
+\if{html}{\out{<hr>}}
+\if{html}{\out{<a id="method-DSLiteServer-initialize"></a>}}
+\if{latex}{\out{\hypertarget{method-DSLiteServer-initialize}{}}}
+\subsection{\code{DSLiteServer$new()}}{
+  Create new DSLiteServer instance. See \link{defaultDSConfiguration} function for including or excluding packages
 when discovering the DataSHIELD configuration from the DataSHIELD server-side packages (meta-data from the DESCRIPTION files).
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{DSLiteServer$new(
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{DSLiteServer$new(
   tables = list(),
   resources = list(),
   config = DSLite::defaultDSConfiguration(),
   strict = TRUE,
   home = file.path(tempdir(), ".dslite"),
   profile = "default"
-)}\if{html}{\out{</div>}}
-}
-
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{tables}}{A named list of data.frames representing the harmonized tables.}
-
-\item{\code{resources}}{A named list of \code{resourcer::Resource} objects representing accessible data or computation resources.}
-
-\item{\code{config}}{The DataSHIELD configuration. Default is to discover it from the DataSHIELD server-side R packages.}
-
-\item{\code{strict}}{Logical to specify whether the DataSHIELD configuration must be strictly applied. Default is TRUE.}
-
-\item{\code{home}}{Folder location where are located the session work directory and where to read and dump workspace images.}
-
-\item{\code{profile}}{The DataSHIELD profile name, used to give a name to the DS configuration. Default is "default".
+)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{tables}}{A named list of data.frames representing the harmonized tables.}
+      \item{\code{resources}}{A named list of \code{resourcer::Resource} objects representing accessible data or computation resources.}
+      \item{\code{config}}{The DataSHIELD configuration. Default is to discover it from the DataSHIELD server-side R packages.}
+      \item{\code{strict}}{Logical to specify whether the DataSHIELD configuration must be strictly applied. Default is TRUE.}
+      \item{\code{home}}{Folder location where are located the session work directory and where to read and dump workspace images.}
+      \item{\code{profile}}{The DataSHIELD profile name, used to give a name to the DS configuration. Default is "default".
 Default is in a hidden folder of the R session's temporary directory.}
+    }
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Returns}{
+    A DSLiteServer object
+  }
 }
-\if{html}{\out{</div>}}
-}
-\subsection{Returns}{
-A DSLiteServer object
-}
-}
+
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-DSLiteServer-config"></a>}}
 \if{latex}{\out{\hypertarget{method-DSLiteServer-config}{}}}
-\subsection{Method \code{config()}}{
-Get or set the DataSHIELD configuration.
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{DSLiteServer$config(value)}\if{html}{\out{</div>}}
+\subsection{\code{DSLiteServer$config()}}{
+  Get or set the DataSHIELD configuration.
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{DSLiteServer$config(value)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{value}}{The DataSHIELD configuration: aggregate/assign methods in data frames and a named list of options.}
+    }
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Returns}{
+    The DataSHIELD configuration, if no parameter is provided.
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{value}}{The DataSHIELD configuration: aggregate/assign methods in data frames and a named list of options.}
-}
-\if{html}{\out{</div>}}
-}
-\subsection{Returns}{
-The DataSHIELD configuration, if no parameter is provided.
-}
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-DSLiteServer-profile"></a>}}
 \if{latex}{\out{\hypertarget{method-DSLiteServer-profile}{}}}
-\subsection{Method \code{profile()}}{
-Get or set the DataSHIELD profile name.
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{DSLiteServer$profile(value)}\if{html}{\out{</div>}}
+\subsection{\code{DSLiteServer$profile()}}{
+  Get or set the DataSHIELD profile name.
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{DSLiteServer$profile(value)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{value}}{The DataSHIELD profile name.}
+    }
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Returns}{
+    The DataSHIELD profile, if no parameter is provided.
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{value}}{The DataSHIELD profile name.}
-}
-\if{html}{\out{</div>}}
-}
-\subsection{Returns}{
-The DataSHIELD profile, if no parameter is provided.
-}
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-DSLiteServer-strict"></a>}}
 \if{latex}{\out{\hypertarget{method-DSLiteServer-strict}{}}}
-\subsection{Method \code{strict()}}{
-Get or set the level of strictness (stop when function call is not configured)
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{DSLiteServer$strict(value)}\if{html}{\out{</div>}}
+\subsection{\code{DSLiteServer$strict()}}{
+  Get or set the level of strictness (stop when function call is not configured)
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{DSLiteServer$strict(value)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{value}}{The \code{strict} logical field.}
+    }
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Returns}{
+    The strict field if no parameter is provided.
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{value}}{The \code{strict} logical field.}
-}
-\if{html}{\out{</div>}}
-}
-\subsection{Returns}{
-The strict field if no parameter is provided.
-}
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-DSLiteServer-home"></a>}}
 \if{latex}{\out{\hypertarget{method-DSLiteServer-home}{}}}
-\subsection{Method \code{home()}}{
-Get or set the home folder location where are located the session work directories and where to read and dump workspace images.
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{DSLiteServer$home(value)}\if{html}{\out{</div>}}
+\subsection{\code{DSLiteServer$home()}}{
+  Get or set the home folder location where are located the session work directories and where to read and dump workspace images.
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{DSLiteServer$home(value)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{value}}{The path to the home folder.}
+    }
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Returns}{
+    The home folder path if no parameter is provided.
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{value}}{The path to the home folder.}
-}
-\if{html}{\out{</div>}}
-}
-\subsection{Returns}{
-The home folder path if no parameter is provided.
-}
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-DSLiteServer-workspaces"></a>}}
 \if{latex}{\out{\hypertarget{method-DSLiteServer-workspaces}{}}}
-\subsection{Method \code{workspaces()}}{
-List the saved workspaces in the \code{home} folder.
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{DSLiteServer$workspaces(prefix = NULL)}\if{html}{\out{</div>}}
+\subsection{\code{DSLiteServer$workspaces()}}{
+  List the saved workspaces in the \code{home} folder.
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{DSLiteServer$workspaces(prefix = NULL)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{prefix}}{Filter workspaces starting with provided prefix (optional).}
+    }
+    \if{html}{\out{</div>}}
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{prefix}}{Filter workspaces starting with provided prefix (optional).}
-}
-\if{html}{\out{</div>}}
-}
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-DSLiteServer-workspace_save"></a>}}
 \if{latex}{\out{\hypertarget{method-DSLiteServer-workspace_save}{}}}
-\subsection{Method \code{workspace_save()}}{
-Save the session's workspace image identified by the \code{sid} identifier
+\subsection{\code{DSLiteServer$workspace_save()}}{
+  Save the session's workspace image identified by the \code{sid} identifier
 with the provided \code{name} in the \code{home} folder.
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{DSLiteServer$workspace_save(sid, name)}\if{html}{\out{</div>}}
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{DSLiteServer$workspace_save(sid, name)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{sid, }}{Session ID}
+      \item{\code{name}}{The name to be given to the workspace's image.}
+    }
+    \if{html}{\out{</div>}}
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{sid, }}{Session ID}
-
-\item{\code{name}}{The name to be given to the workspace's image.}
-}
-\if{html}{\out{</div>}}
-}
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-DSLiteServer-workspace_restore"></a>}}
 \if{latex}{\out{\hypertarget{method-DSLiteServer-workspace_restore}{}}}
-\subsection{Method \code{workspace_restore()}}{
-Restore a saved session's workspace image into the session identified by the \code{sid} identifier
+\subsection{\code{DSLiteServer$workspace_restore()}}{
+  Restore a saved session's workspace image into the session identified by the \code{sid} identifier
 with the provided \code{name} in the \code{home} folder.
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{DSLiteServer$workspace_restore(sid, name)}\if{html}{\out{</div>}}
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{DSLiteServer$workspace_restore(sid, name)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{sid, }}{Session ID}
+      \item{\code{name}}{The name of the workspace's image to restore.}
+    }
+    \if{html}{\out{</div>}}
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{sid, }}{Session ID}
-
-\item{\code{name}}{The name of the workspace's image to restore.}
-}
-\if{html}{\out{</div>}}
-}
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-DSLiteServer-workspace_rm"></a>}}
 \if{latex}{\out{\hypertarget{method-DSLiteServer-workspace_rm}{}}}
-\subsection{Method \code{workspace_rm()}}{
-Remove the workspace image with the provided \code{name} from the \code{home} folder.
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{DSLiteServer$workspace_rm(name)}\if{html}{\out{</div>}}
+\subsection{\code{DSLiteServer$workspace_rm()}}{
+  Remove the workspace image with the provided \code{name} from the \code{home} folder.
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{DSLiteServer$workspace_rm(name)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{name}}{The name of the workspace.}
+    }
+    \if{html}{\out{</div>}}
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{name}}{The name of the workspace.}
-}
-\if{html}{\out{</div>}}
-}
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-DSLiteServer-aggregateMethods"></a>}}
 \if{latex}{\out{\hypertarget{method-DSLiteServer-aggregateMethods}{}}}
-\subsection{Method \code{aggregateMethods()}}{
-Get or set the aggregate methods.
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{DSLiteServer$aggregateMethods(value)}\if{html}{\out{</div>}}
-}
-
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{value}}{A \code{data.frame} with columns: \code{name} (the client function call),
+\subsection{\code{DSLiteServer$aggregateMethods()}}{
+  Get or set the aggregate methods.
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{DSLiteServer$aggregateMethods(value)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{value}}{A \code{data.frame} with columns: \code{name} (the client function call),
 \code{value} (the translated server call), \code{package} (relevant when extracted from a DataSHIELD server-side package),
 \code{version} (relevant when extracted from a DataSHIELD server-side package), \code{type} ("aggregate"),
 \code{class} ("function" for package functions or "script" for custom scripts).}
+    }
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Returns}{
+    The aggregate methods when no parameter is provided.
+  }
 }
-\if{html}{\out{</div>}}
-}
-\subsection{Returns}{
-The aggregate methods when no parameter is provided.
-}
-}
+
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-DSLiteServer-aggregateMethod"></a>}}
 \if{latex}{\out{\hypertarget{method-DSLiteServer-aggregateMethod}{}}}
-\subsection{Method \code{aggregateMethod()}}{
-Get or set an aggregate method.
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{DSLiteServer$aggregateMethod(name, value)}\if{html}{\out{</div>}}
+\subsection{\code{DSLiteServer$aggregateMethod()}}{
+  Get or set an aggregate method.
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{DSLiteServer$aggregateMethod(name, value)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{name}}{The client function call.}
+      \item{\code{value}}{The translated server call: either a package function reference or function expression. Remove the method when \code{NULL}.}
+    }
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Returns}{
+    The aggregate method when no \code{value} parameter is provided.
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{name}}{The client function call.}
-
-\item{\code{value}}{The translated server call: either a package function reference or function expression. Remove the method when \code{NULL}.}
-}
-\if{html}{\out{</div>}}
-}
-\subsection{Returns}{
-The aggregate method when no \code{value} parameter is provided.
-}
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-DSLiteServer-assignMethods"></a>}}
 \if{latex}{\out{\hypertarget{method-DSLiteServer-assignMethods}{}}}
-\subsection{Method \code{assignMethods()}}{
-Get or set the assign methods.
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{DSLiteServer$assignMethods(value)}\if{html}{\out{</div>}}
-}
-
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{value}}{A \code{data.frame} with columns: \code{name} (the client function call), \code{value} (the translated server call),
+\subsection{\code{DSLiteServer$assignMethods()}}{
+  Get or set the assign methods.
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{DSLiteServer$assignMethods(value)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{value}}{A \code{data.frame} with columns: \code{name} (the client function call), \code{value} (the translated server call),
 \code{package} (relevant when extracted from a DataSHIELD server-side package), \code{version} (relevant when extracted from a DataSHIELD server-side package),
 \code{type} ("assign"), \code{class} ("function" for package functions or "script" for custom scripts).}
+    }
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Returns}{
+    The assign methods when no parameter is provided.
+  }
 }
-\if{html}{\out{</div>}}
-}
-\subsection{Returns}{
-The assign methods when no parameter is provided.
-}
-}
+
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-DSLiteServer-assignMethod"></a>}}
 \if{latex}{\out{\hypertarget{method-DSLiteServer-assignMethod}{}}}
-\subsection{Method \code{assignMethod()}}{
-Get or set an assign method.
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{DSLiteServer$assignMethod(name, value)}\if{html}{\out{</div>}}
+\subsection{\code{DSLiteServer$assignMethod()}}{
+  Get or set an assign method.
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{DSLiteServer$assignMethod(name, value)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{name}}{The client function call}
+      \item{\code{value}}{The translated server call: either a package function reference or function expression. Remove the method when \code{NULL}.}
+    }
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Returns}{
+    The assign method when no \code{value} parameter is provided.
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{name}}{The client function call}
-
-\item{\code{value}}{The translated server call: either a package function reference or function expression. Remove the method when \code{NULL}.}
-}
-\if{html}{\out{</div>}}
-}
-\subsection{Returns}{
-The assign method when no \code{value} parameter is provided.
-}
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-DSLiteServer-options"></a>}}
 \if{latex}{\out{\hypertarget{method-DSLiteServer-options}{}}}
-\subsection{Method \code{options()}}{
-Get or set the DataSHIELD R options that are applied when a new DataSHIELD session is started.
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{DSLiteServer$options(value)}\if{html}{\out{</div>}}
+\subsection{\code{DSLiteServer$options()}}{
+  Get or set the DataSHIELD R options that are applied when a new DataSHIELD session is started.
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{DSLiteServer$options(value)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{value}}{A named list of options.}
+    }
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Returns}{
+    The R options when no parameter is provided.
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{value}}{A named list of options.}
-}
-\if{html}{\out{</div>}}
-}
-\subsection{Returns}{
-The R options when no parameter is provided.
-}
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-DSLiteServer-option"></a>}}
 \if{latex}{\out{\hypertarget{method-DSLiteServer-option}{}}}
-\subsection{Method \code{option()}}{
-Get or set a R option.
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{DSLiteServer$option(key, value)}\if{html}{\out{</div>}}
+\subsection{\code{DSLiteServer$option()}}{
+  Get or set a R option.
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{DSLiteServer$option(key, value)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{key}}{The R option's name.}
+      \item{\code{value}}{The R option's value. Remove the option when \code{NULL}.}
+    }
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Returns}{
+    The R option's value when only \code{key} parameter is provided.
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{key}}{The R option's name.}
-
-\item{\code{value}}{The R option's value. Remove the option when \code{NULL}.}
-}
-\if{html}{\out{</div>}}
-}
-\subsection{Returns}{
-The R option's value when only \code{key} parameter is provided.
-}
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-DSLiteServer-newSession"></a>}}
 \if{latex}{\out{\hypertarget{method-DSLiteServer-newSession}{}}}
-\subsection{Method \code{newSession()}}{
-Create a new DataSHIELD session (contained execution environment), apply options that are defined
+\subsection{\code{DSLiteServer$newSession()}}{
+  Create a new DataSHIELD session (contained execution environment), apply options that are defined
 in the DataSHIELD configuration and restore workspace image if \code{restore} workspace name argument is provided.
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{DSLiteServer$newSession(restore = NULL, profile = NULL)}\if{html}{\out{</div>}}
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{DSLiteServer$newSession(restore = NULL, profile = NULL)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{restore}}{The workspace image to be restored (optional).}
+      \item{\code{profile}}{The requested profile name (optional). If provided, new session creation will fail in case it does not match the server's profile name.}
+    }
+    \if{html}{\out{</div>}}
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{restore}}{The workspace image to be restored (optional).}
-
-\item{\code{profile}}{The requested profile name (optional). If provided, new session creation will fail in case it does not match the server's profile name.}
-}
-\if{html}{\out{</div>}}
-}
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-DSLiteServer-hasSession"></a>}}
 \if{latex}{\out{\hypertarget{method-DSLiteServer-hasSession}{}}}
-\subsection{Method \code{hasSession()}}{
-Check a DataSHIELD session is alive.
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{DSLiteServer$hasSession(sid)}\if{html}{\out{</div>}}
+\subsection{\code{DSLiteServer$hasSession()}}{
+  Check a DataSHIELD session is alive.
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{DSLiteServer$hasSession(sid)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{sid}}{The session ID.}
+    }
+    \if{html}{\out{</div>}}
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{sid}}{The session ID.}
-}
-\if{html}{\out{</div>}}
-}
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-DSLiteServer-getSession"></a>}}
 \if{latex}{\out{\hypertarget{method-DSLiteServer-getSession}{}}}
-\subsection{Method \code{getSession()}}{
-Get the DataSHIELD session's environment.
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{DSLiteServer$getSession(sid)}\if{html}{\out{</div>}}
+\subsection{\code{DSLiteServer$getSession()}}{
+  Get the DataSHIELD session's environment.
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{DSLiteServer$getSession(sid)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{sid}}{The session ID.}
+    }
+    \if{html}{\out{</div>}}
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{sid}}{The session ID.}
-}
-\if{html}{\out{</div>}}
-}
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-DSLiteServer-getSessionIds"></a>}}
 \if{latex}{\out{\hypertarget{method-DSLiteServer-getSessionIds}{}}}
-\subsection{Method \code{getSessionIds()}}{
-Get the DataSHIELD session IDs.
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{DSLiteServer$getSessionIds()}\if{html}{\out{</div>}}
+\subsection{\code{DSLiteServer$getSessionIds()}}{
+  Get the DataSHIELD session IDs.
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{DSLiteServer$getSessionIds()}
+    \if{html}{\out{</div>}}
+  }
 }
 
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-DSLiteServer-getSessionData"></a>}}
 \if{latex}{\out{\hypertarget{method-DSLiteServer-getSessionData}{}}}
-\subsection{Method \code{getSessionData()}}{
-Get the symbol value from the DataSHIELD session's environment.
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{DSLiteServer$getSessionData(sid, symbol)}\if{html}{\out{</div>}}
+\subsection{\code{DSLiteServer$getSessionData()}}{
+  Get the symbol value from the DataSHIELD session's environment.
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{DSLiteServer$getSessionData(sid, symbol)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{sid}}{The session ID.}
+      \item{\code{symbol}}{The symbol name.}
+    }
+    \if{html}{\out{</div>}}
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{sid}}{The session ID.}
-
-\item{\code{symbol}}{The symbol name.}
-}
-\if{html}{\out{</div>}}
-}
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-DSLiteServer-closeSession"></a>}}
 \if{latex}{\out{\hypertarget{method-DSLiteServer-closeSession}{}}}
-\subsection{Method \code{closeSession()}}{
-Destroy DataSHIELD session and save workspace image if \code{save} workspace name argument is provided.
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{DSLiteServer$closeSession(sid, save = NULL)}\if{html}{\out{</div>}}
+\subsection{\code{DSLiteServer$closeSession()}}{
+  Destroy DataSHIELD session and save workspace image if \code{save} workspace name argument is provided.
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{DSLiteServer$closeSession(sid, save = NULL)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{sid}}{The session ID.}
+      \item{\code{save}}{The name of the workspace image to be saved (optional).}
+    }
+    \if{html}{\out{</div>}}
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{sid}}{The session ID.}
-
-\item{\code{save}}{The name of the workspace image to be saved (optional).}
-}
-\if{html}{\out{</div>}}
-}
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-DSLiteServer-tableNames"></a>}}
 \if{latex}{\out{\hypertarget{method-DSLiteServer-tableNames}{}}}
-\subsection{Method \code{tableNames()}}{
-List the names of the tables that can be assigned.
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{DSLiteServer$tableNames()}\if{html}{\out{</div>}}
+\subsection{\code{DSLiteServer$tableNames()}}{
+  List the names of the tables that can be assigned.
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{DSLiteServer$tableNames()}
+    \if{html}{\out{</div>}}
+  }
 }
 
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-DSLiteServer-hasTable"></a>}}
 \if{latex}{\out{\hypertarget{method-DSLiteServer-hasTable}{}}}
-\subsection{Method \code{hasTable()}}{
-Check a table exists.
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{DSLiteServer$hasTable(name)}\if{html}{\out{</div>}}
+\subsection{\code{DSLiteServer$hasTable()}}{
+  Check a table exists.
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{DSLiteServer$hasTable(name)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{name}}{The table name to be looked for.}
+    }
+    \if{html}{\out{</div>}}
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{name}}{The table name to be looked for.}
-}
-\if{html}{\out{</div>}}
-}
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-DSLiteServer-resourceNames"></a>}}
 \if{latex}{\out{\hypertarget{method-DSLiteServer-resourceNames}{}}}
-\subsection{Method \code{resourceNames()}}{
-List the names of the resources (\code{resourcer::Resource} objects) that can be assigned.
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{DSLiteServer$resourceNames()}\if{html}{\out{</div>}}
+\subsection{\code{DSLiteServer$resourceNames()}}{
+  List the names of the resources (\code{resourcer::Resource} objects) that can be assigned.
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{DSLiteServer$resourceNames()}
+    \if{html}{\out{</div>}}
+  }
 }
 
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-DSLiteServer-hasResource"></a>}}
 \if{latex}{\out{\hypertarget{method-DSLiteServer-hasResource}{}}}
-\subsection{Method \code{hasResource()}}{
-Check a resource (\code{resourcer::Resource} object) exists.
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{DSLiteServer$hasResource(name)}\if{html}{\out{</div>}}
+\subsection{\code{DSLiteServer$hasResource()}}{
+  Check a resource (\code{resourcer::Resource} object) exists.
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{DSLiteServer$hasResource(name)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{name}}{The resource name to be looked for.}
+    }
+    \if{html}{\out{</div>}}
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{name}}{The resource name to be looked for.}
-}
-\if{html}{\out{</div>}}
-}
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-DSLiteServer-symbols"></a>}}
 \if{latex}{\out{\hypertarget{method-DSLiteServer-symbols}{}}}
-\subsection{Method \code{symbols()}}{
-List the symbols living in a DataSHIELD session.
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{DSLiteServer$symbols(sid)}\if{html}{\out{</div>}}
+\subsection{\code{DSLiteServer$symbols()}}{
+  List the symbols living in a DataSHIELD session.
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{DSLiteServer$symbols(sid)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{sid}}{The session ID.}
+    }
+    \if{html}{\out{</div>}}
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{sid}}{The session ID.}
-}
-\if{html}{\out{</div>}}
-}
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-DSLiteServer-symbol_rm"></a>}}
 \if{latex}{\out{\hypertarget{method-DSLiteServer-symbol_rm}{}}}
-\subsection{Method \code{symbol_rm()}}{
-Remove a symbol from a DataSHIELD session.
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{DSLiteServer$symbol_rm(sid, name)}\if{html}{\out{</div>}}
+\subsection{\code{DSLiteServer$symbol_rm()}}{
+  Remove a symbol from a DataSHIELD session.
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{DSLiteServer$symbol_rm(sid, name)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{sid}}{The session ID.}
+      \item{\code{name}}{The symbol name.}
+    }
+    \if{html}{\out{</div>}}
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{sid}}{The session ID.}
-
-\item{\code{name}}{The symbol name.}
-}
-\if{html}{\out{</div>}}
-}
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-DSLiteServer-assignTable"></a>}}
 \if{latex}{\out{\hypertarget{method-DSLiteServer-assignTable}{}}}
-\subsection{Method \code{assignTable()}}{
-Assign a table to a symbol in a DataSHIELD session. Filter
+\subsection{\code{DSLiteServer$assignTable()}}{
+  Assign a table to a symbol in a DataSHIELD session. Filter
 table columns with the variables names provided.
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{DSLiteServer$assignTable(sid, symbol, name, variables = NULL, id.name = NULL)}\if{html}{\out{</div>}}
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{DSLiteServer$assignTable(sid, symbol, name, variables = NULL, id.name = NULL)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{sid}}{The session ID.}
+      \item{\code{symbol}}{The symbol to be assigned.}
+      \item{\code{name}}{The table's name.}
+      \item{\code{variables}}{The variable names to be filtered in (optional).}
+      \item{\code{id.name}}{The column name to be used for the entity's identifier (optional).}
+    }
+    \if{html}{\out{</div>}}
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{sid}}{The session ID.}
-
-\item{\code{symbol}}{The symbol to be assigned.}
-
-\item{\code{name}}{The table's name.}
-
-\item{\code{variables}}{The variable names to be filtered in (optional).}
-
-\item{\code{id.name}}{The column name to be used for the entity's identifier (optional).}
-}
-\if{html}{\out{</div>}}
-}
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-DSLiteServer-assignResource"></a>}}
 \if{latex}{\out{\hypertarget{method-DSLiteServer-assignResource}{}}}
-\subsection{Method \code{assignResource()}}{
-Assign a resource as a \code{resourcer::ResourceClient} object to a symbol in a DataSHIELD session.
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{DSLiteServer$assignResource(sid, symbol, name)}\if{html}{\out{</div>}}
+\subsection{\code{DSLiteServer$assignResource()}}{
+  Assign a resource as a \code{resourcer::ResourceClient} object to a symbol in a DataSHIELD session.
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{DSLiteServer$assignResource(sid, symbol, name)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{sid}}{The session ID.}
+      \item{\code{symbol}}{The symbol name.}
+      \item{\code{name}}{The name of the resource.}
+    }
+    \if{html}{\out{</div>}}
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{sid}}{The session ID.}
-
-\item{\code{symbol}}{The symbol name.}
-
-\item{\code{name}}{The name of the resource.}
-}
-\if{html}{\out{</div>}}
-}
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-DSLiteServer-assignExpr"></a>}}
 \if{latex}{\out{\hypertarget{method-DSLiteServer-assignExpr}{}}}
-\subsection{Method \code{assignExpr()}}{
-Evaluate an assignment expression in a DataSHIELD session.
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{DSLiteServer$assignExpr(sid, symbol, expr)}\if{html}{\out{</div>}}
+\subsection{\code{DSLiteServer$assignExpr()}}{
+  Evaluate an assignment expression in a DataSHIELD session.
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{DSLiteServer$assignExpr(sid, symbol, expr)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{sid}}{The session ID.}
+      \item{\code{symbol}}{The symbol name.}
+      \item{\code{expr}}{The R expression to evaluate.}
+    }
+    \if{html}{\out{</div>}}
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{sid}}{The session ID.}
-
-\item{\code{symbol}}{The symbol name.}
-
-\item{\code{expr}}{The R expression to evaluate.}
-}
-\if{html}{\out{</div>}}
-}
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-DSLiteServer-aggregate"></a>}}
 \if{latex}{\out{\hypertarget{method-DSLiteServer-aggregate}{}}}
-\subsection{Method \code{aggregate()}}{
-Evaluate an aggregate expression in a DataSHIELD session.
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{DSLiteServer$aggregate(sid, expr)}\if{html}{\out{</div>}}
+\subsection{\code{DSLiteServer$aggregate()}}{
+  Evaluate an aggregate expression in a DataSHIELD session.
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{DSLiteServer$aggregate(sid, expr)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{sid}}{The session ID.}
+      \item{\code{expr}}{The R expression to evaluate.}
+    }
+    \if{html}{\out{</div>}}
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{sid}}{The session ID.}
-
-\item{\code{expr}}{The R expression to evaluate.}
-}
-\if{html}{\out{</div>}}
-}
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-DSLiteServer-clone"></a>}}
 \if{latex}{\out{\hypertarget{method-DSLiteServer-clone}{}}}
-\subsection{Method \code{clone()}}{
-The objects of this class are cloneable with this method.
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{DSLiteServer$clone(deep = FALSE)}\if{html}{\out{</div>}}
+\subsection{\code{DSLiteServer$clone()}}{
+  The objects of this class are cloneable with this method.
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{DSLiteServer$clone(deep = FALSE)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{deep}}{Whether to make a deep clone.}
+    }
+    \if{html}{\out{</div>}}
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{deep}}{Whether to make a deep clone.}
-}
-\if{html}{\out{</div>}}
-}
-}
 }
diff --git a/man/FormulaNode.Rd b/man/FormulaNode.Rd
index d6efe71..11eb7e2 100644
--- a/man/FormulaNode.Rd
+++ b/man/FormulaNode.Rd
@@ -8,7 +8,7 @@
 AST node that reprsents a formula (such as NAME ~ \emph{terms}).
 }
 \seealso{
-Other parser items: 
+Other parser items:
 \code{\link{BinaryOpNode}},
 \code{\link{FunctionNode}},
 \code{\link{GroupNode}},
@@ -22,68 +22,72 @@ Other parser items:
 }
 \concept{parser items}
 \section{Super class}{
-\code{\link[DSLite:Node]{DSLite::Node}} -> \code{FormulaNode}
+\code{\link[DSLite:Node]{Node}} -> \code{FormulaNode}
 }
 \section{Methods}{
 \subsection{Public methods}{
-\itemize{
-\item \href{#method-FormulaNode-add_child}{\code{FormulaNode$add_child()}}
-\item \href{#method-FormulaNode-to_string}{\code{FormulaNode$to_string()}}
-\item \href{#method-FormulaNode-clone}{\code{FormulaNode$clone()}}
+  \itemize{
+    \item \href{#method-FormulaNode-add_child}{\code{FormulaNode$add_child()}}
+    \item \href{#method-FormulaNode-to_string}{\code{FormulaNode$to_string()}}
+    \item \href{#method-FormulaNode-clone}{\code{FormulaNode$clone()}}
+  }
 }
-}
-\if{html}{\out{
-<details open><summary>Inherited methods</summary>
+\if{html}{\out{<details open><summary>Inherited methods</summary>
 <ul>
-<li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="accept"><a href='../../DSLite/html/Node.html#method-Node-accept'><code>DSLite::Node$accept()</code></a></span></li>
-<li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="initialize"><a href='../../DSLite/html/Node.html#method-Node-initialize'><code>DSLite::Node$initialize()</code></a></span></li>
-<li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="set_parent"><a href='../../DSLite/html/Node.html#method-Node-set_parent'><code>DSLite::Node$set_parent()</code></a></span></li>
-<li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="to_string_children"><a href='../../DSLite/html/Node.html#method-Node-to_string_children'><code>DSLite::Node$to_string_children()</code></a></span></li>
+  <li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="accept"><a href='../../DSLite/html/Node.html#method-Node-accept'><code>Node$accept()</code></a></span></li>
+  <li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="initialize"><a href='../../DSLite/html/Node.html#method-Node-initialize'><code>Node$initialize()</code></a></span></li>
+  <li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="set_parent"><a href='../../DSLite/html/Node.html#method-Node-set_parent'><code>Node$set_parent()</code></a></span></li>
+  <li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="to_string_children"><a href='../../DSLite/html/Node.html#method-Node-to_string_children'><code>Node$to_string_children()</code></a></span></li>
 </ul>
-</details>
-}}
+</details>}}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-FormulaNode-add_child"></a>}}
 \if{latex}{\out{\hypertarget{method-FormulaNode-add_child}{}}}
-\subsection{Method \code{add_child()}}{
-Two children
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{FormulaNode$add_child(val)}\if{html}{\out{</div>}}
+\subsection{\code{FormulaNode$add_child()}}{
+  Two children
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{FormulaNode$add_child(val)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{val}}{Child Node}
+    }
+    \if{html}{\out{</div>}}
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{val}}{Child Node}
-}
-\if{html}{\out{</div>}}
-}
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-FormulaNode-to_string"></a>}}
 \if{latex}{\out{\hypertarget{method-FormulaNode-to_string}{}}}
-\subsection{Method \code{to_string()}}{
-Get the string representation of the BinaryOpNode
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{FormulaNode$to_string()}\if{html}{\out{</div>}}
+\subsection{\code{FormulaNode$to_string()}}{
+  Get the string representation of the BinaryOpNode
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{FormulaNode$to_string()}
+    \if{html}{\out{</div>}}
+  }
 }
 
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-FormulaNode-clone"></a>}}
 \if{latex}{\out{\hypertarget{method-FormulaNode-clone}{}}}
-\subsection{Method \code{clone()}}{
-The objects of this class are cloneable with this method.
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{FormulaNode$clone(deep = FALSE)}\if{html}{\out{</div>}}
+\subsection{\code{FormulaNode$clone()}}{
+  The objects of this class are cloneable with this method.
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{FormulaNode$clone(deep = FALSE)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{deep}}{Whether to make a deep clone.}
+    }
+    \if{html}{\out{</div>}}
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{deep}}{Whether to make a deep clone.}
-}
-\if{html}{\out{</div>}}
-}
-}
 }
diff --git a/man/FunctionNode.Rd b/man/FunctionNode.Rd
index e1dbaf6..db90f0b 100644
--- a/man/FunctionNode.Rd
+++ b/man/FunctionNode.Rd
@@ -8,7 +8,7 @@
 AST node that represents a function with its arguments.
 }
 \seealso{
-Other parser items: 
+Other parser items:
 \code{\link{BinaryOpNode}},
 \code{\link{FormulaNode}},
 \code{\link{GroupNode}},
@@ -22,51 +22,53 @@ Other parser items:
 }
 \concept{parser items}
 \section{Super class}{
-\code{\link[DSLite:Node]{DSLite::Node}} -> \code{FunctionNode}
+\code{\link[DSLite:Node]{Node}} -> \code{FunctionNode}
 }
 \section{Methods}{
 \subsection{Public methods}{
-\itemize{
-\item \href{#method-FunctionNode-to_string}{\code{FunctionNode$to_string()}}
-\item \href{#method-FunctionNode-clone}{\code{FunctionNode$clone()}}
+  \itemize{
+    \item \href{#method-FunctionNode-to_string}{\code{FunctionNode$to_string()}}
+    \item \href{#method-FunctionNode-clone}{\code{FunctionNode$clone()}}
+  }
 }
-}
-\if{html}{\out{
-<details open><summary>Inherited methods</summary>
+\if{html}{\out{<details open><summary>Inherited methods</summary>
 <ul>
-<li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="accept"><a href='../../DSLite/html/Node.html#method-Node-accept'><code>DSLite::Node$accept()</code></a></span></li>
-<li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="add_child"><a href='../../DSLite/html/Node.html#method-Node-add_child'><code>DSLite::Node$add_child()</code></a></span></li>
-<li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="initialize"><a href='../../DSLite/html/Node.html#method-Node-initialize'><code>DSLite::Node$initialize()</code></a></span></li>
-<li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="set_parent"><a href='../../DSLite/html/Node.html#method-Node-set_parent'><code>DSLite::Node$set_parent()</code></a></span></li>
-<li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="to_string_children"><a href='../../DSLite/html/Node.html#method-Node-to_string_children'><code>DSLite::Node$to_string_children()</code></a></span></li>
+  <li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="accept"><a href='../../DSLite/html/Node.html#method-Node-accept'><code>Node$accept()</code></a></span></li>
+  <li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="add_child"><a href='../../DSLite/html/Node.html#method-Node-add_child'><code>Node$add_child()</code></a></span></li>
+  <li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="initialize"><a href='../../DSLite/html/Node.html#method-Node-initialize'><code>Node$initialize()</code></a></span></li>
+  <li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="set_parent"><a href='../../DSLite/html/Node.html#method-Node-set_parent'><code>Node$set_parent()</code></a></span></li>
+  <li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="to_string_children"><a href='../../DSLite/html/Node.html#method-Node-to_string_children'><code>Node$to_string_children()</code></a></span></li>
 </ul>
-</details>
-}}
+</details>}}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-FunctionNode-to_string"></a>}}
 \if{latex}{\out{\hypertarget{method-FunctionNode-to_string}{}}}
-\subsection{Method \code{to_string()}}{
-Get the string representation of the FunctionNode
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{FunctionNode$to_string()}\if{html}{\out{</div>}}
+\subsection{\code{FunctionNode$to_string()}}{
+  Get the string representation of the FunctionNode
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{FunctionNode$to_string()}
+    \if{html}{\out{</div>}}
+  }
 }
 
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-FunctionNode-clone"></a>}}
 \if{latex}{\out{\hypertarget{method-FunctionNode-clone}{}}}
-\subsection{Method \code{clone()}}{
-The objects of this class are cloneable with this method.
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{FunctionNode$clone(deep = FALSE)}\if{html}{\out{</div>}}
+\subsection{\code{FunctionNode$clone()}}{
+  The objects of this class are cloneable with this method.
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{FunctionNode$clone(deep = FALSE)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{deep}}{Whether to make a deep clone.}
+    }
+    \if{html}{\out{</div>}}
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{deep}}{Whether to make a deep clone.}
-}
-\if{html}{\out{</div>}}
-}
-}
 }
diff --git a/man/GroupNode.Rd b/man/GroupNode.Rd
index a814267..a4db85a 100644
--- a/man/GroupNode.Rd
+++ b/man/GroupNode.Rd
@@ -8,7 +8,7 @@
 AST node that reprsents a group of tokens enclosed by parenthesis.
 }
 \seealso{
-Other parser items: 
+Other parser items:
 \code{\link{BinaryOpNode}},
 \code{\link{FormulaNode}},
 \code{\link{FunctionNode}},
@@ -22,51 +22,53 @@ Other parser items:
 }
 \concept{parser items}
 \section{Super class}{
-\code{\link[DSLite:Node]{DSLite::Node}} -> \code{GroupNode}
+\code{\link[DSLite:Node]{Node}} -> \code{GroupNode}
 }
 \section{Methods}{
 \subsection{Public methods}{
-\itemize{
-\item \href{#method-GroupNode-to_string}{\code{GroupNode$to_string()}}
-\item \href{#method-GroupNode-clone}{\code{GroupNode$clone()}}
+  \itemize{
+    \item \href{#method-GroupNode-to_string}{\code{GroupNode$to_string()}}
+    \item \href{#method-GroupNode-clone}{\code{GroupNode$clone()}}
+  }
 }
-}
-\if{html}{\out{
-<details open><summary>Inherited methods</summary>
+\if{html}{\out{<details open><summary>Inherited methods</summary>
 <ul>
-<li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="accept"><a href='../../DSLite/html/Node.html#method-Node-accept'><code>DSLite::Node$accept()</code></a></span></li>
-<li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="add_child"><a href='../../DSLite/html/Node.html#method-Node-add_child'><code>DSLite::Node$add_child()</code></a></span></li>
-<li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="initialize"><a href='../../DSLite/html/Node.html#method-Node-initialize'><code>DSLite::Node$initialize()</code></a></span></li>
-<li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="set_parent"><a href='../../DSLite/html/Node.html#method-Node-set_parent'><code>DSLite::Node$set_parent()</code></a></span></li>
-<li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="to_string_children"><a href='../../DSLite/html/Node.html#method-Node-to_string_children'><code>DSLite::Node$to_string_children()</code></a></span></li>
+  <li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="accept"><a href='../../DSLite/html/Node.html#method-Node-accept'><code>Node$accept()</code></a></span></li>
+  <li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="add_child"><a href='../../DSLite/html/Node.html#method-Node-add_child'><code>Node$add_child()</code></a></span></li>
+  <li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="initialize"><a href='../../DSLite/html/Node.html#method-Node-initialize'><code>Node$initialize()</code></a></span></li>
+  <li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="set_parent"><a href='../../DSLite/html/Node.html#method-Node-set_parent'><code>Node$set_parent()</code></a></span></li>
+  <li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="to_string_children"><a href='../../DSLite/html/Node.html#method-Node-to_string_children'><code>Node$to_string_children()</code></a></span></li>
 </ul>
-</details>
-}}
+</details>}}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-GroupNode-to_string"></a>}}
 \if{latex}{\out{\hypertarget{method-GroupNode-to_string}{}}}
-\subsection{Method \code{to_string()}}{
-Get the string representation of the GroupNode
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{GroupNode$to_string()}\if{html}{\out{</div>}}
+\subsection{\code{GroupNode$to_string()}}{
+  Get the string representation of the GroupNode
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{GroupNode$to_string()}
+    \if{html}{\out{</div>}}
+  }
 }
 
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-GroupNode-clone"></a>}}
 \if{latex}{\out{\hypertarget{method-GroupNode-clone}{}}}
-\subsection{Method \code{clone()}}{
-The objects of this class are cloneable with this method.
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{GroupNode$clone(deep = FALSE)}\if{html}{\out{</div>}}
+\subsection{\code{GroupNode$clone()}}{
+  The objects of this class are cloneable with this method.
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{GroupNode$clone(deep = FALSE)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{deep}}{Whether to make a deep clone.}
+    }
+    \if{html}{\out{</div>}}
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{deep}}{Whether to make a deep clone.}
-}
-\if{html}{\out{</div>}}
-}
-}
 }
diff --git a/man/Node.Rd b/man/Node.Rd
index 0a934b2..dca87f1 100644
--- a/man/Node.Rd
+++ b/man/Node.Rd
@@ -8,7 +8,7 @@
 Abstract Syntaxic Tree (AST) node that will be created by the DSLite R parser.
 }
 \seealso{
-Other parser items: 
+Other parser items:
 \code{\link{BinaryOpNode}},
 \code{\link{FormulaNode}},
 \code{\link{FunctionNode}},
@@ -22,136 +22,149 @@ Other parser items:
 }
 \concept{parser items}
 \section{Public fields}{
-\if{html}{\out{<div class="r6-fields">}}
-\describe{
-\item{\code{name}}{Token value}
+  \if{html}{\out{<div class="r6-fields">}}
+  \describe{
+    \item{\code{name}}{Token value}
 
-\item{\code{parent}}{Parent Node}
+    \item{\code{parent}}{Parent Node}
 
-\item{\code{children}}{Children Nodes}
-}
-\if{html}{\out{</div>}}
+    \item{\code{children}}{Children Nodes}
+  }
+  \if{html}{\out{</div>}}
 }
 \section{Methods}{
 \subsection{Public methods}{
-\itemize{
-\item \href{#method-Node-new}{\code{Node$new()}}
-\item \href{#method-Node-set_parent}{\code{Node$set_parent()}}
-\item \href{#method-Node-add_child}{\code{Node$add_child()}}
-\item \href{#method-Node-to_string}{\code{Node$to_string()}}
-\item \href{#method-Node-to_string_children}{\code{Node$to_string_children()}}
-\item \href{#method-Node-accept}{\code{Node$accept()}}
-\item \href{#method-Node-clone}{\code{Node$clone()}}
-}
+  \itemize{
+    \item \href{#method-Node-initialize}{\code{Node$new()}}
+    \item \href{#method-Node-set_parent}{\code{Node$set_parent()}}
+    \item \href{#method-Node-add_child}{\code{Node$add_child()}}
+    \item \href{#method-Node-to_string}{\code{Node$to_string()}}
+    \item \href{#method-Node-to_string_children}{\code{Node$to_string_children()}}
+    \item \href{#method-Node-accept}{\code{Node$accept()}}
+    \item \href{#method-Node-clone}{\code{Node$clone()}}
+  }
 }
 \if{html}{\out{<hr>}}
-\if{html}{\out{<a id="method-Node-new"></a>}}
-\if{latex}{\out{\hypertarget{method-Node-new}{}}}
-\subsection{Method \code{new()}}{
-Simple node constructor
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{Node$new(name = NA, parent = NA)}\if{html}{\out{</div>}}
+\if{html}{\out{<a id="method-Node-initialize"></a>}}
+\if{latex}{\out{\hypertarget{method-Node-initialize}{}}}
+\subsection{\code{Node$new()}}{
+  Simple node constructor
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{Node$new(name = NA, parent = NA)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{name}}{Token value}
+      \item{\code{parent}}{Parent Node}
+    }
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Returns}{
+    A Node object
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{name}}{Token value}
-
-\item{\code{parent}}{Parent Node}
-}
-\if{html}{\out{</div>}}
-}
-\subsection{Returns}{
-A Node object
-}
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-Node-set_parent"></a>}}
 \if{latex}{\out{\hypertarget{method-Node-set_parent}{}}}
-\subsection{Method \code{set_parent()}}{
-Set parent Node
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{Node$set_parent(val)}\if{html}{\out{</div>}}
+\subsection{\code{Node$set_parent()}}{
+  Set parent Node
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{Node$set_parent(val)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{val}}{Parent Node}
+    }
+    \if{html}{\out{</div>}}
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{val}}{Parent Node}
-}
-\if{html}{\out{</div>}}
-}
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-Node-add_child"></a>}}
 \if{latex}{\out{\hypertarget{method-Node-add_child}{}}}
-\subsection{Method \code{add_child()}}{
-Add a child Node
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{Node$add_child(val)}\if{html}{\out{</div>}}
+\subsection{\code{Node$add_child()}}{
+  Add a child Node
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{Node$add_child(val)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{val}}{Child Node}
+    }
+    \if{html}{\out{</div>}}
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{val}}{Child Node}
-}
-\if{html}{\out{</div>}}
-}
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-Node-to_string"></a>}}
 \if{latex}{\out{\hypertarget{method-Node-to_string}{}}}
-\subsection{Method \code{to_string()}}{
-The string representation of the Node
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{Node$to_string()}\if{html}{\out{</div>}}
+\subsection{\code{Node$to_string()}}{
+  The string representation of the Node
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{Node$to_string()}
+    \if{html}{\out{</div>}}
+  }
 }
 
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-Node-to_string_children"></a>}}
 \if{latex}{\out{\hypertarget{method-Node-to_string_children}{}}}
-\subsection{Method \code{to_string_children()}}{
-Get the string representation of the Node's children
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{Node$to_string_children()}\if{html}{\out{</div>}}
+\subsection{\code{Node$to_string_children()}}{
+  Get the string representation of the Node's children
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{Node$to_string_children()}
+    \if{html}{\out{</div>}}
+  }
 }
 
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-Node-accept"></a>}}
 \if{latex}{\out{\hypertarget{method-Node-accept}{}}}
-\subsection{Method \code{accept()}}{
-Accept visitor
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{Node$accept(visitor)}\if{html}{\out{</div>}}
+\subsection{\code{Node$accept()}}{
+  Accept visitor
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{Node$accept(visitor)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{visitor}}{Node visitor object}
+    }
+    \if{html}{\out{</div>}}
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{visitor}}{Node visitor object}
-}
-\if{html}{\out{</div>}}
-}
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-Node-clone"></a>}}
 \if{latex}{\out{\hypertarget{method-Node-clone}{}}}
-\subsection{Method \code{clone()}}{
-The objects of this class are cloneable with this method.
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{Node$clone(deep = FALSE)}\if{html}{\out{</div>}}
+\subsection{\code{Node$clone()}}{
+  The objects of this class are cloneable with this method.
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{Node$clone(deep = FALSE)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{deep}}{Whether to make a deep clone.}
+    }
+    \if{html}{\out{</div>}}
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{deep}}{Whether to make a deep clone.}
-}
-\if{html}{\out{</div>}}
-}
-}
 }
diff --git a/man/NumericNode.Rd b/man/NumericNode.Rd
index b65852a..fdd8d87 100644
--- a/man/NumericNode.Rd
+++ b/man/NumericNode.Rd
@@ -8,7 +8,7 @@
 AST node that reprsents a numeric (integer or float) value.
 }
 \seealso{
-Other parser items: 
+Other parser items:
 \code{\link{BinaryOpNode}},
 \code{\link{FormulaNode}},
 \code{\link{FunctionNode}},
@@ -22,68 +22,72 @@ Other parser items:
 }
 \concept{parser items}
 \section{Super class}{
-\code{\link[DSLite:Node]{DSLite::Node}} -> \code{NumericNode}
+\code{\link[DSLite:Node]{Node}} -> \code{NumericNode}
 }
 \section{Methods}{
 \subsection{Public methods}{
-\itemize{
-\item \href{#method-NumericNode-add_child}{\code{NumericNode$add_child()}}
-\item \href{#method-NumericNode-to_string}{\code{NumericNode$to_string()}}
-\item \href{#method-NumericNode-clone}{\code{NumericNode$clone()}}
+  \itemize{
+    \item \href{#method-NumericNode-add_child}{\code{NumericNode$add_child()}}
+    \item \href{#method-NumericNode-to_string}{\code{NumericNode$to_string()}}
+    \item \href{#method-NumericNode-clone}{\code{NumericNode$clone()}}
+  }
 }
-}
-\if{html}{\out{
-<details open><summary>Inherited methods</summary>
+\if{html}{\out{<details open><summary>Inherited methods</summary>
 <ul>
-<li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="accept"><a href='../../DSLite/html/Node.html#method-Node-accept'><code>DSLite::Node$accept()</code></a></span></li>
-<li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="initialize"><a href='../../DSLite/html/Node.html#method-Node-initialize'><code>DSLite::Node$initialize()</code></a></span></li>
-<li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="set_parent"><a href='../../DSLite/html/Node.html#method-Node-set_parent'><code>DSLite::Node$set_parent()</code></a></span></li>
-<li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="to_string_children"><a href='../../DSLite/html/Node.html#method-Node-to_string_children'><code>DSLite::Node$to_string_children()</code></a></span></li>
+  <li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="accept"><a href='../../DSLite/html/Node.html#method-Node-accept'><code>Node$accept()</code></a></span></li>
+  <li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="initialize"><a href='../../DSLite/html/Node.html#method-Node-initialize'><code>Node$initialize()</code></a></span></li>
+  <li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="set_parent"><a href='../../DSLite/html/Node.html#method-Node-set_parent'><code>Node$set_parent()</code></a></span></li>
+  <li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="to_string_children"><a href='../../DSLite/html/Node.html#method-Node-to_string_children'><code>Node$to_string_children()</code></a></span></li>
 </ul>
-</details>
-}}
+</details>}}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-NumericNode-add_child"></a>}}
 \if{latex}{\out{\hypertarget{method-NumericNode-add_child}{}}}
-\subsection{Method \code{add_child()}}{
-No children
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{NumericNode$add_child(val)}\if{html}{\out{</div>}}
+\subsection{\code{NumericNode$add_child()}}{
+  No children
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{NumericNode$add_child(val)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{val}}{Child Node}
+    }
+    \if{html}{\out{</div>}}
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{val}}{Child Node}
-}
-\if{html}{\out{</div>}}
-}
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-NumericNode-to_string"></a>}}
 \if{latex}{\out{\hypertarget{method-NumericNode-to_string}{}}}
-\subsection{Method \code{to_string()}}{
-Get the string representation of the NumericNode
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{NumericNode$to_string()}\if{html}{\out{</div>}}
+\subsection{\code{NumericNode$to_string()}}{
+  Get the string representation of the NumericNode
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{NumericNode$to_string()}
+    \if{html}{\out{</div>}}
+  }
 }
 
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-NumericNode-clone"></a>}}
 \if{latex}{\out{\hypertarget{method-NumericNode-clone}{}}}
-\subsection{Method \code{clone()}}{
-The objects of this class are cloneable with this method.
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{NumericNode$clone(deep = FALSE)}\if{html}{\out{</div>}}
+\subsection{\code{NumericNode$clone()}}{
+  The objects of this class are cloneable with this method.
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{NumericNode$clone(deep = FALSE)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{deep}}{Whether to make a deep clone.}
+    }
+    \if{html}{\out{</div>}}
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{deep}}{Whether to make a deep clone.}
-}
-\if{html}{\out{</div>}}
-}
-}
 }
diff --git a/man/ParameterNode.Rd b/man/ParameterNode.Rd
index ea174eb..9a2aba1 100644
--- a/man/ParameterNode.Rd
+++ b/man/ParameterNode.Rd
@@ -8,7 +8,7 @@
 AST node that represents a function's named parameter (such as NAME = \emph{expression}).
 }
 \seealso{
-Other parser items: 
+Other parser items:
 \code{\link{BinaryOpNode}},
 \code{\link{FormulaNode}},
 \code{\link{FunctionNode}},
@@ -22,68 +22,72 @@ Other parser items:
 }
 \concept{parser items}
 \section{Super class}{
-\code{\link[DSLite:Node]{DSLite::Node}} -> \code{ParameterNode}
+\code{\link[DSLite:Node]{Node}} -> \code{ParameterNode}
 }
 \section{Methods}{
 \subsection{Public methods}{
-\itemize{
-\item \href{#method-ParameterNode-add_child}{\code{ParameterNode$add_child()}}
-\item \href{#method-ParameterNode-to_string}{\code{ParameterNode$to_string()}}
-\item \href{#method-ParameterNode-clone}{\code{ParameterNode$clone()}}
+  \itemize{
+    \item \href{#method-ParameterNode-add_child}{\code{ParameterNode$add_child()}}
+    \item \href{#method-ParameterNode-to_string}{\code{ParameterNode$to_string()}}
+    \item \href{#method-ParameterNode-clone}{\code{ParameterNode$clone()}}
+  }
 }
-}
-\if{html}{\out{
-<details open><summary>Inherited methods</summary>
+\if{html}{\out{<details open><summary>Inherited methods</summary>
 <ul>
-<li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="accept"><a href='../../DSLite/html/Node.html#method-Node-accept'><code>DSLite::Node$accept()</code></a></span></li>
-<li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="initialize"><a href='../../DSLite/html/Node.html#method-Node-initialize'><code>DSLite::Node$initialize()</code></a></span></li>
-<li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="set_parent"><a href='../../DSLite/html/Node.html#method-Node-set_parent'><code>DSLite::Node$set_parent()</code></a></span></li>
-<li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="to_string_children"><a href='../../DSLite/html/Node.html#method-Node-to_string_children'><code>DSLite::Node$to_string_children()</code></a></span></li>
+  <li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="accept"><a href='../../DSLite/html/Node.html#method-Node-accept'><code>Node$accept()</code></a></span></li>
+  <li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="initialize"><a href='../../DSLite/html/Node.html#method-Node-initialize'><code>Node$initialize()</code></a></span></li>
+  <li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="set_parent"><a href='../../DSLite/html/Node.html#method-Node-set_parent'><code>Node$set_parent()</code></a></span></li>
+  <li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="to_string_children"><a href='../../DSLite/html/Node.html#method-Node-to_string_children'><code>Node$to_string_children()</code></a></span></li>
 </ul>
-</details>
-}}
+</details>}}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-ParameterNode-add_child"></a>}}
 \if{latex}{\out{\hypertarget{method-ParameterNode-add_child}{}}}
-\subsection{Method \code{add_child()}}{
-Two children
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{ParameterNode$add_child(val)}\if{html}{\out{</div>}}
+\subsection{\code{ParameterNode$add_child()}}{
+  Two children
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{ParameterNode$add_child(val)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{val}}{Child Node}
+    }
+    \if{html}{\out{</div>}}
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{val}}{Child Node}
-}
-\if{html}{\out{</div>}}
-}
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-ParameterNode-to_string"></a>}}
 \if{latex}{\out{\hypertarget{method-ParameterNode-to_string}{}}}
-\subsection{Method \code{to_string()}}{
-Get the string representation of the BinaryOpNode
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{ParameterNode$to_string()}\if{html}{\out{</div>}}
+\subsection{\code{ParameterNode$to_string()}}{
+  Get the string representation of the BinaryOpNode
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{ParameterNode$to_string()}
+    \if{html}{\out{</div>}}
+  }
 }
 
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-ParameterNode-clone"></a>}}
 \if{latex}{\out{\hypertarget{method-ParameterNode-clone}{}}}
-\subsection{Method \code{clone()}}{
-The objects of this class are cloneable with this method.
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{ParameterNode$clone(deep = FALSE)}\if{html}{\out{</div>}}
+\subsection{\code{ParameterNode$clone()}}{
+  The objects of this class are cloneable with this method.
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{ParameterNode$clone(deep = FALSE)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{deep}}{Whether to make a deep clone.}
+    }
+    \if{html}{\out{</div>}}
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{deep}}{Whether to make a deep clone.}
-}
-\if{html}{\out{</div>}}
-}
-}
 }
diff --git a/man/RangeNode.Rd b/man/RangeNode.Rd
index d2775b1..73601a2 100644
--- a/man/RangeNode.Rd
+++ b/man/RangeNode.Rd
@@ -8,7 +8,7 @@
 AST node that represents a range of values (such as \emph{min expression}:\emph{max expression}), therefore having two child nodes.
 }
 \seealso{
-Other parser items: 
+Other parser items:
 \code{\link{BinaryOpNode}},
 \code{\link{FormulaNode}},
 \code{\link{FunctionNode}},
@@ -22,68 +22,72 @@ Other parser items:
 }
 \concept{parser items}
 \section{Super class}{
-\code{\link[DSLite:Node]{DSLite::Node}} -> \code{RangeNode}
+\code{\link[DSLite:Node]{Node}} -> \code{RangeNode}
 }
 \section{Methods}{
 \subsection{Public methods}{
-\itemize{
-\item \href{#method-RangeNode-add_child}{\code{RangeNode$add_child()}}
-\item \href{#method-RangeNode-to_string}{\code{RangeNode$to_string()}}
-\item \href{#method-RangeNode-clone}{\code{RangeNode$clone()}}
+  \itemize{
+    \item \href{#method-RangeNode-add_child}{\code{RangeNode$add_child()}}
+    \item \href{#method-RangeNode-to_string}{\code{RangeNode$to_string()}}
+    \item \href{#method-RangeNode-clone}{\code{RangeNode$clone()}}
+  }
 }
-}
-\if{html}{\out{
-<details open><summary>Inherited methods</summary>
+\if{html}{\out{<details open><summary>Inherited methods</summary>
 <ul>
-<li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="accept"><a href='../../DSLite/html/Node.html#method-Node-accept'><code>DSLite::Node$accept()</code></a></span></li>
-<li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="initialize"><a href='../../DSLite/html/Node.html#method-Node-initialize'><code>DSLite::Node$initialize()</code></a></span></li>
-<li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="set_parent"><a href='../../DSLite/html/Node.html#method-Node-set_parent'><code>DSLite::Node$set_parent()</code></a></span></li>
-<li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="to_string_children"><a href='../../DSLite/html/Node.html#method-Node-to_string_children'><code>DSLite::Node$to_string_children()</code></a></span></li>
+  <li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="accept"><a href='../../DSLite/html/Node.html#method-Node-accept'><code>Node$accept()</code></a></span></li>
+  <li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="initialize"><a href='../../DSLite/html/Node.html#method-Node-initialize'><code>Node$initialize()</code></a></span></li>
+  <li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="set_parent"><a href='../../DSLite/html/Node.html#method-Node-set_parent'><code>Node$set_parent()</code></a></span></li>
+  <li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="to_string_children"><a href='../../DSLite/html/Node.html#method-Node-to_string_children'><code>Node$to_string_children()</code></a></span></li>
 </ul>
-</details>
-}}
+</details>}}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-RangeNode-add_child"></a>}}
 \if{latex}{\out{\hypertarget{method-RangeNode-add_child}{}}}
-\subsection{Method \code{add_child()}}{
-Two children
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{RangeNode$add_child(val)}\if{html}{\out{</div>}}
+\subsection{\code{RangeNode$add_child()}}{
+  Two children
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{RangeNode$add_child(val)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{val}}{Child Node}
+    }
+    \if{html}{\out{</div>}}
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{val}}{Child Node}
-}
-\if{html}{\out{</div>}}
-}
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-RangeNode-to_string"></a>}}
 \if{latex}{\out{\hypertarget{method-RangeNode-to_string}{}}}
-\subsection{Method \code{to_string()}}{
-Get the string representation of the BinaryOpNode
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{RangeNode$to_string()}\if{html}{\out{</div>}}
+\subsection{\code{RangeNode$to_string()}}{
+  Get the string representation of the BinaryOpNode
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{RangeNode$to_string()}
+    \if{html}{\out{</div>}}
+  }
 }
 
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-RangeNode-clone"></a>}}
 \if{latex}{\out{\hypertarget{method-RangeNode-clone}{}}}
-\subsection{Method \code{clone()}}{
-The objects of this class are cloneable with this method.
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{RangeNode$clone(deep = FALSE)}\if{html}{\out{</div>}}
+\subsection{\code{RangeNode$clone()}}{
+  The objects of this class are cloneable with this method.
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{RangeNode$clone(deep = FALSE)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{deep}}{Whether to make a deep clone.}
+    }
+    \if{html}{\out{</div>}}
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{deep}}{Whether to make a deep clone.}
-}
-\if{html}{\out{</div>}}
-}
-}
 }
diff --git a/man/StringNode.Rd b/man/StringNode.Rd
index 9df0ab9..3afca68 100644
--- a/man/StringNode.Rd
+++ b/man/StringNode.Rd
@@ -8,7 +8,7 @@
 AST node that represent a string value, either single or double quoted.
 }
 \seealso{
-Other parser items: 
+Other parser items:
 \code{\link{BinaryOpNode}},
 \code{\link{FormulaNode}},
 \code{\link{FunctionNode}},
@@ -22,68 +22,72 @@ Other parser items:
 }
 \concept{parser items}
 \section{Super class}{
-\code{\link[DSLite:Node]{DSLite::Node}} -> \code{StringNode}
+\code{\link[DSLite:Node]{Node}} -> \code{StringNode}
 }
 \section{Methods}{
 \subsection{Public methods}{
-\itemize{
-\item \href{#method-StringNode-add_child}{\code{StringNode$add_child()}}
-\item \href{#method-StringNode-to_string}{\code{StringNode$to_string()}}
-\item \href{#method-StringNode-clone}{\code{StringNode$clone()}}
+  \itemize{
+    \item \href{#method-StringNode-add_child}{\code{StringNode$add_child()}}
+    \item \href{#method-StringNode-to_string}{\code{StringNode$to_string()}}
+    \item \href{#method-StringNode-clone}{\code{StringNode$clone()}}
+  }
 }
-}
-\if{html}{\out{
-<details open><summary>Inherited methods</summary>
+\if{html}{\out{<details open><summary>Inherited methods</summary>
 <ul>
-<li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="accept"><a href='../../DSLite/html/Node.html#method-Node-accept'><code>DSLite::Node$accept()</code></a></span></li>
-<li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="initialize"><a href='../../DSLite/html/Node.html#method-Node-initialize'><code>DSLite::Node$initialize()</code></a></span></li>
-<li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="set_parent"><a href='../../DSLite/html/Node.html#method-Node-set_parent'><code>DSLite::Node$set_parent()</code></a></span></li>
-<li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="to_string_children"><a href='../../DSLite/html/Node.html#method-Node-to_string_children'><code>DSLite::Node$to_string_children()</code></a></span></li>
+  <li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="accept"><a href='../../DSLite/html/Node.html#method-Node-accept'><code>Node$accept()</code></a></span></li>
+  <li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="initialize"><a href='../../DSLite/html/Node.html#method-Node-initialize'><code>Node$initialize()</code></a></span></li>
+  <li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="set_parent"><a href='../../DSLite/html/Node.html#method-Node-set_parent'><code>Node$set_parent()</code></a></span></li>
+  <li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="to_string_children"><a href='../../DSLite/html/Node.html#method-Node-to_string_children'><code>Node$to_string_children()</code></a></span></li>
 </ul>
-</details>
-}}
+</details>}}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-StringNode-add_child"></a>}}
 \if{latex}{\out{\hypertarget{method-StringNode-add_child}{}}}
-\subsection{Method \code{add_child()}}{
-No children
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{StringNode$add_child(val)}\if{html}{\out{</div>}}
+\subsection{\code{StringNode$add_child()}}{
+  No children
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{StringNode$add_child(val)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{val}}{Child Node}
+    }
+    \if{html}{\out{</div>}}
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{val}}{Child Node}
-}
-\if{html}{\out{</div>}}
-}
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-StringNode-to_string"></a>}}
 \if{latex}{\out{\hypertarget{method-StringNode-to_string}{}}}
-\subsection{Method \code{to_string()}}{
-Get the string representation of the StringNode
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{StringNode$to_string()}\if{html}{\out{</div>}}
+\subsection{\code{StringNode$to_string()}}{
+  Get the string representation of the StringNode
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{StringNode$to_string()}
+    \if{html}{\out{</div>}}
+  }
 }
 
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-StringNode-clone"></a>}}
 \if{latex}{\out{\hypertarget{method-StringNode-clone}{}}}
-\subsection{Method \code{clone()}}{
-The objects of this class are cloneable with this method.
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{StringNode$clone(deep = FALSE)}\if{html}{\out{</div>}}
+\subsection{\code{StringNode$clone()}}{
+  The objects of this class are cloneable with this method.
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{StringNode$clone(deep = FALSE)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{deep}}{Whether to make a deep clone.}
+    }
+    \if{html}{\out{</div>}}
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{deep}}{Whether to make a deep clone.}
-}
-\if{html}{\out{</div>}}
-}
-}
 }
diff --git a/man/SymbolNode.Rd b/man/SymbolNode.Rd
index 672175d..2c10364 100644
--- a/man/SymbolNode.Rd
+++ b/man/SymbolNode.Rd
@@ -8,7 +8,7 @@
 AST node that represents a R symbol (variable name, function name etc.).
 }
 \seealso{
-Other parser items: 
+Other parser items:
 \code{\link{BinaryOpNode}},
 \code{\link{FormulaNode}},
 \code{\link{FunctionNode}},
@@ -22,68 +22,72 @@ Other parser items:
 }
 \concept{parser items}
 \section{Super class}{
-\code{\link[DSLite:Node]{DSLite::Node}} -> \code{SymbolNode}
+\code{\link[DSLite:Node]{Node}} -> \code{SymbolNode}
 }
 \section{Methods}{
 \subsection{Public methods}{
-\itemize{
-\item \href{#method-SymbolNode-add_child}{\code{SymbolNode$add_child()}}
-\item \href{#method-SymbolNode-to_string}{\code{SymbolNode$to_string()}}
-\item \href{#method-SymbolNode-clone}{\code{SymbolNode$clone()}}
+  \itemize{
+    \item \href{#method-SymbolNode-add_child}{\code{SymbolNode$add_child()}}
+    \item \href{#method-SymbolNode-to_string}{\code{SymbolNode$to_string()}}
+    \item \href{#method-SymbolNode-clone}{\code{SymbolNode$clone()}}
+  }
 }
-}
-\if{html}{\out{
-<details open><summary>Inherited methods</summary>
+\if{html}{\out{<details open><summary>Inherited methods</summary>
 <ul>
-<li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="accept"><a href='../../DSLite/html/Node.html#method-Node-accept'><code>DSLite::Node$accept()</code></a></span></li>
-<li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="initialize"><a href='../../DSLite/html/Node.html#method-Node-initialize'><code>DSLite::Node$initialize()</code></a></span></li>
-<li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="set_parent"><a href='../../DSLite/html/Node.html#method-Node-set_parent'><code>DSLite::Node$set_parent()</code></a></span></li>
-<li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="to_string_children"><a href='../../DSLite/html/Node.html#method-Node-to_string_children'><code>DSLite::Node$to_string_children()</code></a></span></li>
+  <li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="accept"><a href='../../DSLite/html/Node.html#method-Node-accept'><code>Node$accept()</code></a></span></li>
+  <li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="initialize"><a href='../../DSLite/html/Node.html#method-Node-initialize'><code>Node$initialize()</code></a></span></li>
+  <li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="set_parent"><a href='../../DSLite/html/Node.html#method-Node-set_parent'><code>Node$set_parent()</code></a></span></li>
+  <li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="to_string_children"><a href='../../DSLite/html/Node.html#method-Node-to_string_children'><code>Node$to_string_children()</code></a></span></li>
 </ul>
-</details>
-}}
+</details>}}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-SymbolNode-add_child"></a>}}
 \if{latex}{\out{\hypertarget{method-SymbolNode-add_child}{}}}
-\subsection{Method \code{add_child()}}{
-No children
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{SymbolNode$add_child(val)}\if{html}{\out{</div>}}
+\subsection{\code{SymbolNode$add_child()}}{
+  No children
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{SymbolNode$add_child(val)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{val}}{Child Node}
+    }
+    \if{html}{\out{</div>}}
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{val}}{Child Node}
-}
-\if{html}{\out{</div>}}
-}
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-SymbolNode-to_string"></a>}}
 \if{latex}{\out{\hypertarget{method-SymbolNode-to_string}{}}}
-\subsection{Method \code{to_string()}}{
-Get the string representation of the SymbolNode
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{SymbolNode$to_string()}\if{html}{\out{</div>}}
+\subsection{\code{SymbolNode$to_string()}}{
+  Get the string representation of the SymbolNode
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{SymbolNode$to_string()}
+    \if{html}{\out{</div>}}
+  }
 }
 
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-SymbolNode-clone"></a>}}
 \if{latex}{\out{\hypertarget{method-SymbolNode-clone}{}}}
-\subsection{Method \code{clone()}}{
-The objects of this class are cloneable with this method.
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{SymbolNode$clone(deep = FALSE)}\if{html}{\out{</div>}}
+\subsection{\code{SymbolNode$clone()}}{
+  The objects of this class are cloneable with this method.
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{SymbolNode$clone(deep = FALSE)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{deep}}{Whether to make a deep clone.}
+    }
+    \if{html}{\out{</div>}}
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{deep}}{Whether to make a deep clone.}
-}
-\if{html}{\out{</div>}}
-}
-}
 }
diff --git a/man/UnaryOpNode.Rd b/man/UnaryOpNode.Rd
index 6de7ab1..fbba77b 100644
--- a/man/UnaryOpNode.Rd
+++ b/man/UnaryOpNode.Rd
@@ -8,7 +8,7 @@
 AST node that represents a unary operator (such as '-'), therefore having a single child node.
 }
 \seealso{
-Other parser items: 
+Other parser items:
 \code{\link{BinaryOpNode}},
 \code{\link{FormulaNode}},
 \code{\link{FunctionNode}},
@@ -22,68 +22,72 @@ Other parser items:
 }
 \concept{parser items}
 \section{Super class}{
-\code{\link[DSLite:Node]{DSLite::Node}} -> \code{UnaryOpNode}
+\code{\link[DSLite:Node]{Node}} -> \code{UnaryOpNode}
 }
 \section{Methods}{
 \subsection{Public methods}{
-\itemize{
-\item \href{#method-UnaryOpNode-add_child}{\code{UnaryOpNode$add_child()}}
-\item \href{#method-UnaryOpNode-to_string}{\code{UnaryOpNode$to_string()}}
-\item \href{#method-UnaryOpNode-clone}{\code{UnaryOpNode$clone()}}
+  \itemize{
+    \item \href{#method-UnaryOpNode-add_child}{\code{UnaryOpNode$add_child()}}
+    \item \href{#method-UnaryOpNode-to_string}{\code{UnaryOpNode$to_string()}}
+    \item \href{#method-UnaryOpNode-clone}{\code{UnaryOpNode$clone()}}
+  }
 }
-}
-\if{html}{\out{
-<details open><summary>Inherited methods</summary>
+\if{html}{\out{<details open><summary>Inherited methods</summary>
 <ul>
-<li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="accept"><a href='../../DSLite/html/Node.html#method-Node-accept'><code>DSLite::Node$accept()</code></a></span></li>
-<li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="initialize"><a href='../../DSLite/html/Node.html#method-Node-initialize'><code>DSLite::Node$initialize()</code></a></span></li>
-<li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="set_parent"><a href='../../DSLite/html/Node.html#method-Node-set_parent'><code>DSLite::Node$set_parent()</code></a></span></li>
-<li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="to_string_children"><a href='../../DSLite/html/Node.html#method-Node-to_string_children'><code>DSLite::Node$to_string_children()</code></a></span></li>
+  <li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="accept"><a href='../../DSLite/html/Node.html#method-Node-accept'><code>Node$accept()</code></a></span></li>
+  <li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="initialize"><a href='../../DSLite/html/Node.html#method-Node-initialize'><code>Node$initialize()</code></a></span></li>
+  <li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="set_parent"><a href='../../DSLite/html/Node.html#method-Node-set_parent'><code>Node$set_parent()</code></a></span></li>
+  <li><span class="pkg-link" data-pkg="DSLite" data-topic="Node" data-id="to_string_children"><a href='../../DSLite/html/Node.html#method-Node-to_string_children'><code>Node$to_string_children()</code></a></span></li>
 </ul>
-</details>
-}}
+</details>}}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-UnaryOpNode-add_child"></a>}}
 \if{latex}{\out{\hypertarget{method-UnaryOpNode-add_child}{}}}
-\subsection{Method \code{add_child()}}{
-One children
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{UnaryOpNode$add_child(val)}\if{html}{\out{</div>}}
+\subsection{\code{UnaryOpNode$add_child()}}{
+  One children
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{UnaryOpNode$add_child(val)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{val}}{Child Node}
+    }
+    \if{html}{\out{</div>}}
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{val}}{Child Node}
-}
-\if{html}{\out{</div>}}
-}
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-UnaryOpNode-to_string"></a>}}
 \if{latex}{\out{\hypertarget{method-UnaryOpNode-to_string}{}}}
-\subsection{Method \code{to_string()}}{
-Get the string representation of the UnaryOpNode
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{UnaryOpNode$to_string()}\if{html}{\out{</div>}}
+\subsection{\code{UnaryOpNode$to_string()}}{
+  Get the string representation of the UnaryOpNode
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{UnaryOpNode$to_string()}
+    \if{html}{\out{</div>}}
+  }
 }
 
-}
 \if{html}{\out{<hr>}}
 \if{html}{\out{<a id="method-UnaryOpNode-clone"></a>}}
 \if{latex}{\out{\hypertarget{method-UnaryOpNode-clone}{}}}
-\subsection{Method \code{clone()}}{
-The objects of this class are cloneable with this method.
-\subsection{Usage}{
-\if{html}{\out{<div class="r">}}\preformatted{UnaryOpNode$clone(deep = FALSE)}\if{html}{\out{</div>}}
+\subsection{\code{UnaryOpNode$clone()}}{
+  The objects of this class are cloneable with this method.
+  \subsection{Usage}{
+    \if{html}{\out{<div class="r">}}
+    \preformatted{UnaryOpNode$clone(deep = FALSE)}
+    \if{html}{\out{</div>}}
+  }
+  \subsection{Arguments}{
+    \if{html}{\out{<div class="arguments">}}
+    \describe{
+      \item{\code{deep}}{Whether to make a deep clone.}
+    }
+    \if{html}{\out{</div>}}
+  }
 }
 
-\subsection{Arguments}{
-\if{html}{\out{<div class="arguments">}}
-\describe{
-\item{\code{deep}}{Whether to make a deep clone.}
-}
-\if{html}{\out{</div>}}
-}
-}
 }
diff --git a/man/newDSLiteServer.Rd b/man/newDSLiteServer.Rd
index b9e8ccb..a383504 100644
--- a/man/newDSLiteServer.Rd
+++ b/man/newDSLiteServer.Rd
@@ -30,7 +30,7 @@ Default is in a hidden folder of the R session's temporary directory.}
 Shortcut function to create a new \code{DSLiteServer} instance.
 }
 \seealso{
-Other server-side items: 
+Other server-side items:
 \code{\link{DSLiteServer}}
 }
 \concept{server-side items}
diff --git a/man/setupCNSIMTest.Rd b/man/setupCNSIMTest.Rd
index bfd6825..69668fb 100644
--- a/man/setupCNSIMTest.Rd
+++ b/man/setupCNSIMTest.Rd
@@ -29,11 +29,11 @@ datashield.logout(conns)
 }
 }
 \seealso{
-Other setup functions: 
-\code{\link{setupDASIMTest}()},
-\code{\link{setupDATASETTest}()},
-\code{\link{setupDISCORDANTTest}()},
-\code{\link{setupDSLiteServer}()},
-\code{\link{setupSURVIVALTest}()}
+Other setup functions:
+\code{\link[=setupDASIMTest]{setupDASIMTest()}},
+\code{\link[=setupDATASETTest]{setupDATASETTest()}},
+\code{\link[=setupDISCORDANTTest]{setupDISCORDANTTest()}},
+\code{\link[=setupDSLiteServer]{setupDSLiteServer()}},
+\code{\link[=setupSURVIVALTest]{setupSURVIVALTest()}}
 }
 \concept{setup functions}
diff --git a/man/setupDASIMTest.Rd b/man/setupDASIMTest.Rd
index 09491bb..dcbfa1a 100644
--- a/man/setupDASIMTest.Rd
+++ b/man/setupDASIMTest.Rd
@@ -29,11 +29,11 @@ datashield.logout(conns)
 }
 }
 \seealso{
-Other setup functions: 
-\code{\link{setupCNSIMTest}()},
-\code{\link{setupDATASETTest}()},
-\code{\link{setupDISCORDANTTest}()},
-\code{\link{setupDSLiteServer}()},
-\code{\link{setupSURVIVALTest}()}
+Other setup functions:
+\code{\link[=setupCNSIMTest]{setupCNSIMTest()}},
+\code{\link[=setupDATASETTest]{setupDATASETTest()}},
+\code{\link[=setupDISCORDANTTest]{setupDISCORDANTTest()}},
+\code{\link[=setupDSLiteServer]{setupDSLiteServer()}},
+\code{\link[=setupSURVIVALTest]{setupSURVIVALTest()}}
 }
 \concept{setup functions}
diff --git a/man/setupDATASETTest.Rd b/man/setupDATASETTest.Rd
index b2e05b7..bbf2d9d 100644
--- a/man/setupDATASETTest.Rd
+++ b/man/setupDATASETTest.Rd
@@ -29,11 +29,11 @@ datashield.logout(conns)
 }
 }
 \seealso{
-Other setup functions: 
-\code{\link{setupCNSIMTest}()},
-\code{\link{setupDASIMTest}()},
-\code{\link{setupDISCORDANTTest}()},
-\code{\link{setupDSLiteServer}()},
-\code{\link{setupSURVIVALTest}()}
+Other setup functions:
+\code{\link[=setupCNSIMTest]{setupCNSIMTest()}},
+\code{\link[=setupDASIMTest]{setupDASIMTest()}},
+\code{\link[=setupDISCORDANTTest]{setupDISCORDANTTest()}},
+\code{\link[=setupDSLiteServer]{setupDSLiteServer()}},
+\code{\link[=setupSURVIVALTest]{setupSURVIVALTest()}}
 }
 \concept{setup functions}
diff --git a/man/setupDISCORDANTTest.Rd b/man/setupDISCORDANTTest.Rd
index d3ad054..1644f23 100644
--- a/man/setupDISCORDANTTest.Rd
+++ b/man/setupDISCORDANTTest.Rd
@@ -29,11 +29,11 @@ datashield.logout(conns)
 }
 }
 \seealso{
-Other setup functions: 
-\code{\link{setupCNSIMTest}()},
-\code{\link{setupDASIMTest}()},
-\code{\link{setupDATASETTest}()},
-\code{\link{setupDSLiteServer}()},
-\code{\link{setupSURVIVALTest}()}
+Other setup functions:
+\code{\link[=setupCNSIMTest]{setupCNSIMTest()}},
+\code{\link[=setupDASIMTest]{setupDASIMTest()}},
+\code{\link[=setupDATASETTest]{setupDATASETTest()}},
+\code{\link[=setupDSLiteServer]{setupDSLiteServer()}},
+\code{\link[=setupSURVIVALTest]{setupSURVIVALTest()}}
 }
 \concept{setup functions}
diff --git a/man/setupDSLiteServer.Rd b/man/setupDSLiteServer.Rd
index 0f036de..bb40265 100644
--- a/man/setupDSLiteServer.Rd
+++ b/man/setupDSLiteServer.Rd
@@ -51,11 +51,11 @@ datashield.logout(conns)
 
 }
 \seealso{
-Other setup functions: 
-\code{\link{setupCNSIMTest}()},
-\code{\link{setupDASIMTest}()},
-\code{\link{setupDATASETTest}()},
-\code{\link{setupDISCORDANTTest}()},
-\code{\link{setupSURVIVALTest}()}
+Other setup functions:
+\code{\link[=setupCNSIMTest]{setupCNSIMTest()}},
+\code{\link[=setupDASIMTest]{setupDASIMTest()}},
+\code{\link[=setupDATASETTest]{setupDATASETTest()}},
+\code{\link[=setupDISCORDANTTest]{setupDISCORDANTTest()}},
+\code{\link[=setupSURVIVALTest]{setupSURVIVALTest()}}
 }
 \concept{setup functions}
diff --git a/man/setupSURVIVALTest.Rd b/man/setupSURVIVALTest.Rd
index 30d0c5d..8ed1437 100644
--- a/man/setupSURVIVALTest.Rd
+++ b/man/setupSURVIVALTest.Rd
@@ -29,11 +29,11 @@ datashield.logout(conns)
 }
 }
 \seealso{
-Other setup functions: 
-\code{\link{setupCNSIMTest}()},
-\code{\link{setupDASIMTest}()},
-\code{\link{setupDATASETTest}()},
-\code{\link{setupDISCORDANTTest}()},
-\code{\link{setupDSLiteServer}()}
+Other setup functions:
+\code{\link[=setupCNSIMTest]{setupCNSIMTest()}},
+\code{\link[=setupDASIMTest]{setupDASIMTest()}},
+\code{\link[=setupDATASETTest]{setupDATASETTest()}},
+\code{\link[=setupDISCORDANTTest]{setupDISCORDANTTest()}},
+\code{\link[=setupDSLiteServer]{setupDSLiteServer()}}
 }
 \concept{setup functions}
diff --git a/tests/testthat/test-parser.R b/tests/testthat/test-parser.R
index ac9c3b2..866af7a 100644
--- a/tests/testthat/test-parser.R
+++ b/tests/testthat/test-parser.R
@@ -12,7 +12,7 @@ test_that("A number", {
 
 test_that("A negative number", {
   ast <- DSLite::testParse("-0.43151402098822")
-  expect_true(inherits(ast, "NumericNode"))
+  expect_true(inherits(ast, "UnaryOpNode"))
   expect_equal(ast$to_string(), "-0.43151402098822")
 })
 
@@ -34,13 +34,13 @@ test_that("A number with floating point and exponent", {
 
 test_that("A number with floating point, exponent and negative signs", {
   ast <- DSLite::testParse("-3.1e-4")
-  expect_true(inherits(ast, "NumericNode"))
+  expect_true(inherits(ast, "UnaryOpNode"))
   expect_equal(ast$to_string(), "-3.1e-4")
 })
 
 test_that("A number with floating point, exponent and positive signs", {
   ast <- DSLite::testParse("+3.1e+4")
-  expect_true(inherits(ast, "NumericNode"))
+  expect_true(inherits(ast, "UnaryOpNode"))
   expect_equal(ast$to_string(), "+3.1e+4")
 })
 
@@ -124,9 +124,9 @@ test_that("A symbol", {
   expect_true(inherits(ast, "SymbolNode"))
   expect_equal(ast$to_string(), "abc")
 
-  ast <- DSLite::testParse("abc-DEF.123X$var_12")
+  ast <- DSLite::testParse("abc.DEF.123X$var_12")
   expect_true(inherits(ast, "SymbolNode"))
-  expect_equal(ast$to_string(), "abc-DEF.123X$var_12")
+  expect_equal(ast$to_string(), "abc.DEF.123X$var_12")
 })
 
 test_that("Symbol with invalid chars", {
@@ -182,6 +182,50 @@ test_that("Unary not operator", {
   expect_equal(ast$to_string(), "!A")
 })
 
+test_that("Minus sign is an operator", {
+  expect_equal(DSLite::testParse("1-1")$to_string(), "1 - 1")
+  expect_equal(DSLite::testParse("x -1")$to_string(), "x - 1")
+  expect_equal(DSLite::testParse("x+1")$to_string(), "x + 1")
+  expect_equal(DSLite::testParse("-1L")$to_string(), "-1L")
+
+  ast <- DSLite::testParse("a-f(1)")
+  expect_true(inherits(ast, "BinaryOpNode"))
+  expect_true(inherits(ast$children[[2]], "FunctionNode"))
+  expect_equal(ast$children[[2]]$name, "f")
+
+  ast <- DSLite::testParse("a-(b)")
+  expect_true(inherits(ast, "BinaryOpNode"))
+  expect_equal(ast$to_string(), "a - (b)")
+})
+
+test_that("Power and pct operators", {
+  expect_equal(DSLite::testParse("a^2")$to_string(), "a^2")
+  expect_equal(DSLite::testParse("A %*% B")$to_string(), "A %*% B")
+  expect_equal(DSLite::testParse("A %% B")$to_string(), "A %% B")
+  expect_equal(DSLite::testParse("A %/% B")$to_string(), "A %/% B")
+})
+
+test_that("Operators follow R precedence", {
+  # the shape of the tree must be the one R gives: operator at the root, then its operands
+  root <- function(expr) {
+    ast <- DSLite::testParse(expr)
+    c(ast$name, ast$children[[1]]$to_string())
+  }
+  expect_equal(root("a * b + c"), c("+", "a * b"))
+  expect_equal(root("a - b - c"), c("-", "a - b"))
+  expect_equal(root("a^b^c"), c("^", "a"))
+  expect_equal(root("-2^2"), c("-", "2^2"))
+  expect_equal(root("-1:3"), c(":", "-1"))
+  expect_equal(root("1:3^2"), c(":", "1"))
+  expect_equal(root("2 * 1:3"), c("*", "2"))
+})
+
+test_that("Round trip is the same expression for R", {
+  for (expr in c("a*b-c", "-2^2", "1:3^2", "2^1:3", "-1:3", "a^b^c", "1-1", "x -1", "a-f(1)", "f(1 -2)",
+                 "a %*% b", "y-1 ~ x", "a + b ~ c", "y ~ -x", "y ~ x -1", "y ~ a/b + c", "-y ~ x"))
+    expect_identical(parse(text = DSLite::testParse(expr)$to_string())[[1]], parse(text = expr)[[1]], info = expr)
+})
+
 #
 # Group
 #
@@ -247,11 +291,31 @@ test_that("A formula with operators", {
   ast <- DSLite::testParse("A ~ B + (C * D)^4 : E %in% F")
   expect_true(inherits(ast, "FormulaNode"))
   expect_equal(ast$to_string(), "A ~ B + (C * D)^4:E %in% F")
+
+  ast <- DSLite::testParse("A ~ B / C")
+  expect_true(inherits(ast, "FormulaNode"))
+  expect_equal(ast$to_string(), "A ~ B / C")
+
+  ast <- DSLite::testParse("A ~ -1 + B")
+  expect_true(inherits(ast, "FormulaNode"))
+  expect_equal(ast$to_string(), "A ~ -1 + B")
+})
+
+test_that("A formula with an expression as response", {
+  ast <- DSLite::testParse("A-1~B")
+  expect_true(inherits(ast, "FormulaNode"))
+  expect_equal(ast$to_string(), "A - 1 ~ B")
+
+  ast <- DSLite::testParse("A + B ~ C")
+  expect_true(inherits(ast, "FormulaNode"))
+  expect_equal(ast$to_string(), "A + B ~ C")
 })
 
 test_that("Formula with invalid syntax", {
   expect_error(DSLite::testParse("A ~ 'abc'"))
   expect_error(DSLite::testParse("D$height ~ D$diameter + poly(D$length, 3, raw=TRUE)"))
+  expect_error(DSLite::testParse("log(A) ~ B"))
+  expect_error(DSLite::testParse("A ~ (log(B))"))
 })
 
 #
diff --git a/tests/testthat/test-server.R b/tests/testthat/test-server.R
index 10ed9e4..54d852c 100644
--- a/tests/testthat/test-server.R
+++ b/tests/testthat/test-server.R
@@ -35,6 +35,19 @@ test_that("session operations work", {
   expect_false(testServ$hasSession(sid))
 })
 
+test_that("strict mode applies to nested function calls", {
+  methods <- data.frame(name = c("length", "sum"), value = c("base::length", "base::sum"),
+                        class = "function", stringsAsFactors = FALSE)
+  serv <- DSLite::DSLiteServer$new(config = list(AggregateMethods = methods), strict = TRUE)
+  sid <- serv$newSession()
+
+  expect_equal(serv$aggregate(sid, "length(sum(1))"), 1)
+  for (expr in c("nchar('a')", "length(nchar('a'))", "1 + nchar('a')", "-nchar('a')", "(nchar('a'))", "x = nchar('a')"))
+    expect_error(serv$aggregate(sid, expr), "does not allow expression: nchar")
+
+  serv$closeSession(sid)
+})
+
 test_that("options operations work", {
   testServ$options(list(foo="bar"))
   expect_equal(testServ$options(), list(foo="bar"))