pep-material: comparison handouts/pep-ho.tex

equal deleted inserted replaced

-:841727e27252
+:7e00d2b13b04
 \usepackage{../langs}
 \usepackage{tikz}
 \usepackage{pgf}
 \usepackage{marvosym}
 \usepackage{boxedminipage}
 %cheat sheet
 %http://worldline.github.io/scala-cheatsheet/
 %% https://alvinalexander.com/downloads/HelloScala-FreePreview.pdf
 %%
 %% Section 10 about strings; interpolations and multiline strings
+% Exact colors from NB
+\usepackage[breakable]{tcolorbox}
+\definecolor{incolor}{HTML}{303F9F}
+\definecolor{outcolor}{HTML}{D84315}
+\definecolor{cellborder}{HTML}{CFCFCF}
+\definecolor{cellbackground}{HTML}{F7F7F7}
 \begin{document}
 \fnote{\copyright{} Christian Urban, King's College London, 2017, 2018, 2019, 2020}
+%\begin{tcolorbox}[breakable,size=fbox,boxrule=1pt,pad at break*=1mm,colback=cellbackground,colframe=cellborder]
+%  abd
+%\end{tcolorbox}
 \section*{A Crash-Course in Scala}
 \mbox{}\hfill\textit{``Scala --- \underline{S}lowly \underline{c}ompiled
 \underline{a}cademic \underline{la}nguage''}\smallskip\\
 Type in expressions for evaluation. Or try :help.
 scala>
 \end{lstlisting}%$
 \noindent The precise response may vary depending
 on the version and platform where you installed Scala. At the Scala
 prompt you can type things like \code{2 + 3}\;\keys{Ret} and
 the output will be
 scala> List(1,2,1).size
 scala> Set(1,2,1).size
 scala> List(1) == List(1)
 scala> Array(1) == Array(1)
 scala> Array(1).sameElements(Array(1))
+\end{lstlisting}
+\noindent
+Also observe carefully what Scala responds in the following
+three instances involving the constant \lstinline!1!---can
+you explain the differences?
+\begin{lstlisting}[numbers=none]
+scala> 1
+scala> 1L
+scala> 1F
 \end{lstlisting}\smallskip
 \noindent
 Please take the Scala REPL seriously: If you want to take advantage of my
 reference implementation for the assignments, you will need to be
 able to ``play around'' with it!
 \end{lstlisting}
 \noindent
 but this seems a bit overkill for a small function like \code{fact}.
 Note that Scala does not have a \code{then}-keyword in an
-\code{if}-statement; and there should be always an \code{else}-branch.
+\code{if}-statement. Also important is that there should be always an
-Never write an \code{if} without an \code{else}, unless you know what
+\code{else}-branch. Never write an \code{if} without an \code{else},
-you are doing! Note also that there are a few other ways of how to
+unless you know what you are doing! While \code{def} is the main
-define a function. We will see some of them in the next sections.
+mechanism for defining functions, there are a few other ways for doing
+this. We will see some of them in the next sections.
 Before we go on, let me explain one tricky point in function
-definitions, especially in larger definitions. What does a Scala function
+definitions, especially in larger definitions. What does a Scala
-actually return? Scala has a \code{return} keyword, but it is
+function return as result? Scala has a \code{return} keyword, but it is
 used for something different than in Java (and C/C++). Therefore please
 make sure no \code{return} slips into your Scala code.
 So in the absence of \code{return}, what value does a Scala function
 actually produce? A rule-of-thumb is whatever is in the last line of the
 \end{lstlisting}
 \noindent In this example the expression \code{s / n} is in the last
 line of the function---so this will be the result the function
 calculates. The two lines before just calculate intermediate values.
-This principle of the ``last-line'' comes in handy when you need to print
+This principle of the ``last-line'' comes in handy when you need to
-out values, for example, for debugging purposes. Suppose you want
+print out values, for example, for debugging purposes. Suppose you want
 rewrite the function as
 \begin{lstlisting}[numbers=none]
 def average(xs: List[Int]) : Int = {
 val s = xs.sum
 \noindent
 Here the function still only returns the expression in the last line.
 The \code{println} before just prints out some information about the
 input of this function, but does not contribute to the result of the
 function. Similarly, the value \code{h} is used in the \code{println}
-but does not contribute to what integer is returned. However note that
+but does not contribute to what integer is returned.
-the idea with the ``last line'' is only a rough rule-of-thumb. A better
-rule might be: the last expression that is evaluated in the function.
+A caveat is that the idea with the ``last line'' is only a rough
-Consider the following version of \code{iaverage}:
+rule-of-thumb. A better rule might be: the last expression that is
+evaluated in the function. Consider the following version of
+\code{average}:
 \begin{lstlisting}[numbers=none]
 def average(xs: List[Int]) : Int = {
 if (xs.length == 0) 0
 else xs.sum / xs.length
 }
 \end{lstlisting}
 \noindent
-What does this function return? Well are two possibilities: either the
+What does this function return? Well there are two possibilities: either
-result of \code{xs.sum / xs.length} in the last line provided the list
+the result of \code{xs.sum / xs.length} in the last line provided the
-\code{xs} is nonempty, \textbf{or} if the list is empty, then it will
+list \code{xs} is nonempty, \textbf{or} if the list is empty, then it
-return \code{0} from the \code{if}-branch (which is technically not the
+will return \code{0} from the \code{if}-branch (which is technically not
-last line, but the last expression evaluated by the function in the
+the last line, but the last expression evaluated by the function in the
 empty-case).
 Summing up, do not use \code{return} in your Scala code! A function
 returns what is evaluated by the function as the last expression. There
 is always only one such last expression. Previous expressions might

changeset 335	7e00d2b13b04
parent 334	841727e27252
child 343	c8fcc0e0a57f