S3.Rnw

<<knitr, echo=FALSE>>=
opts_chunk$set(tidy.opts = 
               list(width.cutoff = 50, 
                    tidy = FALSE),
               fig.align = 'center',
               stop_on_error = 1L,
               comment = NA,
               prompt = TRUE)
options(width = 60)
@ 


\section{S3 object oriented framework}

% S4 class system introduction
\begin{frame}[t]{S3 versus S4}

\begin{block}{Differences of S3 class system to S4}
\begin{small}
\begin{itemize}
\item \textbf{Classes are not explicit} - New types are created by manually setting the \Rfunction{class()} attribute. 
\item \textbf{Generics and dispatching by naming convention} - Generics work by an informal naming convention
\item \textbf{Limited introspection}
\item \textbf{No validity checking, multiple inheritance, multiple dispatch, virtual classes}
\end{itemize}
\end{small}

\bigskip
S4 class system is the de-facto standard in Bioconductor, but most of base R 
is written in S3.

\end{block}

\end{frame}

\begin{frame}[fragile]

\begin{block}{Creating an object in S3}
	In S3, classes are not explciit, and objects are created by setting the \Rfunction{class()}
	attribute. 
\end{block}
\begin{scriptsize}
<<creatClass-s3, echo=TRUE>>=
s <- list(id="example", sequence="ACCTAGAT", alphabet=c("A", "C", "G", "T"))
class(s) <- "GenericSeq"
s
names(s)
@
\end{scriptsize}
\end{frame}


\begin{frame}[fragile]{S3 generics and dispatch}
\begin{block}{Methods are created by naming convention}
	The method is named as \Robject{<generic>.<class>}. The generic that is defined
	by the usage of the \Robject{UseMethod()} command will look for functions of this format
	in the current workspace. If not function is found it will use 
	\Robject{<generic>.default}. 
\end{block}
\begin{scriptsize}
<<creatMethod-s3, echo=TRUE>>=
# generic
id <- function(obj, ...) UseMethod("id") 
# method
id.GenericSeq <- function(obj, ...) obj$id

id(s) 
@
\end{scriptsize}
\end{frame}

\begin{frame}[fragile]{S3 generics in base R}
\begin{scriptsize}
<<generics,echo=TRUE>>=
summary
x <- c(1, 4, 2, 1, 4, 2)
class(x)
summary(x)
@
\end{scriptsize}
\end{frame}

%% Cheating below because methods(summary) created an error due to '
%% in the output.

\begin{frame}[fragile]
To see what method exist for a generic:
\begin{scriptsize}
\begin{verbatim}
> methods(summary)
 [1] summary.aov                    summary.aovlist*
 [3] summary.aspell*                summary.check_packages_in_dir*
 [5] summary.connection             summary.data.frame
 [7] summary.Date                   summary.default
 [9] summary.ecdf*                  summary.factor
[11] summary.glm                    summary.infl*
[13] summary.lm                     summary.loess*
[15] summary.manova                 summary.matrix
[17] summary.mlm*                   summary.nls*
[19] summary.packageStatus*         summary.PDF_Dictionary*
[21] summary.PDF_Stream*            summary.POSIXct
[23] summary.POSIXlt                summary.ppr*
[25] summary.prcomp*                summary.princomp*
[27] summary.proc_time              summary.srcfile
[29] summary.srcref                 summary.stepfun
[31] summary.stl*                   summary.table
[33] summary.tukeysmooth*
see "?methods" for accessing help and source code     
\end{verbatim}
\end{scriptsize}
\end{frame}


\begin{frame}[fragile]
  \begin{block}{S3 dispatch}
    Because there is no \Robject{summary.numeric}, the default implementation
    \Robject{summary.default} is used.
  \end{block}

\begin{scriptsize}
<<generics3,echo=TRUE>>=
x <- c(1, 4, 2, 1, 4, 2)
class(x)
summary(x)
summary.default(x)
@
\end{scriptsize}

\end{frame}

\begin{frame}[fragile]
\begin{scriptsize}
<<generics4,echo=TRUE>>=
y <- table(c(0, 1, 1, 0), c(1, 0, 1, 1))
class(y)
summary(y)
summary.table(y)
@
\end{scriptsize}
\end{frame}


\begin{frame}[t]{S3 methods exercises}
\small
Look at the code we have written so far, understand it, and then solve
the following exercise.

\begin{block}{\exercise}
\small
Explore some of the built-in generics and methods. Try the following commands:\\
\smallskip
\code{methods("summary")}\\
\code{methods(class="lm")}\\
\end{block}


\begin{block}{\exercise (code:\code{03_GenericSeq.R}, solution:\code{03_GenericSeq_solution.R})}
\small
Both \code{length()} and \code{rev()} are already generic functions,
but \code{alphabet()} is not. 
Add these methods for class \code{GenericSeq}:
\begin{itemize}
	\item \code{length()} should return the length of the DNA/RNA sequence
	\item \code{alphabet()} should return the alphabet of the sequence
	\item \code{rev()} should return the sequence in reverse ({\scriptsize Hint:
	try to use functions \code{strsplit()} and the existing base \code{rev()} function}).
\end{itemize}
\end{block}

\comments{
<<exercise2,echo=FALSE>>=
invisible(alphabet <- function(x, ...) UseMethod("alphabet"))
invisible(alphabet.GenericSeq <- function(x, ...) x$alphabet)

invisible(rev <- function(x, ...) UseMethod("rev"))
invisible(rev.GenericSeq <- function(x, ...) paste(rev(unlist(strsplit(x$sequence, ""))), collapse=""))
invisible(seq.GenericSeq <- function(x, ...){ x$seq })
@
}

\end{frame}

% Introduce S3 inheritance
\begin{frame}[fragile]{S3 inheritance}

\begin{block}{Reusing class methods}
So far we have written methods for \code{GenericSeq} that work with any sequence type.
Now lets introduce a new class \code{DnaSeq}. We want to \textbf{inherit}
all methods from \code{GenericSeq} - to achieve this simply set the \code{class}
attribute to all applicable class names. 
\end{block}

\smallskip
\begin{scriptsize}
<<seq-type,echo=TRUE>>=
setSeqSubtype <- function(s){
  if (all( alphabet(s) %in% c("A","C","G","T") )) {
    class(s) <- c("DnaSeq", "GenericSeq")  
  } else if (all( alphabet(s) %in% c("A","C","G","U") )) {
    class(s) <- c("RnaSeq", "GenericSeq")
  } else {
    stop("Alphabet ", alphabet(s) ," is unknown.")
  }
  
  return(s)
}
s.dna <- setSeqSubtype(s)
class(s.dna)
@

\end{scriptsize}

\end{frame}

% define the DnaSeq function and show how it works
\begin{frame}[fragile]{S3 inheritance continued}
  \begin{block}{\code{DnaSeq} methods}
    \small
    Define a \code{DnaSeq} method \code{comp()}. All \code{GenericSeq} methods still work with \code{DnaSeq} objects, but
    the \code{comp()} only works with \code{DnaSeq}.
  \end{block}

<<comp,echo=TRUE>>=
comp <- function(x, ...){ UseMethod("comp") }
comp.DnaSeq <- function(x, ...) 
	chartr("ACGT", "TGCA", seq(x))
@
\end{frame}

\begin{frame}[fragile]{S3 inheritance continued}
<<inheritance,echo=TRUE>>=
id(s) # works on GenericSeq
id(s.dna) # works on DnaSeq, GenericSeq
comp(s) # fails with error
comp(s.dna)
@
\end{frame}

\begin{frame}[fragile]{S3 inheritance continued}
  \begin{block}{S3 dispatch and inheritance}
    The dispatching will look for appropriate methods for all \code{x} (sub-)classes
    (in order in which they are set).
  \end{block}
\end{frame}

% S3 inheritance exercise
\begin{frame}[t]{S3 inheritance exercise}

Look at the inheritance code and understand how it works. Then solve the following exercise.

\begin{block}{\exercise (code: \code{04_inherit.R}, solution: \code{04_inherit_solution.R})}
Write the \code{comp()} method for \code{RnaSeq} class. Since we don't have a RNA FASTA
file you will have to make a new \code{RnaSeq} object by hand and assign the right classes
to test your code. 

\bigskip
What do you notice about the S3 class system, is it easy to make mistakes? Could you also make
your RNA sequence to be of class "\code{lm}"?

\end{block}

\end{frame}

% final S3 revision
\begin{frame}

\begin{block}{S3 class system revision}
\smallskip
\begin{small}
\begin{itemize}
	\item Classes are implicit (no formal class definition)
	\item Making new objects is done by simply setting the \code{class} attribute
	\item Making class methods is done by defining a generic function \code{functionName()} and a normal function \code{functionName.className()}. 
	Methods can be retrieved using the \code{methods()} function.
	\item Objects can inherit multiple classes by setting the \code{class} attribute to a vector of class names
	\item Many functions in base R use the S3 system
	\item Easy to make new ad-hoc classes and objects, but also mistakes and inconsistencies
\end{itemize}
\end{small}
\bigskip

The S4 class system was designed to address some of these concerns. 

\end{block}

\end{frame}

\begin{frame}[fragile]{Mutability in S3 and S4}
  \begin{block}{Mutability}
    \small
    \R objects are not \textbf{mutable}; \R has a \textbf{pass-by-value} semantics, 
    consistently with functional programming semantics. 
    Whenever\footnote{\tiny{Although, in general, \R tries to avoid copying objects unless they are modified.}} 
    you pass an object to a function, a copy is passed as argument; changes made to the object are local to the function call; 
    the original object is unchanged. This is how things work for both S3 and S4 class systems. 
  \end{block}
\begin{scriptsize}
<<makea, echo=FALSE>>=
invisible({
setClass("GenericSeq",
         representation = representation(
           id = "character",
           sequence =  "character",
           alphabet = "character"
          ))

setClass("DnaSeq",
         contains = "GenericSeq",
         prototype = prototype(
           id = paste("my DNA sequence", date()),
           alphabet = c("A", "C", "G", "T"),
           sequence = character()))

setGeneric("seq", function(...) standardGeneric("seq")) 
setMethod("seq", "GenericSeq", function(object,...) object@sequence)          
           
a <- new("DnaSeq",sequence="ACGTAA")
})
@   
<<mutability,echo=TRUE>>=
seq(a)
comp(a)
seq(a)
@ 
\end{scriptsize}
\end{frame}

%% % Coffee break!
%% \begin{frame}[fragile]{But before we continue...}
%%   \begin{center}
%%     {\Large It is time for morning coffee...}
%%     \bigskip
%%     (15 minute break)
%%   \end{center}
%% \end{frame}