mapValues -> map; 2.13 deprecates mapValues :(

compendium/generated/quiz-w09-mapops-solurows-generated.tex

@@ -4,7 +4,7 @@
   \code|xs(0)                         | & 4 & ~~\Large$\leadsto$~~ &  E & \code|NoSuchElementException| \\ 
   \code|(xs + (0 -> 1)).apply(0)      | & 5 & ~~\Large$\leadsto$~~ &  A & \code|1                     | \\ 
   \code|xs.keySet.apply(2)            | & 6 & ~~\Large$\leadsto$~~ &  J & \code|true                  | \\ 
-  \code|xs.mapValues(v => -v).apply(8)| & 7 & ~~\Large$\leadsto$~~ &  B & \code|-9                    | \\ 
-  \code|xs isDefinedAt 0              | & 8 & ~~\Large$\leadsto$~~ &  G & \code|false                 | \\ 
-  \code|xs.getOrElse(0, 7)            | & 9 & ~~\Large$\leadsto$~~ &  D & \code|7                     | \\ 
-  \code|xs.maxBy(_._2)                | & 10 & ~~\Large$\leadsto$~~ &  I & \code|(16, 17)              | \\ 
+  \code|xs isDefinedAt 0              | & 7 & ~~\Large$\leadsto$~~ &  B & \code|false                 | \\ 
+  \code|xs.getOrElse(0, 7)            | & 8 & ~~\Large$\leadsto$~~ &  G & \code|7                     | \\ 
+  \code|xs.maxBy(_._2)                | & 9 & ~~\Large$\leadsto$~~ &  D & \code|(16, 17)              | \\ 
+  \code|xs.map(p => p._1 -> -p._2)(8) | & 10 & ~~\Large$\leadsto$~~ &  I & \code|-9                    | \\ 

compendium/generated/quiz-w09-mapops-taskrows-generated.tex

@@ -1,10 +1,10 @@
   \code|xs(2) + xs(4)                 | & 1 & & A & \code|1                     | \\ 
-  \code|ys(2) + ys(4)                 | & 2 & & B & \code|-9                    | \\ 
+  \code|ys(2) + ys(4)                 | & 2 & & B & \code|false                 | \\ 
   \code|ys(0)                         | & 3 & & C & \code|8                     | \\ 
-  \code|xs(0)                         | & 4 & & D & \code|7                     | \\ 
+  \code|xs(0)                         | & 4 & & D & \code|(16, 17)              | \\ 
   \code|(xs + (0 -> 1)).apply(0)      | & 5 & & E & \code|NoSuchElementException| \\ 
   \code|xs.keySet.apply(2)            | & 6 & & F & \code|(10, 11)              | \\ 
-  \code|xs.mapValues(v => -v).apply(8)| & 7 & & G & \code|false                 | \\ 
-  \code|xs isDefinedAt 0              | & 8 & & H & \verb|error: type mismatch  | \\ 
-  \code|xs.getOrElse(0, 7)            | & 9 & & I & \code|(16, 17)              | \\ 
-  \code|xs.maxBy(_._2)                | & 10 & & J & \code|true                  | \\ 
+  \code|xs isDefinedAt 0              | & 7 & & G & \code|7                     | \\ 
+  \code|xs.getOrElse(0, 7)            | & 8 & & H & \verb|error: type mismatch  | \\ 
+  \code|xs.maxBy(_._2)                | & 9 & & I & \code|-9                    | \\ 
+  \code|xs.map(p => p._1 -> -p._2)(8) | & 10 & & J & \code|true                  | \\ 

compendium/modules/w09-setmap-exercise.tex

@@ -553,11 +553,11 @@
 \AdvancedTasks %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
 
-\WHAT{Registrering med \code{groupBy} och \code{mapValues}.}
+\WHAT{Registrering med \code{groupBy}.}
 
 \QUESTBEGIN
 
-\Task \what~Vi ska nu utnyttja ett riktigt listigt trick för att via en enda kodrad implementera registrering med hjälp av samlingsmetoden \code{groupBy} och tabellmetoden \code{mapValues}.
+\Task \what~Vi ska nu utnyttja ett riktigt listigt trick för att via en enda kodrad implementera registrering med hjälp av samlingsmetoderna \code{groupBy} och \code{map}.
 
 \Subtask Läs om metoden \code{groupBy} i snabbreferensen. Du hittar den under rubriken \emph{''Methods in trait \code{Traversable[A]}''} eftersom \code{groupBy} fungerar på alla samlingar. Testa \code{groupBy} enligt nedan och beskriv vad som händer.
 
@@ -566,7 +566,7 @@
 scala> val ys = Vector(1, 1, 2, 2, 4, 4, 4).groupBy(x => x)
 \end{REPL}
 
-\Subtask Skapa en funktion \code{freq} med nedan funktionshuvud som returnerar en tabell med antalet förekomster av olika heltal i \code{xs}. Testa \code{freq} på en sekvens av 1000 slumpvisa tärningskast och förklara hur funktionen \code{freq} fungerar. \emph{Tips:} Gör först \code{groupBy(???)} och sedan \code{mapValues(???)}.
+\Subtask Skapa en funktion \code{freq} med nedan funktionshuvud som returnerar en tabell med antalet förekomster av olika heltal i \code{xs}. Testa \code{freq} på en sekvens av 1000 slumpvisa tärningskast och förklara hur funktionen \code{freq} fungerar. \emph{Tips:} Gör först \code{groupBy(???)} och sedan \code{map(???)}.
 
 \begin{Code}
 def freq(xs: Vector[Int]): Map[Int, Int] = ???
@@ -601,9 +601,9 @@
 
 \begin{Code}
 def freq(xs: Vector[Int]): Map[Int, Int] =
-  xs.groupBy(x => x).mapValues(_.size)
+  xs.groupBy(x => x).map(p => p._1 -> p._2.size)
 \end{Code}
-Förklaring: metoden \code{groupBy} skapar en tabell med par \code{k, v} där \code{v} är en sekvens med så många \code{k} som antalet gånger \code{k} förekommer i \code{xs}. Genom att omvandla alla värden \code{v} till storleken av \code{v} får vi en frekvenstabell.
+Förklaring: metoden \code{groupBy} skapar en tabell med par \code{k, v} där \code{v} är en sekvens med så många \code{k} som antalet gånger \code{k} förekommer i \code{xs}. Genom att omvandla alla värden \code{p._2} till storleken \code{p._2.size} får vi en frekvenstabell.
 
 \begin{REPL}
 scala> freq(kasta(1000))

compendium/modules/w09-setmap-lab.tex

@@ -182,7 +182,7 @@ \subsection{Obligatoriska uppgifter}
   else
     /* lägg till (key -> ny frekvenstabell med next) i result*/
 }
-result.mapValues(_.toMap).toMap // returnerar oföränderligt objekt
+result.map(p => p._1 -> p._2.toMap).toMap // returnerar oföränderligt objekt
 \end{Code}
 Skriv uttryck för att ta reda på följande:\Pen
 
@@ -270,23 +270,20 @@ \subsection{Frivilliga uppgifter}
 
 \Subtask Undersök i REPL hur metoden \code{groupBy(x => x)} fungerar då den appliceras på en samling med strängar. Sök efter och studera dokumentationen för \code{groupBy}.
 
-\Subtask Undersök i REPL hur metoden \code{mapValues} fungerar då den appliceras på en nyckel-värde-tabell där värdet är en samling. Sök efter och studera dokumentationen för \code{mapValues}.
-
-\Subtask Inför värdet \code{lazy val wordFreq2}. Den ska ge samma resultat som \code{wordFreq} men men implementeras med hjälp av \code{groupBy} och \code{mapValues} i stället för \code{FreqMapBuilder}.
+\Subtask Inför värdet \code{lazy val wordFreq2}. Den ska ge samma resultat som \code{wordFreq} men men implementeras med hjälp av \code{groupBy} och \code{map} i stället för \code{FreqMapBuilder}.
 
 \Subtask\Uberkurs Jämför prestanda mellan \code{wordFreq2} och \code{wordFreq}. Vilken är snabbast för stora texter? Är skillnaden stor?
 
-\Subtask Inför värdet \code{lazy val followsFreq2}. Den ska ge samma resultat som \code{followsFreq} men implementeras med hjälp av \code{groupBy} och \code{mapValues} i stället för \code{FreqMapBuilder}.
+\Subtask Inför värdet \code{lazy val followsFreq2}. Den ska ge samma resultat som \code{followsFreq} men implementeras med hjälp av \code{groupBy} och \code{map} i stället för \code{FreqMapBuilder}.
 Denna uppgift är ganska knepig. Experimentera dig fram i REPL, och bygg upp en lösning steg för steg. \emph{Tips:}
 \begin{Code}
 bigrams
   .groupBy(???)
-  .mapValues(_.map(???).groupBy(???).mapValues(???))
+  .map(p => p._1 -> p._2.map(???).groupBy(???).map(???))
 \end{Code}
 
 \Subtask\Uberkurs Jämför prestanda mellan \code{followsFreq2} och \code{followsFreq}. Vilken är snabbast för stora texter? Är skillnaden stor?
 
-
 \Task\Uberkurs \emph{Gör \code{FreqMapBuilder} generisk.} Senare i kursen ska vi se hur man kan skapa s.k. generiska datastrukturer med hjälp av typparametrar. Denna uppgift går händelserna i förväg och tjuvkikar på hur en generisk klass kan se ut.
 
 \Subtask Studera \code{FreqMapBuilder} och identifiera allt i den klassen som är specifikt för typen \code{String}.

plan/ideas/lab-sketches.md

@@ -98,7 +98,7 @@ Nytt namn: "pirates"  ???
 * case class Card("Spades", 13) Engelska el. Svenska i strängarna? Ok med svenska i strängarna men namn som kompilatorn ser i koden ska vara på engelska.
 
 * Lägg till registrering så att de får träna på det:
-    * Visa "färdig" myCardMap.groupBy(_.color).mapValues(_.size)  (kanske ska dett göras redan på föreläsning och övning)
+    * Visa "färdig" myCardMap.groupBy(_.color).map(p => p._1 -> p._2.size)  (kanske ska det göras redan på föreläsning och övning)
     * Inplementera egen registrering i en Map så att man kan registrera inte bara på int utan string i (key, value)-par
 
 * Använda wild-card-syntaxen vid metodanrop på collection -> kolla så att detta övas på övningar

quiz/QuizData.scala

@@ -412,10 +412,10 @@ object QuizData {  // to generate tables for a concept connection quizes in late
       "\\code|xs(0)                         |" -> "\\code|NoSuchElementException|",
       "\\code|(xs + (0 -> 1)).apply(0)      |" -> "\\code|1                     |",
       "\\code|xs.keySet.apply(2)            |" -> "\\code|true                  |",
-      "\\code|xs.mapValues(v => -v).apply(8)|" -> "\\code|-9                    |",
       "\\code|xs isDefinedAt 0              |" -> "\\code|false                 |",
       "\\code|xs.getOrElse(0, 7)            |" -> "\\code|7                     |",
       "\\code|xs.maxBy(_._2)                |" -> "\\code|(16, 17)              |",
+      "\\code|xs.map(p => p._1 -> -p._2)(8) |" -> "\\code|-9                    |",
       "" -> ""
     ).filter(_._1.trim.nonEmpty),
 

slides/body/lect-w07-register.tex

@@ -121,7 +121,7 @@
 %
 % scala> val dice = (1 to 1000).map(i => rnd.nextInt(6) + 1)
 %
-% scala> dice.groupBy(i => i).mapValues(_.size)
+% scala> dice.groupBy(i => i).map(p => p._1 -> p._2.size)
 % res0:scala.collection.immutable.Map[Int,Int]= Map(5 -> 155,
 % 1 -> 178, 6 -> 165, 2 -> 187, 3 -> 167, 4 -> 148)
 % \end{REPLnonum}

slides/body/lect-w09-collections.tex

@@ -222,7 +222,7 @@
 \begin{itemize}
 \item \code{xs.keySet} ger en mängd av alla nycklar
 \item \code{xs.map(f)} mappar funktionen f på alla par av (key, value)
-\item \code{xs.mapValues(f)} mappar funktionen f på alla värden
+\item \code{xs.map(p => p._1 -> f(p._2))} mappar funktionen f på alla värden
 \end{itemize}
 \begin{REPL}
 scala> val färg = Map("gurka" -> "grön", "tomat"->"röd", "aubergine"->"lila")
@@ -238,7 +238,7 @@
 scala> val ärGrönSak = färg.map(elem => (elem._1, elem._2 == "grön"))
 ärGrönSak: Map[String,Boolean] = Map(gurka -> true, tomat -> false, aubergine -> false)
 
-scala> val baklängesFärg = färg.mapValues(s => s.reverse)
+scala> val baklängesFärg = färg.map(p => p._1 -> p._2.reverse)
 baklängesFärg: Map[String,String] = Map(gurka -> nörg, tomat -> dör, aubergine -> alil)
 
 \end{REPL}
@@ -524,7 +524,7 @@
 
 
 
-\begin{Slide}{Metoderna zipWithIndex, mapValues, groupBy}
+\begin{Slide}{Metoderna zipWithIndex, groupBy}
 \vspace{-0.5em}
 \begin{REPL}
 scala> val kort = Vector("Knekt", "Dam", "Kung", "Äss")
@@ -535,7 +535,7 @@
 scala> kortIndex("Kung") > kortIndex("Knekt")
 res0: Boolean = true
 
-scala> kortIndex.mapValues(_ + 11)
+scala> kortIndex.map(p => p._1 -> (p._2 + 11))
 
 scala> val tärningskast = Vector(1,2,3,4,5,6,2,4,6)
 
@@ -547,7 +547,7 @@
 grupperaLika: Map[Int,Vector[Int]] = Map(5 -> Vector(5), 1 -> Vector(1),
   6 -> Vector(6, 6), 2 -> Vector(2, 2), 3 -> Vector(3), 4 -> Vector(4, 4))
 
-scala> val frekvens = tärningskast.groupBy(x => x).mapValues(_.size)
+scala> val frekvens = tärningskast.groupBy(x => x).map(p => p._1 -> p._2.size)
 frekvens: Map[Int,Int] = Map(5 -> 1, 1 -> 1, 6 -> 2, 2 -> 2, 3 -> 1, 4 -> 2)
 
 \end{REPL}
@@ -634,7 +634,7 @@
 val bokstäver = ord.toVector.filter(_ != ' ')
 val antalX = bokstäver.count(_ == 'x')
 val grupperade = bokstäver.groupBy(ch => ch)
-val antal = grupperade.mapValues(_.size)
+val antal = grupperade.map(p => p._1 -> p._2.size)
 val sorterat = antal.toVector.sortBy(_._2)
 val vanligast = antal.maxBy(_._2)
 \end{Code}

slides/body/lect-w13-exam-tips.tex

@@ -335,26 +335,6 @@
 \end{itemize}
 \end{Slide}
 
-% \begin{Slide}{Tillåtna uppdateringar i din QuickRef}
-% Du får med egen penna göra dessa fixar i din QuickRef:
-% \begin{itemize}
-% \item Grundtypernas implementation, sid 4:
-% \begin{itemize}
-%
-% \item omfång för Int ska ha exponent 31 (inte 15),
-% \item omfång för Long ska ha exponent 63 (inte 15).
-% \end{itemize}
-%
-% \item Saknade samlingsmetoder:
-% \begin{itemize}
-% \item Under rubriken "Methods in trait Map[K, V]" saknas metoderna keySet och mapValues.
-% \item Saknade metoderna för mutable.ArrayBuffer[T]: \\ \code{update} \code{insert} \code{remove} \code{append} \code{prepend}, etc. \\ lägg till beskrivning på lediga platsen på sista sidan \\
-% (se vidare commit \href{https://github.com/lunduniversity/introprog/commit/a5e29d000062}{a5e29d000062a} i kursrepot)
-% \end{itemize}
-% \end{itemize}
-% \end{Slide}
-
-
 \begin{Slide}{ArrayBuffer}
 Viktigast att känna till: update, insert, remove, append
 {\SlideFontTiny

workspace/w09_words/src/main/scala/nlp/Text.scala

@@ -26,8 +26,6 @@ case class Text(source: String){
     }
     //eller kortare med samma resultat: (lättare eller svårare att läsa?)
     //  followFreq.map(kv => kv._1 -> kv._2.maxBy(_._2)._1)
-    //eller ännu lite kortare men samma resultat: 
-    //  followFreq.view.mapValues(_.maxBy(_._2)._1).toMap
 }
 
 object Text {