diff --git a/build.sbt b/build.sbt
index e08782121..3a085a7b2 100644
--- a/build.sbt
+++ b/build.sbt
@@ -57,7 +57,8 @@ def runPdfLatexCmd(texFile: File, workDir: File, stdOutSuffix: String = "-consol
   // val bibtexCmd = Process(Seq("bibtex", texFile.getName.replace(".tex", ".aux")), workDir)
 
   // run pdflatex command TWICE in sequence to generate toc from .aux etc:
-  val exitValue = cmd.#>(cmdOutputFile).#&&(cmd).#>(cmdOutputFile).run.exitValue
+  //val exitValue = cmd.#>(cmdOutputFile).#&&(cmd).#>(cmdOutputFile).run.exitValue
+  val exitValue = cmd.#>(cmdOutputFile).run.exitValue
   if (exitValue != 0) {
     println("*** ############ ERROR LOG STARTS HERE ############### ***")
     //Process(Seq("cat", cmdOutputFile.getName), workDir).run
@@ -136,7 +137,7 @@ lazy val root = (project in file(".")).
     build := Def.sequential(
       hello,
       (run in Compile in plan).toTask(""),
-//      (run in Compile in quiz).toTask(""),  //decomment if you want re-scrambled quizes
+//    (run in Compile in quiz).toTask(""),  //decomment if you want re-scrambled quizes
       pdf
     ).value
   )
diff --git a/compendium/generated/quiz-w01-concepts-solurows-generated.tex b/compendium/generated/quiz-w01-concepts-solurows-generated.tex
index 24ec8d146..f76c95d39 100644
--- a/compendium/generated/quiz-w01-concepts-solurows-generated.tex
+++ b/compendium/generated/quiz-w01-concepts-solurows-generated.tex
@@ -1,16 +1,16 @@
-  litteral & 1 & ~~\Large$\leadsto$~~ &  G & anger ett specifikt datavärde \\ 
-  sträng & 2 & ~~\Large$\leadsto$~~ &  K & en sekvens av tecken \\ 
-  sats & 3 & ~~\Large$\leadsto$~~ &  C & en kodrad som gör något; kan särskiljas med semikolon \\ 
-  uttryck & 4 & ~~\Large$\leadsto$~~ &  B & kombinerar värden och funktioner till ett nytt värde \\ 
-  funktion & 5 & ~~\Large$\leadsto$~~ &  P & vid anrop beräknas ett returvärde \\ 
-  procedur & 6 & ~~\Large$\leadsto$~~ &  L & vid anrop sker (sido)effekt; returvärdet är tomt \\ 
-  exekveringsfel & 7 & ~~\Large$\leadsto$~~ &  M & sker medan programmet kör \\ 
-  kompileringsfel & 8 & ~~\Large$\leadsto$~~ &  D & sker innan exekveringen startat \\ 
-  abstrahera & 9 & ~~\Large$\leadsto$~~ &  F & att införa nya begrepp som förenklar kodningen \\ 
-  kompilera & 10 & ~~\Large$\leadsto$~~ &  H & att översätta kod till exekverbar form \\ 
-  typ & 11 & ~~\Large$\leadsto$~~ &  A & beskriver vad data kan användas till \\ 
-  for-sats & 12 & ~~\Large$\leadsto$~~ &  E & bra då antalet repetitioner är bestämt i förväg \\ 
-  while-sats & 13 & ~~\Large$\leadsto$~~ &  I & bra då antalet repetitioner ej är bestämt i förväg \\ 
-  tilldelning & 14 & ~~\Large$\leadsto$~~ &  N & för att ändra en variabels värde \\ 
-  flyttal & 15 & ~~\Large$\leadsto$~~ &  J & decimaltal med begränsad noggrannhet \\ 
-  boolesk & 16 & ~~\Large$\leadsto$~~ &  O & antingen sann eller falsk \\ 
\ No newline at end of file
+  litteral & 1 & ~~\Large$\leadsto$~~ &  B & anger ett specifikt datavärde \\ 
+  sträng & 2 & ~~\Large$\leadsto$~~ &  G & en sekvens av tecken \\ 
+  sats & 3 & ~~\Large$\leadsto$~~ &  J & en kodrad som gör något; kan särskiljas med semikolon \\ 
+  uttryck & 4 & ~~\Large$\leadsto$~~ &  K & kombinerar värden och funktioner till ett nytt värde \\ 
+  funktion & 5 & ~~\Large$\leadsto$~~ &  D & vid anrop beräknas ett returvärde \\ 
+  procedur & 6 & ~~\Large$\leadsto$~~ &  E & vid anrop sker (sido)effekt; returvärdet är tomt \\ 
+  exekveringsfel & 7 & ~~\Large$\leadsto$~~ &  A & sker medan programmet kör \\ 
+  kompileringsfel & 8 & ~~\Large$\leadsto$~~ &  L & sker innan exekveringen startat \\ 
+  abstrahera & 9 & ~~\Large$\leadsto$~~ &  I & att införa nya begrepp som förenklar kodningen \\ 
+  kompilera & 10 & ~~\Large$\leadsto$~~ &  O & att översätta kod till exekverbar form \\ 
+  typ & 11 & ~~\Large$\leadsto$~~ &  F & beskriver vad data kan användas till \\ 
+  for-sats & 12 & ~~\Large$\leadsto$~~ &  P & bra då antalet repetitioner är bestämt i förväg \\ 
+  while-sats & 13 & ~~\Large$\leadsto$~~ &  N & bra då antalet repetitioner ej är bestämt i förväg \\ 
+  tilldelning & 14 & ~~\Large$\leadsto$~~ &  M & för att ändra en variabels värde \\ 
+  flyttal & 15 & ~~\Large$\leadsto$~~ &  C & decimaltal med begränsad noggrannhet \\ 
+  boolesk & 16 & ~~\Large$\leadsto$~~ &  H & antingen sann eller falsk \\ 
\ No newline at end of file
diff --git a/compendium/generated/quiz-w01-concepts-taskrows-generated.tex b/compendium/generated/quiz-w01-concepts-taskrows-generated.tex
index 1e0edc795..3610cde64 100644
--- a/compendium/generated/quiz-w01-concepts-taskrows-generated.tex
+++ b/compendium/generated/quiz-w01-concepts-taskrows-generated.tex
@@ -1,16 +1,16 @@
-  litteral & 1 & & A & beskriver vad data kan användas till \\ 
-  sträng & 2 & & B & kombinerar värden och funktioner till ett nytt värde \\ 
-  sats & 3 & & C & en kodrad som gör något; kan särskiljas med semikolon \\ 
-  uttryck & 4 & & D & sker innan exekveringen startat \\ 
-  funktion & 5 & & E & bra då antalet repetitioner är bestämt i förväg \\ 
-  procedur & 6 & & F & att införa nya begrepp som förenklar kodningen \\ 
-  exekveringsfel & 7 & & G & anger ett specifikt datavärde \\ 
-  kompileringsfel & 8 & & H & att översätta kod till exekverbar form \\ 
-  abstrahera & 9 & & I & bra då antalet repetitioner ej är bestämt i förväg \\ 
-  kompilera & 10 & & J & decimaltal med begränsad noggrannhet \\ 
-  typ & 11 & & K & en sekvens av tecken \\ 
-  for-sats & 12 & & L & vid anrop sker (sido)effekt; returvärdet är tomt \\ 
-  while-sats & 13 & & M & sker medan programmet kör \\ 
-  tilldelning & 14 & & N & för att ändra en variabels värde \\ 
-  flyttal & 15 & & O & antingen sann eller falsk \\ 
-  boolesk & 16 & & P & vid anrop beräknas ett returvärde \\ 
\ No newline at end of file
+  litteral & 1 & & A & sker medan programmet kör \\ 
+  sträng & 2 & & B & anger ett specifikt datavärde \\ 
+  sats & 3 & & C & decimaltal med begränsad noggrannhet \\ 
+  uttryck & 4 & & D & vid anrop beräknas ett returvärde \\ 
+  funktion & 5 & & E & vid anrop sker (sido)effekt; returvärdet är tomt \\ 
+  procedur & 6 & & F & beskriver vad data kan användas till \\ 
+  exekveringsfel & 7 & & G & en sekvens av tecken \\ 
+  kompileringsfel & 8 & & H & antingen sann eller falsk \\ 
+  abstrahera & 9 & & I & att införa nya begrepp som förenklar kodningen \\ 
+  kompilera & 10 & & J & en kodrad som gör något; kan särskiljas med semikolon \\ 
+  typ & 11 & & K & kombinerar värden och funktioner till ett nytt värde \\ 
+  for-sats & 12 & & L & sker innan exekveringen startat \\ 
+  while-sats & 13 & & M & för att ändra en variabels värde \\ 
+  tilldelning & 14 & & N & bra då antalet repetitioner ej är bestämt i förväg \\ 
+  flyttal & 15 & & O & att översätta kod till exekverbar form \\ 
+  boolesk & 16 & & P & bra då antalet repetitioner är bestämt i förväg \\ 
\ No newline at end of file
diff --git a/compendium/generated/quiz-w01-intdiv-solurows-generated.tex b/compendium/generated/quiz-w01-intdiv-solurows-generated.tex
index ba7ff3fa1..3ecba31fd 100644
--- a/compendium/generated/quiz-w01-intdiv-solurows-generated.tex
+++ b/compendium/generated/quiz-w01-intdiv-solurows-generated.tex
@@ -1,7 +1,7 @@
-  \code| 4 / 42      | & 1 & ~~\Large$\leadsto$~~ &  C & \code|    0: Int      | \\ 
-  \code| 42.0 / 2    | & 2 & ~~\Large$\leadsto$~~ &  B & \code| 10.5: Double   | \\ 
-  \code| 42 / 4      | & 3 & ~~\Large$\leadsto$~~ &  F & \code|   10: Int      | \\ 
-  \code| 42 % 4      | & 4 & ~~\Large$\leadsto$~~ &  G & \code|    2: Int      | \\ 
-  \code| 4 % 42      | & 5 & ~~\Large$\leadsto$~~ &  D & \code|    4: Int      | \\ 
-  \code| 40 % 4 == 0 | & 6 & ~~\Large$\leadsto$~~ &  E & \code|true : Boolean  | \\ 
-  \code| 42 % 4 == 0 | & 7 & ~~\Large$\leadsto$~~ &  A & \code|false: Boolean  | \\ 
\ No newline at end of file
+  \code| 4 / 42      | & 1 & ~~\Large$\leadsto$~~ &  G & \code|    0: Int      | \\ 
+  \code| 42.0 / 2    | & 2 & ~~\Large$\leadsto$~~ &  D & \code| 10.5: Double   | \\ 
+  \code| 42 / 4      | & 3 & ~~\Large$\leadsto$~~ &  A & \code|   10: Int      | \\ 
+  \code| 42 % 4      | & 4 & ~~\Large$\leadsto$~~ &  F & \code|    2: Int      | \\ 
+  \code| 4 % 42      | & 5 & ~~\Large$\leadsto$~~ &  B & \code|    4: Int      | \\ 
+  \code| 40 % 4 == 0 | & 6 & ~~\Large$\leadsto$~~ &  C & \code|true : Boolean  | \\ 
+  \code| 42 % 4 == 0 | & 7 & ~~\Large$\leadsto$~~ &  E & \code|false: Boolean  | \\ 
\ No newline at end of file
diff --git a/compendium/generated/quiz-w01-intdiv-taskrows-generated.tex b/compendium/generated/quiz-w01-intdiv-taskrows-generated.tex
index 5722835b5..aa9ce3db5 100644
--- a/compendium/generated/quiz-w01-intdiv-taskrows-generated.tex
+++ b/compendium/generated/quiz-w01-intdiv-taskrows-generated.tex
@@ -1,7 +1,7 @@
-  \code| 4 / 42      | & 1 & & A & \code|false: Boolean  | \\ 
-  \code| 42.0 / 2    | & 2 & & B & \code| 10.5: Double   | \\ 
-  \code| 42 / 4      | & 3 & & C & \code|    0: Int      | \\ 
-  \code| 42 % 4      | & 4 & & D & \code|    4: Int      | \\ 
-  \code| 4 % 42      | & 5 & & E & \code|true : Boolean  | \\ 
-  \code| 40 % 4 == 0 | & 6 & & F & \code|   10: Int      | \\ 
-  \code| 42 % 4 == 0 | & 7 & & G & \code|    2: Int      | \\ 
\ No newline at end of file
+  \code| 4 / 42      | & 1 & & A & \code|   10: Int      | \\ 
+  \code| 42.0 / 2    | & 2 & & B & \code|    4: Int      | \\ 
+  \code| 42 / 4      | & 3 & & C & \code|true : Boolean  | \\ 
+  \code| 42 % 4      | & 4 & & D & \code| 10.5: Double   | \\ 
+  \code| 4 % 42      | & 5 & & E & \code|false: Boolean  | \\ 
+  \code| 40 % 4 == 0 | & 6 & & F & \code|    2: Int      | \\ 
+  \code| 42 % 4 == 0 | & 7 & & G & \code|    0: Int      | \\ 
\ No newline at end of file
diff --git a/compendium/generated/quiz-w01-types-solurows-generated.tex b/compendium/generated/quiz-w01-types-solurows-generated.tex
index 5493a8262..f30c5bb33 100644
--- a/compendium/generated/quiz-w01-types-solurows-generated.tex
+++ b/compendium/generated/quiz-w01-types-solurows-generated.tex
@@ -1,10 +1,10 @@
-  \code|1    | & 1 & ~~\Large$\leadsto$~~ &  B & \code|Int    | \\ 
-  \code|1L   | & 2 & ~~\Large$\leadsto$~~ &  J & \code|Long   | \\ 
-  \code|1.0  | & 3 & ~~\Large$\leadsto$~~ &  E & \code|Double | \\ 
-  \code|1D   | & 4 & ~~\Large$\leadsto$~~ &  F & \code|Double | \\ 
+  \code|1    | & 1 & ~~\Large$\leadsto$~~ &  F & \code|Int    | \\ 
+  \code|1L   | & 2 & ~~\Large$\leadsto$~~ &  B & \code|Long   | \\ 
+  \code|1.0  | & 3 & ~~\Large$\leadsto$~~ &  I & \code|Double | \\ 
+  \code|1D   | & 4 & ~~\Large$\leadsto$~~ &  H & \code|Double | \\ 
   \code|1F   | & 5 & ~~\Large$\leadsto$~~ &  A & \code|Float  | \\ 
-  \code|'1'  | & 6 & ~~\Large$\leadsto$~~ &  I & \code|Char   | \\ 
-  \code|"1"| & 7 & ~~\Large$\leadsto$~~ &  G & \code|String | \\ 
-  \code|true | & 8 & ~~\Large$\leadsto$~~ &  C & \code|Boolean| \\ 
-  \code|false| & 9 & ~~\Large$\leadsto$~~ &  H & \code|Boolean| \\ 
-  \code|()   | & 10 & ~~\Large$\leadsto$~~ &  D & \code|Unit   | \\ 
\ No newline at end of file
+  \code|'1'  | & 6 & ~~\Large$\leadsto$~~ &  D & \code|Char   | \\ 
+  \code|"1"| & 7 & ~~\Large$\leadsto$~~ &  C & \code|String | \\ 
+  \code|true | & 8 & ~~\Large$\leadsto$~~ &  E & \code|Boolean| \\ 
+  \code|false| & 9 & ~~\Large$\leadsto$~~ &  J & \code|Boolean| \\ 
+  \code|()   | & 10 & ~~\Large$\leadsto$~~ &  G & \code|Unit   | \\ 
\ No newline at end of file
diff --git a/compendium/generated/quiz-w01-types-taskrows-generated.tex b/compendium/generated/quiz-w01-types-taskrows-generated.tex
index abd1d698a..7f251ba2e 100644
--- a/compendium/generated/quiz-w01-types-taskrows-generated.tex
+++ b/compendium/generated/quiz-w01-types-taskrows-generated.tex
@@ -1,10 +1,10 @@
   \code|1    | & 1 & & A & \code|Float  | \\ 
-  \code|1L   | & 2 & & B & \code|Int    | \\ 
-  \code|1.0  | & 3 & & C & \code|Boolean| \\ 
-  \code|1D   | & 4 & & D & \code|Unit   | \\ 
-  \code|1F   | & 5 & & E & \code|Double | \\ 
-  \code|'1'  | & 6 & & F & \code|Double | \\ 
-  \code|"1"| & 7 & & G & \code|String | \\ 
-  \code|true | & 8 & & H & \code|Boolean| \\ 
-  \code|false| & 9 & & I & \code|Char   | \\ 
-  \code|()   | & 10 & & J & \code|Long   | \\ 
\ No newline at end of file
+  \code|1L   | & 2 & & B & \code|Long   | \\ 
+  \code|1.0  | & 3 & & C & \code|String | \\ 
+  \code|1D   | & 4 & & D & \code|Char   | \\ 
+  \code|1F   | & 5 & & E & \code|Boolean| \\ 
+  \code|'1'  | & 6 & & F & \code|Int    | \\ 
+  \code|"1"| & 7 & & G & \code|Unit   | \\ 
+  \code|true | & 8 & & H & \code|Double | \\ 
+  \code|false| & 9 & & I & \code|Double | \\ 
+  \code|()   | & 10 & & J & \code|Boolean| \\ 
\ No newline at end of file
diff --git a/compendium/generated/quiz-w01-values-solurows-generated.tex b/compendium/generated/quiz-w01-values-solurows-generated.tex
index 1f0d76841..a2d6cc5a3 100644
--- a/compendium/generated/quiz-w01-values-solurows-generated.tex
+++ b/compendium/generated/quiz-w01-values-solurows-generated.tex
@@ -1,12 +1,12 @@
-  \code|1.0 + 18          | & 1 & ~~\Large$\leadsto$~~ &  J & \code|19.0: Double    | \\ 
-  \code|(41 + 1).toDouble | & 2 & ~~\Large$\leadsto$~~ &  H & \code|42.0: Double    | \\ 
-  \code|1.042e42 + 1      | & 3 & ~~\Large$\leadsto$~~ &  C & \code|1.042E42: Double| \\ 
-  \code|12E6.toLong       | & 4 & ~~\Large$\leadsto$~~ &  I & \code|12000000: Long  | \\ 
-  \code|32.toChar.toString| & 5 & ~~\Large$\leadsto$~~ &  E & \code|" ": String   | \\ 
-  \code|'A'.toInt         | & 6 & ~~\Large$\leadsto$~~ &  K & \code|65: Int         | \\ 
-  \code|0.toInt           | & 7 & ~~\Large$\leadsto$~~ &  F & \code|0: Int          | \\ 
-  \code|'0'.toInt         | & 8 & ~~\Large$\leadsto$~~ &  G & \code|48: Int         | \\ 
-  \code|'9'.toInt         | & 9 & ~~\Large$\leadsto$~~ &  A & \code|57: Int         | \\ 
-  \code|'A' + '0'         | & 10 & ~~\Large$\leadsto$~~ &  B & \code|113: Int        | \\ 
-  \code|('A' + '0').toChar| & 11 & ~~\Large$\leadsto$~~ &  L & \code|'q': Char       | \\ 
-  \code|"*!%#".charAt(0)| & 12 & ~~\Large$\leadsto$~~ &  D & \code|'*': Char       | \\ 
\ No newline at end of file
+  \code|1.0 + 18          | & 1 & ~~\Large$\leadsto$~~ &  C & \code|19.0: Double    | \\ 
+  \code|(41 + 1).toDouble | & 2 & ~~\Large$\leadsto$~~ &  A & \code|42.0: Double    | \\ 
+  \code|1.042e42 + 1      | & 3 & ~~\Large$\leadsto$~~ &  H & \code|1.042E42: Double| \\ 
+  \code|12E6.toLong       | & 4 & ~~\Large$\leadsto$~~ &  D & \code|12000000: Long  | \\ 
+  \code|32.toChar.toString| & 5 & ~~\Large$\leadsto$~~ &  G & \code|" ": String   | \\ 
+  \code|'A'.toInt         | & 6 & ~~\Large$\leadsto$~~ &  B & \code|65: Int         | \\ 
+  \code|0.toInt           | & 7 & ~~\Large$\leadsto$~~ &  K & \code|0: Int          | \\ 
+  \code|'0'.toInt         | & 8 & ~~\Large$\leadsto$~~ &  F & \code|48: Int         | \\ 
+  \code|'9'.toInt         | & 9 & ~~\Large$\leadsto$~~ &  L & \code|57: Int         | \\ 
+  \code|'A' + '0'         | & 10 & ~~\Large$\leadsto$~~ &  J & \code|113: Int        | \\ 
+  \code|('A' + '0').toChar| & 11 & ~~\Large$\leadsto$~~ &  I & \code|'q': Char       | \\ 
+  \code|"*!%#".charAt(0)| & 12 & ~~\Large$\leadsto$~~ &  E & \code|'*': Char       | \\ 
\ No newline at end of file
diff --git a/compendium/generated/quiz-w01-values-taskrows-generated.tex b/compendium/generated/quiz-w01-values-taskrows-generated.tex
index dc3652f88..cb542e0d7 100644
--- a/compendium/generated/quiz-w01-values-taskrows-generated.tex
+++ b/compendium/generated/quiz-w01-values-taskrows-generated.tex
@@ -1,12 +1,12 @@
-  \code|1.0 + 18          | & 1 & & A & \code|57: Int         | \\ 
-  \code|(41 + 1).toDouble | & 2 & & B & \code|113: Int        | \\ 
-  \code|1.042e42 + 1      | & 3 & & C & \code|1.042E42: Double| \\ 
-  \code|12E6.toLong       | & 4 & & D & \code|'*': Char       | \\ 
-  \code|32.toChar.toString| & 5 & & E & \code|" ": String   | \\ 
-  \code|'A'.toInt         | & 6 & & F & \code|0: Int          | \\ 
-  \code|0.toInt           | & 7 & & G & \code|48: Int         | \\ 
-  \code|'0'.toInt         | & 8 & & H & \code|42.0: Double    | \\ 
-  \code|'9'.toInt         | & 9 & & I & \code|12000000: Long  | \\ 
-  \code|'A' + '0'         | & 10 & & J & \code|19.0: Double    | \\ 
-  \code|('A' + '0').toChar| & 11 & & K & \code|65: Int         | \\ 
-  \code|"*!%#".charAt(0)| & 12 & & L & \code|'q': Char       | \\ 
\ No newline at end of file
+  \code|1.0 + 18          | & 1 & & A & \code|42.0: Double    | \\ 
+  \code|(41 + 1).toDouble | & 2 & & B & \code|65: Int         | \\ 
+  \code|1.042e42 + 1      | & 3 & & C & \code|19.0: Double    | \\ 
+  \code|12E6.toLong       | & 4 & & D & \code|12000000: Long  | \\ 
+  \code|32.toChar.toString| & 5 & & E & \code|'*': Char       | \\ 
+  \code|'A'.toInt         | & 6 & & F & \code|48: Int         | \\ 
+  \code|0.toInt           | & 7 & & G & \code|" ": String   | \\ 
+  \code|'0'.toInt         | & 8 & & H & \code|1.042E42: Double| \\ 
+  \code|'9'.toInt         | & 9 & & I & \code|'q': Char       | \\ 
+  \code|'A' + '0'         | & 10 & & J & \code|113: Int        | \\ 
+  \code|('A' + '0').toChar| & 11 & & K & \code|0: Int          | \\ 
+  \code|"*!%#".charAt(0)| & 12 & & L & \code|57: Int         | \\ 
\ No newline at end of file
diff --git a/compendium/generated/quiz-w02-array-vector-equality-solurows-generated.tex b/compendium/generated/quiz-w02-array-vector-equality-solurows-generated.tex
index 0f109bedf..61642aa8d 100644
--- a/compendium/generated/quiz-w02-array-vector-equality-solurows-generated.tex
+++ b/compendium/generated/quiz-w02-array-vector-equality-solurows-generated.tex
@@ -1,2 +1,2 @@
   Vector & 1 & ~~\Large$\leadsto$~~ &  A & \code|xs == ys| är \code|true| om alla element lika \\ 
-  Array & 2 & ~~\Large$\leadsto$~~ &  B & olikt andra samlingar kollar \code|==| ej innehållslikhet \\ 
\ No newline at end of file
+  Array & 2 & ~~\Large$\leadsto$~~ &  B & olikt andra Scala-samlingar kollar \code|==| ej innehållslikhet \\ 
\ No newline at end of file
diff --git a/compendium/generated/quiz-w02-array-vector-equality-taskrows-generated.tex b/compendium/generated/quiz-w02-array-vector-equality-taskrows-generated.tex
index df9405246..db9b55efc 100644
--- a/compendium/generated/quiz-w02-array-vector-equality-taskrows-generated.tex
+++ b/compendium/generated/quiz-w02-array-vector-equality-taskrows-generated.tex
@@ -1,2 +1,2 @@
   Vector & 1 & & A & \code|xs == ys| är \code|true| om alla element lika \\ 
-  Array & 2 & & B & olikt andra samlingar kollar \code|==| ej innehållslikhet \\ 
\ No newline at end of file
+  Array & 2 & & B & olikt andra Scala-samlingar kollar \code|==| ej innehållslikhet \\ 
\ No newline at end of file
diff --git a/compendium/generated/quiz-w02-array-vector-mutability-solurows-generated.tex b/compendium/generated/quiz-w02-array-vector-mutability-solurows-generated.tex
index ac84b1ca9..01942cc9f 100644
--- a/compendium/generated/quiz-w02-array-vector-mutability-solurows-generated.tex
+++ b/compendium/generated/quiz-w02-array-vector-mutability-solurows-generated.tex
@@ -1,2 +1,2 @@
-  Vector & 1 & ~~\Large$\leadsto$~~ &  B & oföränderlig \\ 
-  Array & 2 & ~~\Large$\leadsto$~~ &  A & förändringsbar \\ 
\ No newline at end of file
+  Vector & 1 & ~~\Large$\leadsto$~~ &  A & oföränderlig \\ 
+  Array & 2 & ~~\Large$\leadsto$~~ &  B & förändringsbar \\ 
\ No newline at end of file
diff --git a/compendium/generated/quiz-w02-array-vector-mutability-taskrows-generated.tex b/compendium/generated/quiz-w02-array-vector-mutability-taskrows-generated.tex
index 321cef6c2..697bbfe14 100644
--- a/compendium/generated/quiz-w02-array-vector-mutability-taskrows-generated.tex
+++ b/compendium/generated/quiz-w02-array-vector-mutability-taskrows-generated.tex
@@ -1,2 +1,2 @@
-  Vector & 1 & & A & förändringsbar \\ 
-  Array & 2 & & B & oföränderlig \\ 
\ No newline at end of file
+  Vector & 1 & & A & oföränderlig \\ 
+  Array & 2 & & B & förändringsbar \\ 
\ No newline at end of file
diff --git a/compendium/generated/quiz-w02-collection-methods-solurows-generated.tex b/compendium/generated/quiz-w02-collection-methods-solurows-generated.tex
index 79de5b4bb..31acc49d1 100644
--- a/compendium/generated/quiz-w02-collection-methods-solurows-generated.tex
+++ b/compendium/generated/quiz-w02-collection-methods-solurows-generated.tex
@@ -1,11 +1,11 @@
-  \code|val xs = Vector(2) | & 1 & ~~\Large$\leadsto$~~ &  J & ny referens till sekvens av längd 1 \\ 
-  \code|Array.fill(9)(0)   | & 2 & ~~\Large$\leadsto$~~ &  E & ny förändringsbar sekvens med nollor \\ 
+  \code|val xs = Vector(2) | & 1 & ~~\Large$\leadsto$~~ &  B & ny referens till sekvens av längd 1 \\ 
+  \code|Array.fill(9)(0)   | & 2 & ~~\Large$\leadsto$~~ &  H & ny förändringsbar sekvens med nollor \\ 
   \code|Vector.fill(9)(' ')| & 3 & ~~\Large$\leadsto$~~ &  C & ny oföränderlig sekvens med blanktecken \\ 
-  \code|xs(0)              | & 4 & ~~\Large$\leadsto$~~ &  I & förkortad skrivning av \code|apply(0)| \\ 
-  \code|xs.apply(0)        | & 5 & ~~\Large$\leadsto$~~ &  F & indexering, ger första elementet \\ 
-  \code|xs :+ 0            | & 6 & ~~\Large$\leadsto$~~ &  D & ny samling med en nolla tillagd på slutet \\ 
-  \code|0 +: xs            | & 7 & ~~\Large$\leadsto$~~ &  A & ny samling med en nolla tillagd i början \\ 
-  \code|xs.mkString        | & 8 & ~~\Large$\leadsto$~~ &  G & ny sträng med alla element intill varandra \\ 
-  \code|xs.mkString(",") | & 9 & ~~\Large$\leadsto$~~ &  H & ny sträng med komma mellan elementen \\ 
-  \code|xs.map(_.toString))| & 10 & ~~\Large$\leadsto$~~ &  B & ny samling, elementen omgjorda till strängar \\ 
-  \code|xs.map(_.toInt))   | & 11 & ~~\Large$\leadsto$~~ &  K & ny samling, elementen omgjorda till heltal \\ 
\ No newline at end of file
+  \code|xs(0)              | & 4 & ~~\Large$\leadsto$~~ &  G & förkortad skrivning av \code|apply(0)| \\ 
+  \code|xs.apply(0)        | & 5 & ~~\Large$\leadsto$~~ &  E & indexering, ger första elementet \\ 
+  \code|xs :+ 0            | & 6 & ~~\Large$\leadsto$~~ &  K & ny samling med en nolla tillagd på slutet \\ 
+  \code|0 +: xs            | & 7 & ~~\Large$\leadsto$~~ &  I & ny samling med en nolla tillagd i början \\ 
+  \code|xs.mkString        | & 8 & ~~\Large$\leadsto$~~ &  F & ny sträng med alla element intill varandra \\ 
+  \code|xs.mkString(",") | & 9 & ~~\Large$\leadsto$~~ &  D & ny sträng med komma mellan elementen \\ 
+  \code|xs.map(_.toString))| & 10 & ~~\Large$\leadsto$~~ &  J & ny samling, elementen omgjorda till strängar \\ 
+  \code|xs.map(_.toInt))   | & 11 & ~~\Large$\leadsto$~~ &  A & ny samling, elementen omgjorda till heltal \\ 
\ No newline at end of file
diff --git a/compendium/generated/quiz-w02-collection-methods-taskrows-generated.tex b/compendium/generated/quiz-w02-collection-methods-taskrows-generated.tex
index b133e9fcb..de7a08bbb 100644
--- a/compendium/generated/quiz-w02-collection-methods-taskrows-generated.tex
+++ b/compendium/generated/quiz-w02-collection-methods-taskrows-generated.tex
@@ -1,11 +1,11 @@
-  \code|val xs = Vector(2) | & 1 & & A & ny samling med en nolla tillagd i början \\ 
-  \code|Array.fill(9)(0)   | & 2 & & B & ny samling, elementen omgjorda till strängar \\ 
+  \code|val xs = Vector(2) | & 1 & & A & ny samling, elementen omgjorda till heltal \\ 
+  \code|Array.fill(9)(0)   | & 2 & & B & ny referens till sekvens av längd 1 \\ 
   \code|Vector.fill(9)(' ')| & 3 & & C & ny oföränderlig sekvens med blanktecken \\ 
-  \code|xs(0)              | & 4 & & D & ny samling med en nolla tillagd på slutet \\ 
-  \code|xs.apply(0)        | & 5 & & E & ny förändringsbar sekvens med nollor \\ 
-  \code|xs :+ 0            | & 6 & & F & indexering, ger första elementet \\ 
-  \code|0 +: xs            | & 7 & & G & ny sträng med alla element intill varandra \\ 
-  \code|xs.mkString        | & 8 & & H & ny sträng med komma mellan elementen \\ 
-  \code|xs.mkString(",") | & 9 & & I & förkortad skrivning av \code|apply(0)| \\ 
-  \code|xs.map(_.toString))| & 10 & & J & ny referens till sekvens av längd 1 \\ 
-  \code|xs.map(_.toInt))   | & 11 & & K & ny samling, elementen omgjorda till heltal \\ 
\ No newline at end of file
+  \code|xs(0)              | & 4 & & D & ny sträng med komma mellan elementen \\ 
+  \code|xs.apply(0)        | & 5 & & E & indexering, ger första elementet \\ 
+  \code|xs :+ 0            | & 6 & & F & ny sträng med alla element intill varandra \\ 
+  \code|0 +: xs            | & 7 & & G & förkortad skrivning av \code|apply(0)| \\ 
+  \code|xs.mkString        | & 8 & & H & ny förändringsbar sekvens med nollor \\ 
+  \code|xs.mkString(",") | & 9 & & I & ny samling med en nolla tillagd i början \\ 
+  \code|xs.map(_.toString))| & 10 & & J & ny samling, elementen omgjorda till strängar \\ 
+  \code|xs.map(_.toInt))   | & 11 & & K & ny samling med en nolla tillagd på slutet \\ 
\ No newline at end of file
diff --git a/compendium/generated/quiz-w02-concepts-solurows-generated.tex b/compendium/generated/quiz-w02-concepts-solurows-generated.tex
index 13dd87660..3df5c7865 100644
--- a/compendium/generated/quiz-w02-concepts-solurows-generated.tex
+++ b/compendium/generated/quiz-w02-concepts-solurows-generated.tex
@@ -1,15 +1,15 @@
-  kompilerad & 1 & ~~\Large$\leadsto$~~ &  L & maskinkod sparad och kan köras igen utan kompilering \\ 
-  skript & 2 & ~~\Large$\leadsto$~~ &  D & maskinkod sparas ej utan skapas vid varje körning \\ 
-  objekt & 3 & ~~\Large$\leadsto$~~ &  G & samlar variabler och funktioner \\ 
-  main & 4 & ~~\Large$\leadsto$~~ &  N & där exekveringen av kompilerad app startar \\ 
-  programargument & 5 & ~~\Large$\leadsto$~~ &  O & överförs via parametern args i main \\ 
-  datastruktur & 6 & ~~\Large$\leadsto$~~ &  F & många olika element i en helhet; elementvis åtkomst \\ 
-  samling & 7 & ~~\Large$\leadsto$~~ &  B & datastruktur med element av samma typ \\ 
-  sekvenssamling & 8 & ~~\Large$\leadsto$~~ &  M & datastruktur med element i en viss ordning \\ 
-  Array & 9 & ~~\Large$\leadsto$~~ &  C & en förändringsbar, indexerbar sekvenssamling \\ 
-  Vector & 10 & ~~\Large$\leadsto$~~ &  A & en oföränderlig, indexerbar sekvenssamling \\ 
-  Range & 11 & ~~\Large$\leadsto$~~ &  H & en samling som representerar ett intervall av heltal \\ 
+  kompilerad & 1 & ~~\Large$\leadsto$~~ &  N & maskinkod sparad och kan köras igen utan kompilering \\ 
+  skript & 2 & ~~\Large$\leadsto$~~ &  G & maskinkod sparas ej utan skapas vid varje körning \\ 
+  objekt & 3 & ~~\Large$\leadsto$~~ &  C & samlar variabler och funktioner \\ 
+  main & 4 & ~~\Large$\leadsto$~~ &  D & där exekveringen av kompilerad app startar \\ 
+  programargument & 5 & ~~\Large$\leadsto$~~ &  F & överförs via parametern args i main \\ 
+  datastruktur & 6 & ~~\Large$\leadsto$~~ &  L & många olika element i en helhet; elementvis åtkomst \\ 
+  samling & 7 & ~~\Large$\leadsto$~~ &  E & datastruktur med element av samma typ \\ 
+  sekvenssamling & 8 & ~~\Large$\leadsto$~~ &  K & datastruktur med element i en viss ordning \\ 
+  Array & 9 & ~~\Large$\leadsto$~~ &  J & en förändringsbar, indexerbar sekvenssamling \\ 
+  Vector & 10 & ~~\Large$\leadsto$~~ &  O & en oföränderlig, indexerbar sekvenssamling \\ 
+  Range & 11 & ~~\Large$\leadsto$~~ &  M & en samling som representerar ett intervall av heltal \\ 
   yield & 12 & ~~\Large$\leadsto$~~ &  I & används i for-uttryck för att skapa ny samling \\ 
-  map & 13 & ~~\Large$\leadsto$~~ &  E & applicerar en funktion på varje element i en samling \\ 
-  algoritm & 14 & ~~\Large$\leadsto$~~ &  K & stegvis beskrivning av en lösning på ett problem \\ 
-  implementation & 15 & ~~\Large$\leadsto$~~ &  J & en specifik realisering av en algoritm \\ 
\ No newline at end of file
+  map & 13 & ~~\Large$\leadsto$~~ &  A & applicerar en funktion på varje element i en samling \\ 
+  algoritm & 14 & ~~\Large$\leadsto$~~ &  H & stegvis beskrivning av en lösning på ett problem \\ 
+  implementation & 15 & ~~\Large$\leadsto$~~ &  B & en specifik realisering av en algoritm \\ 
\ No newline at end of file
diff --git a/compendium/generated/quiz-w02-concepts-taskrows-generated.tex b/compendium/generated/quiz-w02-concepts-taskrows-generated.tex
index bf9fd96b0..67231ae49 100644
--- a/compendium/generated/quiz-w02-concepts-taskrows-generated.tex
+++ b/compendium/generated/quiz-w02-concepts-taskrows-generated.tex
@@ -1,15 +1,15 @@
-  kompilerad & 1 & & A & en oföränderlig, indexerbar sekvenssamling \\ 
-  skript & 2 & & B & datastruktur med element av samma typ \\ 
-  objekt & 3 & & C & en förändringsbar, indexerbar sekvenssamling \\ 
-  main & 4 & & D & maskinkod sparas ej utan skapas vid varje körning \\ 
-  programargument & 5 & & E & applicerar en funktion på varje element i en samling \\ 
-  datastruktur & 6 & & F & många olika element i en helhet; elementvis åtkomst \\ 
-  samling & 7 & & G & samlar variabler och funktioner \\ 
-  sekvenssamling & 8 & & H & en samling som representerar ett intervall av heltal \\ 
+  kompilerad & 1 & & A & applicerar en funktion på varje element i en samling \\ 
+  skript & 2 & & B & en specifik realisering av en algoritm \\ 
+  objekt & 3 & & C & samlar variabler och funktioner \\ 
+  main & 4 & & D & där exekveringen av kompilerad app startar \\ 
+  programargument & 5 & & E & datastruktur med element av samma typ \\ 
+  datastruktur & 6 & & F & överförs via parametern args i main \\ 
+  samling & 7 & & G & maskinkod sparas ej utan skapas vid varje körning \\ 
+  sekvenssamling & 8 & & H & stegvis beskrivning av en lösning på ett problem \\ 
   Array & 9 & & I & används i for-uttryck för att skapa ny samling \\ 
-  Vector & 10 & & J & en specifik realisering av en algoritm \\ 
-  Range & 11 & & K & stegvis beskrivning av en lösning på ett problem \\ 
-  yield & 12 & & L & maskinkod sparad och kan köras igen utan kompilering \\ 
-  map & 13 & & M & datastruktur med element i en viss ordning \\ 
-  algoritm & 14 & & N & där exekveringen av kompilerad app startar \\ 
-  implementation & 15 & & O & överförs via parametern args i main \\ 
\ No newline at end of file
+  Vector & 10 & & J & en förändringsbar, indexerbar sekvenssamling \\ 
+  Range & 11 & & K & datastruktur med element i en viss ordning \\ 
+  yield & 12 & & L & många olika element i en helhet; elementvis åtkomst \\ 
+  map & 13 & & M & en samling som representerar ett intervall av heltal \\ 
+  algoritm & 14 & & N & maskinkod sparad och kan köras igen utan kompilering \\ 
+  implementation & 15 & & O & en oföränderlig, indexerbar sekvenssamling \\ 
\ No newline at end of file
diff --git a/compendium/generated/quiz-w02-for-yield-map-solurows-generated.tex b/compendium/generated/quiz-w02-for-yield-map-solurows-generated.tex
index 6d3781196..82c1d603e 100644
--- a/compendium/generated/quiz-w02-for-yield-map-solurows-generated.tex
+++ b/compendium/generated/quiz-w02-for-yield-map-solurows-generated.tex
@@ -1,6 +1,6 @@
-  \code|for (x <- xs) yield x * 2| & 1 & ~~\Large$\leadsto$~~ &  A & \code|Vector(1, 2, 4)| \\ 
-  \code|for (i <- xs.indices) yield i| & 2 & ~~\Large$\leadsto$~~ &  D & \code|Vector(0, 1, 2)| \\ 
-  \code|xs.map(x => x + 1)    | & 3 & ~~\Large$\leadsto$~~ &  F & \code|Vector(2, 3, 4)| \\ 
-  \code|for (i <- 0 to 1) yield xs(i)| & 4 & ~~\Large$\leadsto$~~ &  B & \code|Vector(1, 2)| \\ 
-  \code|(1 to 3).map(i => i)| & 5 & ~~\Large$\leadsto$~~ &  C & \code|Vector(1, 2, 3)| \\ 
-  \code|(1 until 3).map(i => xs(i))| & 6 & ~~\Large$\leadsto$~~ &  E & \code|Vector(2, 3)| \\ 
\ No newline at end of file
+  \code|for (x <- xs) yield x * 2| & 1 & ~~\Large$\leadsto$~~ &  C & \code|Vector(1, 2, 4)| \\ 
+  \code|for (i <- xs.indices) yield i| & 2 & ~~\Large$\leadsto$~~ &  E & \code|Vector(0, 1, 2)| \\ 
+  \code|xs.map(x => x + 1)    | & 3 & ~~\Large$\leadsto$~~ &  B & \code|Vector(2, 3, 4)| \\ 
+  \code|for (i <- 0 to 1) yield xs(i)| & 4 & ~~\Large$\leadsto$~~ &  F & \code|Vector(1, 2)| \\ 
+  \code|(1 to 3).map(i => i)| & 5 & ~~\Large$\leadsto$~~ &  D & \code|Vector(1, 2, 3)| \\ 
+  \code|(1 until 3).map(i => xs(i))| & 6 & ~~\Large$\leadsto$~~ &  A & \code|Vector(2, 3)| \\ 
\ No newline at end of file
diff --git a/compendium/generated/quiz-w02-for-yield-map-taskrows-generated.tex b/compendium/generated/quiz-w02-for-yield-map-taskrows-generated.tex
index 7f947c36a..a15321a1b 100644
--- a/compendium/generated/quiz-w02-for-yield-map-taskrows-generated.tex
+++ b/compendium/generated/quiz-w02-for-yield-map-taskrows-generated.tex
@@ -1,6 +1,6 @@
-  \code|for (x <- xs) yield x * 2| & 1 & & A & \code|Vector(1, 2, 4)| \\ 
-  \code|for (i <- xs.indices) yield i| & 2 & & B & \code|Vector(1, 2)| \\ 
-  \code|xs.map(x => x + 1)    | & 3 & & C & \code|Vector(1, 2, 3)| \\ 
-  \code|for (i <- 0 to 1) yield xs(i)| & 4 & & D & \code|Vector(0, 1, 2)| \\ 
-  \code|(1 to 3).map(i => i)| & 5 & & E & \code|Vector(2, 3)| \\ 
-  \code|(1 until 3).map(i => xs(i))| & 6 & & F & \code|Vector(2, 3, 4)| \\ 
\ No newline at end of file
+  \code|for (x <- xs) yield x * 2| & 1 & & A & \code|Vector(2, 3)| \\ 
+  \code|for (i <- xs.indices) yield i| & 2 & & B & \code|Vector(2, 3, 4)| \\ 
+  \code|xs.map(x => x + 1)    | & 3 & & C & \code|Vector(1, 2, 4)| \\ 
+  \code|for (i <- 0 to 1) yield xs(i)| & 4 & & D & \code|Vector(1, 2, 3)| \\ 
+  \code|(1 to 3).map(i => i)| & 5 & & E & \code|Vector(0, 1, 2)| \\ 
+  \code|(1 until 3).map(i => xs(i))| & 6 & & F & \code|Vector(1, 2)| \\ 
\ No newline at end of file
diff --git a/compendium/generated/quiz-w02-hello-scala-java-solurows-generated.tex b/compendium/generated/quiz-w02-hello-scala-java-solurows-generated.tex
index 5ba483538..c4327e0d2 100644
--- a/compendium/generated/quiz-w02-hello-scala-java-solurows-generated.tex
+++ b/compendium/generated/quiz-w02-hello-scala-java-solurows-generated.tex
@@ -1,6 +1,6 @@
   \code|object| & 1 & ~~\Large$\leadsto$~~ &  C & \jcode|public class| \\ 
-  \code|def main| & 2 & ~~\Large$\leadsto$~~ &  F & \jcode|public static main| \\ 
+  \code|def main| & 2 & ~~\Large$\leadsto$~~ &  D & \jcode|public static main| \\ 
   \code|Array[String]| & 3 & ~~\Large$\leadsto$~~ &  A & \jcode|String[]| \\ 
-  \code|: Unit| & 4 & ~~\Large$\leadsto$~~ &  E & \jcode|void| \\ 
-  \code|=| & 5 & ~~\Large$\leadsto$~~ &  B & \jcode|) {| \\ 
-  \code|println| & 6 & ~~\Large$\leadsto$~~ &  D & \jcode|System.out.println| \\ 
\ No newline at end of file
+  \code|: Unit| & 4 & ~~\Large$\leadsto$~~ &  B & \jcode|void| \\ 
+  \code|=| & 5 & ~~\Large$\leadsto$~~ &  F & \jcode|) {| \\ 
+  \code|println| & 6 & ~~\Large$\leadsto$~~ &  E & \jcode|System.out.println| \\ 
\ No newline at end of file
diff --git a/compendium/generated/quiz-w02-hello-scala-java-taskrows-generated.tex b/compendium/generated/quiz-w02-hello-scala-java-taskrows-generated.tex
index 318bb4d30..d759d828d 100644
--- a/compendium/generated/quiz-w02-hello-scala-java-taskrows-generated.tex
+++ b/compendium/generated/quiz-w02-hello-scala-java-taskrows-generated.tex
@@ -1,6 +1,6 @@
   \code|object| & 1 & & A & \jcode|String[]| \\ 
-  \code|def main| & 2 & & B & \jcode|) {| \\ 
+  \code|def main| & 2 & & B & \jcode|void| \\ 
   \code|Array[String]| & 3 & & C & \jcode|public class| \\ 
-  \code|: Unit| & 4 & & D & \jcode|System.out.println| \\ 
-  \code|=| & 5 & & E & \jcode|void| \\ 
-  \code|println| & 6 & & F & \jcode|public static main| \\ 
\ No newline at end of file
+  \code|: Unit| & 4 & & D & \jcode|public static main| \\ 
+  \code|=| & 5 & & E & \jcode|System.out.println| \\ 
+  \code|println| & 6 & & F & \jcode|) {| \\ 
\ No newline at end of file
diff --git a/compendium/generated/quiz-w03-code-fragments-solurows-generated.tex b/compendium/generated/quiz-w03-code-fragments-solurows-generated.tex
index ea4d6caba..f5b0b77c6 100644
--- a/compendium/generated/quiz-w03-code-fragments-solurows-generated.tex
+++ b/compendium/generated/quiz-w03-code-fragments-solurows-generated.tex
@@ -1,7 +1,7 @@
-  \code|options.indices| & 1 & ~~\Large$\leadsto$~~ &  C & heltalssekvens med alla index i en sekvens \\ 
-  \code|"1X2".toLowercase| & 2 & ~~\Large$\leadsto$~~ &  A & gör om en sträng till små bokstäver \\ 
+  \code|options.indices| & 1 & ~~\Large$\leadsto$~~ &  A & heltalssekvens med alla index i en sekvens \\ 
+  \code|"1X2".toLowercase| & 2 & ~~\Large$\leadsto$~~ &  G & gör om en sträng till små bokstäver \\ 
   \code|Random.nextInt(n)| & 3 & ~~\Large$\leadsto$~~ &  D & slumptal i intervallet \code|0 until n| \\ 
-  \code|try { } catch { }| & 4 & ~~\Large$\leadsto$~~ &  B & fångar undantag för att förhindra krasch \\ 
-  \code|""" ... """| & 5 & ~~\Large$\leadsto$~~ &  E & sträng som kan sträcka sig över flera kodrader \\ 
-  \code|s.stripMargin| & 6 & ~~\Large$\leadsto$~~ &  G & tar bort marginal till och med vertikalstreck \\ 
-  \code|e.printStackTrace| & 7 & ~~\Large$\leadsto$~~ &  F & skriver ut information om ett undantag \\ 
\ No newline at end of file
+  \code|try { } catch { }| & 4 & ~~\Large$\leadsto$~~ &  C & fångar undantag för att förhindra krasch \\ 
+  \code|""" ... """| & 5 & ~~\Large$\leadsto$~~ &  F & sträng som kan sträcka sig över flera kodrader \\ 
+  \code|s.stripMargin| & 6 & ~~\Large$\leadsto$~~ &  B & tar bort marginal till och med vertikalstreck \\ 
+  \code|e.printStackTrace| & 7 & ~~\Large$\leadsto$~~ &  E & skriver ut information om ett undantag \\ 
\ No newline at end of file
diff --git a/compendium/generated/quiz-w03-code-fragments-taskrows-generated.tex b/compendium/generated/quiz-w03-code-fragments-taskrows-generated.tex
index 2688753fc..f6f74b296 100644
--- a/compendium/generated/quiz-w03-code-fragments-taskrows-generated.tex
+++ b/compendium/generated/quiz-w03-code-fragments-taskrows-generated.tex
@@ -1,7 +1,7 @@
-  \code|options.indices| & 1 & & A & gör om en sträng till små bokstäver \\ 
-  \code|"1X2".toLowercase| & 2 & & B & fångar undantag för att förhindra krasch \\ 
-  \code|Random.nextInt(n)| & 3 & & C & heltalssekvens med alla index i en sekvens \\ 
+  \code|options.indices| & 1 & & A & heltalssekvens med alla index i en sekvens \\ 
+  \code|"1X2".toLowercase| & 2 & & B & tar bort marginal till och med vertikalstreck \\ 
+  \code|Random.nextInt(n)| & 3 & & C & fångar undantag för att förhindra krasch \\ 
   \code|try { } catch { }| & 4 & & D & slumptal i intervallet \code|0 until n| \\ 
-  \code|""" ... """| & 5 & & E & sträng som kan sträcka sig över flera kodrader \\ 
-  \code|s.stripMargin| & 6 & & F & skriver ut information om ett undantag \\ 
-  \code|e.printStackTrace| & 7 & & G & tar bort marginal till och med vertikalstreck \\ 
\ No newline at end of file
+  \code|""" ... """| & 5 & & E & skriver ut information om ett undantag \\ 
+  \code|s.stripMargin| & 6 & & F & sträng som kan sträcka sig över flera kodrader \\ 
+  \code|e.printStackTrace| & 7 & & G & gör om en sträng till små bokstäver \\ 
\ No newline at end of file
diff --git a/compendium/generated/quiz-w03-concepts-solurows-generated.tex b/compendium/generated/quiz-w03-concepts-solurows-generated.tex
index 222bb8398..d85b4860a 100644
--- a/compendium/generated/quiz-w03-concepts-solurows-generated.tex
+++ b/compendium/generated/quiz-w03-concepts-solurows-generated.tex
@@ -1,15 +1,15 @@
-  funktionshuvud & 1 & ~~\Large$\leadsto$~~ &  O & har parameterlista och eventuellt en returtyp \\ 
-  funktionskropp & 2 & ~~\Large$\leadsto$~~ &  M & koden som exekveras vid funktionsanrop \\ 
-  parameterlista & 3 & ~~\Large$\leadsto$~~ &  E & beskriver namn och typ på parametrar \\ 
-  block & 4 & ~~\Large$\leadsto$~~ &  G & kan ha lokala namn; sista raden ger värdet \\ 
-  namngivna argument & 5 & ~~\Large$\leadsto$~~ &  D & gör att argument kan ges i valfri ordning \\ 
-  defaultargument & 6 & ~~\Large$\leadsto$~~ &  I & gör att argument kan utelämnas \\ 
-  värdeanrop & 7 & ~~\Large$\leadsto$~~ &  K & argumentet evalueras innan anrop \\ 
-  namnanrop & 8 & ~~\Large$\leadsto$~~ &  F & fördröjd evaluering av argument \\ 
-  tupel & 9 & ~~\Large$\leadsto$~~ &  B & lista med bestämt antal (heterogena) värden \\ 
-  tupelreturtyp & 10 & ~~\Large$\leadsto$~~ &  C & gör att en funktion kan flera resultatvärden \\ 
-  äkta funktion & 11 & ~~\Large$\leadsto$~~ &  H & ger alltid samma resultat om samma argument \\ 
-  predikat & 12 & ~~\Large$\leadsto$~~ &  L & en funktion som ger ett booleskt värde \\ 
-  slumptalsfrö & 13 & ~~\Large$\leadsto$~~ &  A & ger återupprepningsbar sekvens av pseudoslumptal \\ 
-  anonym funktion & 14 & ~~\Large$\leadsto$~~ &  J & funktion utan namn; kallas även lambda \\ 
+  funktionshuvud & 1 & ~~\Large$\leadsto$~~ &  G & har parameterlista och eventuellt en returtyp \\ 
+  funktionskropp & 2 & ~~\Large$\leadsto$~~ &  O & koden som exekveras vid funktionsanrop \\ 
+  parameterlista & 3 & ~~\Large$\leadsto$~~ &  J & beskriver namn och typ på parametrar \\ 
+  block & 4 & ~~\Large$\leadsto$~~ &  B & kan ha lokala namn; sista raden ger värdet \\ 
+  namngivna argument & 5 & ~~\Large$\leadsto$~~ &  L & gör att argument kan ges i valfri ordning \\ 
+  defaultargument & 6 & ~~\Large$\leadsto$~~ &  D & gör att argument kan utelämnas \\ 
+  värdeanrop & 7 & ~~\Large$\leadsto$~~ &  H & argumentet evalueras innan anrop \\ 
+  namnanrop & 8 & ~~\Large$\leadsto$~~ &  E & fördröjd evaluering av argument \\ 
+  tupel & 9 & ~~\Large$\leadsto$~~ &  I & lista med bestämt antal (heterogena) värden \\ 
+  tupelreturtyp & 10 & ~~\Large$\leadsto$~~ &  F & gör att en funktion kan flera resultatvärden \\ 
+  äkta funktion & 11 & ~~\Large$\leadsto$~~ &  C & ger alltid samma resultat om samma argument \\ 
+  predikat & 12 & ~~\Large$\leadsto$~~ &  M & en funktion som ger ett booleskt värde \\ 
+  slumptalsfrö & 13 & ~~\Large$\leadsto$~~ &  K & ger återupprepningsbar sekvens av pseudoslumptal \\ 
+  anonym funktion & 14 & ~~\Large$\leadsto$~~ &  A & funktion utan namn; kallas även lambda \\ 
   rekursiv funktion & 15 & ~~\Large$\leadsto$~~ &  N & en funktion som anropar sig själv \\ 
\ No newline at end of file
diff --git a/compendium/generated/quiz-w03-concepts-taskrows-generated.tex b/compendium/generated/quiz-w03-concepts-taskrows-generated.tex
index 26d02a2e4..32b4ba4cb 100644
--- a/compendium/generated/quiz-w03-concepts-taskrows-generated.tex
+++ b/compendium/generated/quiz-w03-concepts-taskrows-generated.tex
@@ -1,15 +1,15 @@
-  funktionshuvud & 1 & & A & ger återupprepningsbar sekvens av pseudoslumptal \\ 
-  funktionskropp & 2 & & B & lista med bestämt antal (heterogena) värden \\ 
-  parameterlista & 3 & & C & gör att en funktion kan flera resultatvärden \\ 
-  block & 4 & & D & gör att argument kan ges i valfri ordning \\ 
-  namngivna argument & 5 & & E & beskriver namn och typ på parametrar \\ 
-  defaultargument & 6 & & F & fördröjd evaluering av argument \\ 
-  värdeanrop & 7 & & G & kan ha lokala namn; sista raden ger värdet \\ 
-  namnanrop & 8 & & H & ger alltid samma resultat om samma argument \\ 
-  tupel & 9 & & I & gör att argument kan utelämnas \\ 
-  tupelreturtyp & 10 & & J & funktion utan namn; kallas även lambda \\ 
-  äkta funktion & 11 & & K & argumentet evalueras innan anrop \\ 
-  predikat & 12 & & L & en funktion som ger ett booleskt värde \\ 
-  slumptalsfrö & 13 & & M & koden som exekveras vid funktionsanrop \\ 
+  funktionshuvud & 1 & & A & funktion utan namn; kallas även lambda \\ 
+  funktionskropp & 2 & & B & kan ha lokala namn; sista raden ger värdet \\ 
+  parameterlista & 3 & & C & ger alltid samma resultat om samma argument \\ 
+  block & 4 & & D & gör att argument kan utelämnas \\ 
+  namngivna argument & 5 & & E & fördröjd evaluering av argument \\ 
+  defaultargument & 6 & & F & gör att en funktion kan flera resultatvärden \\ 
+  värdeanrop & 7 & & G & har parameterlista och eventuellt en returtyp \\ 
+  namnanrop & 8 & & H & argumentet evalueras innan anrop \\ 
+  tupel & 9 & & I & lista med bestämt antal (heterogena) värden \\ 
+  tupelreturtyp & 10 & & J & beskriver namn och typ på parametrar \\ 
+  äkta funktion & 11 & & K & ger återupprepningsbar sekvens av pseudoslumptal \\ 
+  predikat & 12 & & L & gör att argument kan ges i valfri ordning \\ 
+  slumptalsfrö & 13 & & M & en funktion som ger ett booleskt värde \\ 
   anonym funktion & 14 & & N & en funktion som anropar sig själv \\ 
-  rekursiv funktion & 15 & & O & har parameterlista och eventuellt en returtyp \\ 
\ No newline at end of file
+  rekursiv funktion & 15 & & O & koden som exekveras vid funktionsanrop \\ 
\ No newline at end of file
diff --git a/compendium/generated/quiz-w03-function-values-solurows-generated.tex b/compendium/generated/quiz-w03-function-values-solurows-generated.tex
index 9ec418b03..cb3b7f71f 100644
--- a/compendium/generated/quiz-w03-function-values-solurows-generated.tex
+++ b/compendium/generated/quiz-w03-function-values-solurows-generated.tex
@@ -1,5 +1,5 @@
-  \code| öka(-1)     | & 1 & ~~\Large$\leadsto$~~ &  C & \code| 0     | \\ 
+  \code| öka(-1)     | & 1 & ~~\Large$\leadsto$~~ &  E & \code| 0     | \\ 
   \code| app(1, öka) | & 2 & ~~\Large$\leadsto$~~ &  A & \code| öka(1)| \\ 
-  \code| app(5, f2)  | & 3 & ~~\Large$\leadsto$~~ &  E & \code| 4     | \\ 
-  \code| f1(2)       | & 4 & ~~\Large$\leadsto$~~ &  B & \code| 3     | \\ 
+  \code| app(5, f2)  | & 3 & ~~\Large$\leadsto$~~ &  B & \code| 4     | \\ 
+  \code| f1(2)       | & 4 & ~~\Large$\leadsto$~~ &  C & \code| 3     | \\ 
   \code| f2(2)       | & 5 & ~~\Large$\leadsto$~~ &  D & \code| 1     | \\ 
\ No newline at end of file
diff --git a/compendium/generated/quiz-w03-function-values-taskrows-generated.tex b/compendium/generated/quiz-w03-function-values-taskrows-generated.tex
index a668a0bba..7ee606ef1 100644
--- a/compendium/generated/quiz-w03-function-values-taskrows-generated.tex
+++ b/compendium/generated/quiz-w03-function-values-taskrows-generated.tex
@@ -1,5 +1,5 @@
   \code| öka(-1)     | & 1 & & A & \code| öka(1)| \\ 
-  \code| app(1, öka) | & 2 & & B & \code| 3     | \\ 
-  \code| app(5, f2)  | & 3 & & C & \code| 0     | \\ 
+  \code| app(1, öka) | & 2 & & B & \code| 4     | \\ 
+  \code| app(5, f2)  | & 3 & & C & \code| 3     | \\ 
   \code| f1(2)       | & 4 & & D & \code| 1     | \\ 
-  \code| f2(2)       | & 5 & & E & \code| 4     | \\ 
\ No newline at end of file
+  \code| f2(2)       | & 5 & & E & \code| 0     | \\ 
\ No newline at end of file
diff --git a/compendium/generated/quiz-w03-lambda-solurows-generated.tex b/compendium/generated/quiz-w03-lambda-solurows-generated.tex
index da070924b..e7c55323c 100644
--- a/compendium/generated/quiz-w03-lambda-solurows-generated.tex
+++ b/compendium/generated/quiz-w03-lambda-solurows-generated.tex
@@ -1,5 +1,5 @@
   \code|(0 to 2).map(i => i + 1)           | & 1 & ~~\Large$\leadsto$~~ &  A & \code|(2 to 4).map(i => i - 1)| \\ 
-  \code|(1 to 3).map(_ + 1)                | & 2 & ~~\Large$\leadsto$~~ &  B & \code|Vector(2, 3, 4)         | \\ 
-  \code|(2 to 4).map(math.pow(2, _))       | & 3 & ~~\Large$\leadsto$~~ &  D & \code|Vector(4.0, 8.0, 16.0)  | \\ 
+  \code|(1 to 3).map(_ + 1)                | & 2 & ~~\Large$\leadsto$~~ &  D & \code|Vector(2, 3, 4)         | \\ 
+  \code|(2 to 4).map(math.pow(2, _))       | & 3 & ~~\Large$\leadsto$~~ &  B & \code|Vector(4.0, 8.0, 16.0)  | \\ 
   \code|(3 to 5).map(math.pow(_, 2))       | & 4 & ~~\Large$\leadsto$~~ &  E & \code|Vector(9.0, 16.0, 25.0) | \\ 
   \code|(4 to 6).map(_.toDouble).map(_ / 2)| & 5 & ~~\Large$\leadsto$~~ &  C & \code|Vector(2.0, 2.5, 3.0)   | \\ 
\ No newline at end of file
diff --git a/compendium/generated/quiz-w03-lambda-taskrows-generated.tex b/compendium/generated/quiz-w03-lambda-taskrows-generated.tex
index 71bc9b018..c4297edc7 100644
--- a/compendium/generated/quiz-w03-lambda-taskrows-generated.tex
+++ b/compendium/generated/quiz-w03-lambda-taskrows-generated.tex
@@ -1,5 +1,5 @@
   \code|(0 to 2).map(i => i + 1)           | & 1 & & A & \code|(2 to 4).map(i => i - 1)| \\ 
-  \code|(1 to 3).map(_ + 1)                | & 2 & & B & \code|Vector(2, 3, 4)         | \\ 
+  \code|(1 to 3).map(_ + 1)                | & 2 & & B & \code|Vector(4.0, 8.0, 16.0)  | \\ 
   \code|(2 to 4).map(math.pow(2, _))       | & 3 & & C & \code|Vector(2.0, 2.5, 3.0)   | \\ 
-  \code|(3 to 5).map(math.pow(_, 2))       | & 4 & & D & \code|Vector(4.0, 8.0, 16.0)  | \\ 
+  \code|(3 to 5).map(math.pow(_, 2))       | & 4 & & D & \code|Vector(2, 3, 4)         | \\ 
   \code|(4 to 6).map(_.toDouble).map(_ / 2)| & 5 & & E & \code|Vector(9.0, 16.0, 25.0) | \\ 
\ No newline at end of file
diff --git a/compendium/generated/quiz-w03-yield-map-solurows-generated.tex b/compendium/generated/quiz-w03-yield-map-solurows-generated.tex
index 71998e59d..aed833802 100644
--- a/compendium/generated/quiz-w03-yield-map-solurows-generated.tex
+++ b/compendium/generated/quiz-w03-yield-map-solurows-generated.tex
@@ -1,5 +1,5 @@
   \code|for (i <- 1 to 3) yield öka(i)| & 1 & ~~\Large$\leadsto$~~ &  C & \code|Vector(2, 3, 4)| \\ 
-  \code|Vector(2, 3, 4).map(i => öka(i))| & 2 & ~~\Large$\leadsto$~~ &  E & \code|xs| \\ 
-  \code|xs.map(öka)| & 3 & ~~\Large$\leadsto$~~ &  B & \code|Vector(4, 5, 6)| \\ 
+  \code|Vector(2, 3, 4).map(i => öka(i))| & 2 & ~~\Large$\leadsto$~~ &  B & \code|xs| \\ 
+  \code|xs.map(öka)| & 3 & ~~\Large$\leadsto$~~ &  E & \code|Vector(4, 5, 6)| \\ 
   \code|xs.map(öka).map(öka)| & 4 & ~~\Large$\leadsto$~~ &  D & \code|Vector(5, 6, 7)| \\ 
   \code|xs.foreach(öka)| & 5 & ~~\Large$\leadsto$~~ &  A & \code|()| \\ 
\ No newline at end of file
diff --git a/compendium/generated/quiz-w03-yield-map-taskrows-generated.tex b/compendium/generated/quiz-w03-yield-map-taskrows-generated.tex
index ca6c3be77..b143a9d29 100644
--- a/compendium/generated/quiz-w03-yield-map-taskrows-generated.tex
+++ b/compendium/generated/quiz-w03-yield-map-taskrows-generated.tex
@@ -1,5 +1,5 @@
   \code|for (i <- 1 to 3) yield öka(i)| & 1 & & A & \code|()| \\ 
-  \code|Vector(2, 3, 4).map(i => öka(i))| & 2 & & B & \code|Vector(4, 5, 6)| \\ 
+  \code|Vector(2, 3, 4).map(i => öka(i))| & 2 & & B & \code|xs| \\ 
   \code|xs.map(öka)| & 3 & & C & \code|Vector(2, 3, 4)| \\ 
   \code|xs.map(öka).map(öka)| & 4 & & D & \code|Vector(5, 6, 7)| \\ 
-  \code|xs.foreach(öka)| & 5 & & E & \code|xs| \\ 
\ No newline at end of file
+  \code|xs.foreach(öka)| & 5 & & E & \code|Vector(4, 5, 6)| \\ 
\ No newline at end of file
diff --git a/compendium/generated/quiz-w04-concepts-solurows-generated.tex b/compendium/generated/quiz-w04-concepts-solurows-generated.tex
index d540f6ee7..a0c290244 100644
--- a/compendium/generated/quiz-w04-concepts-solurows-generated.tex
+++ b/compendium/generated/quiz-w04-concepts-solurows-generated.tex
@@ -1,15 +1,15 @@
-  modul & 1 & ~~\Large$\leadsto$~~ &  K & kodenhet med abstraktioner som kan återanvändas \\ 
-  singelobjekt & 2 & ~~\Large$\leadsto$~~ &  A & modul som kan ha tillstånd; finns i en enda upplaga \\ 
-  paket & 3 & ~~\Large$\leadsto$~~ &  G & modul som skapar namnrymd; maskinkod får egen katalog \\ 
-  import & 4 & ~~\Large$\leadsto$~~ &  B & gör namn tillgängligt utan att hela sökvägen behövs \\ 
-  lat initialisering & 5 & ~~\Large$\leadsto$~~ &  O & allokering sker först när namnet refereras \\ 
-  medlem & 6 & ~~\Large$\leadsto$~~ &  N & tillhör ett objekt; nås med punktnotation om synlig \\ 
-  attribut & 7 & ~~\Large$\leadsto$~~ &  L & variabel som utgör (del av) ett objekts tillstånd \\ 
-  metod & 8 & ~~\Large$\leadsto$~~ &  C & funktion som är medlem av ett objekt \\ 
-  privat & 9 & ~~\Large$\leadsto$~~ &  E & modifierar synligheten av en objektmedlem \\ 
-  överlagring & 10 & ~~\Large$\leadsto$~~ &  M & metoder med samma namn men olika parametertyper \\ 
-  namnskuggning & 11 & ~~\Large$\leadsto$~~ &  J & lokalt namn döljer samma namn i omgivande block \\ 
-  namnrymd & 12 & ~~\Large$\leadsto$~~ &  I & omgivning där är alla namn är unika \\ 
-  uniform access & 13 & ~~\Large$\leadsto$~~ &  H & ändring mellan def och val påverkar ej användning \\ 
-  punktnotation & 14 & ~~\Large$\leadsto$~~ &  D & används för att komma åt icke-privata delar \\ 
-  typalias & 15 & ~~\Large$\leadsto$~~ &  F & alternativt namn på typ som ofta ökar läsbarheten \\ 
\ No newline at end of file
+  modul & 1 & ~~\Large$\leadsto$~~ &  I & kodenhet med abstraktioner som kan återanvändas \\ 
+  singelobjekt & 2 & ~~\Large$\leadsto$~~ &  M & modul som kan ha tillstånd; finns i en enda upplaga \\ 
+  paket & 3 & ~~\Large$\leadsto$~~ &  H & modul som skapar namnrymd; maskinkod får egen katalog \\ 
+  import & 4 & ~~\Large$\leadsto$~~ &  J & gör namn tillgängligt utan att hela sökvägen behövs \\ 
+  lat initialisering & 5 & ~~\Large$\leadsto$~~ &  K & allokering sker först när namnet refereras \\ 
+  medlem & 6 & ~~\Large$\leadsto$~~ &  F & tillhör ett objekt; nås med punktnotation om synlig \\ 
+  attribut & 7 & ~~\Large$\leadsto$~~ &  D & variabel som utgör (del av) ett objekts tillstånd \\ 
+  metod & 8 & ~~\Large$\leadsto$~~ &  O & funktion som är medlem av ett objekt \\ 
+  privat & 9 & ~~\Large$\leadsto$~~ &  N & modifierar synligheten av en objektmedlem \\ 
+  överlagring & 10 & ~~\Large$\leadsto$~~ &  E & metoder med samma namn men olika parametertyper \\ 
+  namnskuggning & 11 & ~~\Large$\leadsto$~~ &  A & lokalt namn döljer samma namn i omgivande block \\ 
+  namnrymd & 12 & ~~\Large$\leadsto$~~ &  L & omgivning där är alla namn är unika \\ 
+  uniform access & 13 & ~~\Large$\leadsto$~~ &  G & ändring mellan def och val påverkar ej användning \\ 
+  punktnotation & 14 & ~~\Large$\leadsto$~~ &  B & används för att komma åt icke-privata delar \\ 
+  typalias & 15 & ~~\Large$\leadsto$~~ &  C & alternativt namn på typ som ofta ökar läsbarheten \\ 
\ No newline at end of file
diff --git a/compendium/generated/quiz-w04-concepts-taskrows-generated.tex b/compendium/generated/quiz-w04-concepts-taskrows-generated.tex
index ccb989c80..1c9bb83f1 100644
--- a/compendium/generated/quiz-w04-concepts-taskrows-generated.tex
+++ b/compendium/generated/quiz-w04-concepts-taskrows-generated.tex
@@ -1,15 +1,15 @@
-  modul & 1 & & A & modul som kan ha tillstånd; finns i en enda upplaga \\ 
-  singelobjekt & 2 & & B & gör namn tillgängligt utan att hela sökvägen behövs \\ 
-  paket & 3 & & C & funktion som är medlem av ett objekt \\ 
-  import & 4 & & D & används för att komma åt icke-privata delar \\ 
-  lat initialisering & 5 & & E & modifierar synligheten av en objektmedlem \\ 
-  medlem & 6 & & F & alternativt namn på typ som ofta ökar läsbarheten \\ 
-  attribut & 7 & & G & modul som skapar namnrymd; maskinkod får egen katalog \\ 
-  metod & 8 & & H & ändring mellan def och val påverkar ej användning \\ 
-  privat & 9 & & I & omgivning där är alla namn är unika \\ 
-  överlagring & 10 & & J & lokalt namn döljer samma namn i omgivande block \\ 
-  namnskuggning & 11 & & K & kodenhet med abstraktioner som kan återanvändas \\ 
-  namnrymd & 12 & & L & variabel som utgör (del av) ett objekts tillstånd \\ 
-  uniform access & 13 & & M & metoder med samma namn men olika parametertyper \\ 
-  punktnotation & 14 & & N & tillhör ett objekt; nås med punktnotation om synlig \\ 
-  typalias & 15 & & O & allokering sker först när namnet refereras \\ 
\ No newline at end of file
+  modul & 1 & & A & lokalt namn döljer samma namn i omgivande block \\ 
+  singelobjekt & 2 & & B & används för att komma åt icke-privata delar \\ 
+  paket & 3 & & C & alternativt namn på typ som ofta ökar läsbarheten \\ 
+  import & 4 & & D & variabel som utgör (del av) ett objekts tillstånd \\ 
+  lat initialisering & 5 & & E & metoder med samma namn men olika parametertyper \\ 
+  medlem & 6 & & F & tillhör ett objekt; nås med punktnotation om synlig \\ 
+  attribut & 7 & & G & ändring mellan def och val påverkar ej användning \\ 
+  metod & 8 & & H & modul som skapar namnrymd; maskinkod får egen katalog \\ 
+  privat & 9 & & I & kodenhet med abstraktioner som kan återanvändas \\ 
+  överlagring & 10 & & J & gör namn tillgängligt utan att hela sökvägen behövs \\ 
+  namnskuggning & 11 & & K & allokering sker först när namnet refereras \\ 
+  namnrymd & 12 & & L & omgivning där är alla namn är unika \\ 
+  uniform access & 13 & & M & modul som kan ha tillstånd; finns i en enda upplaga \\ 
+  punktnotation & 14 & & N & modifierar synligheten av en objektmedlem \\ 
+  typalias & 15 & & O & funktion som är medlem av ett objekt \\ 
\ No newline at end of file
diff --git a/compendium/generated/quiz-w05-concepts-solurows-generated.tex b/compendium/generated/quiz-w05-concepts-solurows-generated.tex
index 775cc444f..dfda53445 100644
--- a/compendium/generated/quiz-w05-concepts-solurows-generated.tex
+++ b/compendium/generated/quiz-w05-concepts-solurows-generated.tex
@@ -1,9 +1,9 @@
-  klass & 1 & ~~\Large$\leadsto$~~ &  I & en mall för att skapa flera instanser av samma typ \\ 
-  instans & 2 & ~~\Large$\leadsto$~~ &  A & upplaga av ett objekt med eget tillståndsminne \\ 
-  konstruktor & 3 & ~~\Large$\leadsto$~~ &  E & skapar instans, allokerar plats för tillståndsminne \\ 
-  klassparameter & 4 & ~~\Large$\leadsto$~~ &  F & ge argument vid konstruktion, initialisera tillstånd \\ 
-  fabriksmetod & 5 & ~~\Large$\leadsto$~~ &  B & hjälpfunktion för att anropa konstruktor \\ 
-  referenslikhet & 6 & ~~\Large$\leadsto$~~ &  C & instanser anses olika även om de har samma tillstånd \\ 
-  innehållslikhet & 7 & ~~\Large$\leadsto$~~ &  G & olika instanser anses lika om de har samma tillstånd \\ 
-  case-klass & 8 & ~~\Large$\leadsto$~~ &  D & slipper skriva new; automatisk innehållslikhet \\ 
-  kompanjonsobjekt & 9 & ~~\Large$\leadsto$~~ &  H & ser privata medlemmar i klassen med samma namn \\ 
\ No newline at end of file
+  klass & 1 & ~~\Large$\leadsto$~~ &  F & en mall för att skapa flera instanser av samma typ \\ 
+  instans & 2 & ~~\Large$\leadsto$~~ &  E & upplaga av ett objekt med eget tillståndsminne \\ 
+  konstruktor & 3 & ~~\Large$\leadsto$~~ &  A & skapar instans, allokerar plats för tillståndsminne \\ 
+  klassparameter & 4 & ~~\Large$\leadsto$~~ &  G & ge argument vid konstruktion, initialisera tillstånd \\ 
+  fabriksmetod & 5 & ~~\Large$\leadsto$~~ &  C & hjälpfunktion för att anropa konstruktor \\ 
+  referenslikhet & 6 & ~~\Large$\leadsto$~~ &  D & instanser anses olika även om de har samma tillstånd \\ 
+  innehållslikhet & 7 & ~~\Large$\leadsto$~~ &  I & olika instanser anses lika om de har samma tillstånd \\ 
+  case-klass & 8 & ~~\Large$\leadsto$~~ &  H & slipper skriva new; automatisk innehållslikhet \\ 
+  kompanjonsobjekt & 9 & ~~\Large$\leadsto$~~ &  B & ser privata medlemmar i klassen med samma namn \\ 
\ No newline at end of file
diff --git a/compendium/generated/quiz-w05-concepts-taskrows-generated.tex b/compendium/generated/quiz-w05-concepts-taskrows-generated.tex
index def199d9f..01a193e8d 100644
--- a/compendium/generated/quiz-w05-concepts-taskrows-generated.tex
+++ b/compendium/generated/quiz-w05-concepts-taskrows-generated.tex
@@ -1,9 +1,9 @@
-  klass & 1 & & A & upplaga av ett objekt med eget tillståndsminne \\ 
-  instans & 2 & & B & hjälpfunktion för att anropa konstruktor \\ 
-  konstruktor & 3 & & C & instanser anses olika även om de har samma tillstånd \\ 
-  klassparameter & 4 & & D & slipper skriva new; automatisk innehållslikhet \\ 
-  fabriksmetod & 5 & & E & skapar instans, allokerar plats för tillståndsminne \\ 
-  referenslikhet & 6 & & F & ge argument vid konstruktion, initialisera tillstånd \\ 
-  innehållslikhet & 7 & & G & olika instanser anses lika om de har samma tillstånd \\ 
-  case-klass & 8 & & H & ser privata medlemmar i klassen med samma namn \\ 
-  kompanjonsobjekt & 9 & & I & en mall för att skapa flera instanser av samma typ \\ 
\ No newline at end of file
+  klass & 1 & & A & skapar instans, allokerar plats för tillståndsminne \\ 
+  instans & 2 & & B & ser privata medlemmar i klassen med samma namn \\ 
+  konstruktor & 3 & & C & hjälpfunktion för att anropa konstruktor \\ 
+  klassparameter & 4 & & D & instanser anses olika även om de har samma tillstånd \\ 
+  fabriksmetod & 5 & & E & upplaga av ett objekt med eget tillståndsminne \\ 
+  referenslikhet & 6 & & F & en mall för att skapa flera instanser av samma typ \\ 
+  innehållslikhet & 7 & & G & ge argument vid konstruktion, initialisera tillstånd \\ 
+  case-klass & 8 & & H & slipper skriva new; automatisk innehållslikhet \\ 
+  kompanjonsobjekt & 9 & & I & olika instanser anses lika om de har samma tillstånd \\ 
\ No newline at end of file
diff --git a/compendium/generated/quiz-w06-concepts-solurows-generated.tex b/compendium/generated/quiz-w06-concepts-solurows-generated.tex
index 129a82363..fa7c46826 100644
--- a/compendium/generated/quiz-w06-concepts-solurows-generated.tex
+++ b/compendium/generated/quiz-w06-concepts-solurows-generated.tex
@@ -1,8 +1,8 @@
-  samlingsbibliotek & 1 & ~~\Large$\leadsto$~~ &  B & många färdiga datastrukturer med olika egenskaper \\ 
-  sekvenssamling & 2 & ~~\Large$\leadsto$~~ &  A & noll el. flera element av samma typ i viss ordning \\ 
-  sekvensalgoritm & 3 & ~~\Large$\leadsto$~~ &  G & lösning på problem som drar nytta av sekvenser \\ 
+  samlingsbibliotek & 1 & ~~\Large$\leadsto$~~ &  A & många färdiga datastrukturer med olika egenskaper \\ 
+  sekvenssamling & 2 & ~~\Large$\leadsto$~~ &  B & noll el. flera element av samma typ i viss ordning \\ 
+  sekvensalgoritm & 3 & ~~\Large$\leadsto$~~ &  D & lösning på problem som drar nytta av sekvenser \\ 
   ordning & 4 & ~~\Large$\leadsto$~~ &  F & beskriver hur element av en viss typ ska ordnas \\ 
-  sortering & 5 & ~~\Large$\leadsto$~~ &  H & algoritm som ordnar element i en viss ordning \\ 
-  söking & 6 & ~~\Large$\leadsto$~~ &  C & algoritm som leta upp element enligt sökkriterium \\ 
-  registrering & 7 & ~~\Large$\leadsto$~~ &  D & algoritm som räknar element med vissa egenskaper \\ 
+  sortering & 5 & ~~\Large$\leadsto$~~ &  C & algoritm som ordnar element i en viss ordning \\ 
+  söking & 6 & ~~\Large$\leadsto$~~ &  G & algoritm som leta upp element enligt sökkriterium \\ 
+  registrering & 7 & ~~\Large$\leadsto$~~ &  H & algoritm som räknar element med vissa egenskaper \\ 
   varargs & 8 & ~~\Large$\leadsto$~~ &  E & variabelt antal argument, asterisk efter parametertyp \\ 
\ No newline at end of file
diff --git a/compendium/generated/quiz-w06-concepts-taskrows-generated.tex b/compendium/generated/quiz-w06-concepts-taskrows-generated.tex
index 19e799535..6924cc262 100644
--- a/compendium/generated/quiz-w06-concepts-taskrows-generated.tex
+++ b/compendium/generated/quiz-w06-concepts-taskrows-generated.tex
@@ -1,8 +1,8 @@
-  samlingsbibliotek & 1 & & A & noll el. flera element av samma typ i viss ordning \\ 
-  sekvenssamling & 2 & & B & många färdiga datastrukturer med olika egenskaper \\ 
-  sekvensalgoritm & 3 & & C & algoritm som leta upp element enligt sökkriterium \\ 
-  ordning & 4 & & D & algoritm som räknar element med vissa egenskaper \\ 
+  samlingsbibliotek & 1 & & A & många färdiga datastrukturer med olika egenskaper \\ 
+  sekvenssamling & 2 & & B & noll el. flera element av samma typ i viss ordning \\ 
+  sekvensalgoritm & 3 & & C & algoritm som ordnar element i en viss ordning \\ 
+  ordning & 4 & & D & lösning på problem som drar nytta av sekvenser \\ 
   sortering & 5 & & E & variabelt antal argument, asterisk efter parametertyp \\ 
   söking & 6 & & F & beskriver hur element av en viss typ ska ordnas \\ 
-  registrering & 7 & & G & lösning på problem som drar nytta av sekvenser \\ 
-  varargs & 8 & & H & algoritm som ordnar element i en viss ordning \\ 
\ No newline at end of file
+  registrering & 7 & & G & algoritm som leta upp element enligt sökkriterium \\ 
+  varargs & 8 & & H & algoritm som räknar element med vissa egenskaper \\ 
\ No newline at end of file
diff --git a/compendium/generated/quiz-w07-concepts-solurows-generated.tex b/compendium/generated/quiz-w07-concepts-solurows-generated.tex
index f244bdd85..f656cafd1 100644
--- a/compendium/generated/quiz-w07-concepts-solurows-generated.tex
+++ b/compendium/generated/quiz-w07-concepts-solurows-generated.tex
@@ -1,9 +1,9 @@
-  linjärsökning & 1 & ~~\Large$\leadsto$~~ &  F & leta i sekvens tills sökkriteriet är uppfyllt \\ 
-  tidskomplexitet & 2 & ~~\Large$\leadsto$~~ &  I & hur exekveringstiden växer med problemstorleken \\ 
-  minneskomplexitet & 3 & ~~\Large$\leadsto$~~ &  B & hur minnesåtgången växer med problemstorleken \\ 
-  mängd & 4 & ~~\Large$\leadsto$~~ &  E & unika element, kan snabbt se om element finns \\ 
-  nyckel-värde-tabell & 5 & ~~\Large$\leadsto$~~ &  G & för att snabbt hitta tillhörande värde \\ 
-  nyckelmängd & 6 & ~~\Large$\leadsto$~~ &  H & unika identifierare, associerade med ett enda värde \\ 
-  persistens & 7 & ~~\Large$\leadsto$~~ &  D & egenskapen att finnas kvar efter programmets avslut \\ 
-  serialisera & 8 & ~~\Large$\leadsto$~~ &  A & koda objekt till avkodningsbar sekvens av symboler \\ 
-  de-serialisera & 9 & ~~\Large$\leadsto$~~ &  C & avkoda symbolsekvens och återskapa objekt i minnet \\ 
\ No newline at end of file
+  linjärsökning & 1 & ~~\Large$\leadsto$~~ &  D & leta i sekvens tills sökkriteriet är uppfyllt \\ 
+  tidskomplexitet & 2 & ~~\Large$\leadsto$~~ &  H & hur exekveringstiden växer med problemstorleken \\ 
+  minneskomplexitet & 3 & ~~\Large$\leadsto$~~ &  G & hur minnesåtgången växer med problemstorleken \\ 
+  mängd & 4 & ~~\Large$\leadsto$~~ &  I & unika element, kan snabbt se om element finns \\ 
+  nyckel-värde-tabell & 5 & ~~\Large$\leadsto$~~ &  F & för att snabbt hitta tillhörande värde \\ 
+  nyckelmängd & 6 & ~~\Large$\leadsto$~~ &  B & unika identifierare, associerade med ett enda värde \\ 
+  persistens & 7 & ~~\Large$\leadsto$~~ &  A & egenskapen att finnas kvar efter programmets avslut \\ 
+  serialisera & 8 & ~~\Large$\leadsto$~~ &  C & koda objekt till avkodningsbar sekvens av symboler \\ 
+  de-serialisera & 9 & ~~\Large$\leadsto$~~ &  E & avkoda symbolsekvens och återskapa objekt i minnet \\ 
\ No newline at end of file
diff --git a/compendium/generated/quiz-w07-concepts-taskrows-generated.tex b/compendium/generated/quiz-w07-concepts-taskrows-generated.tex
index b060e4651..729189215 100644
--- a/compendium/generated/quiz-w07-concepts-taskrows-generated.tex
+++ b/compendium/generated/quiz-w07-concepts-taskrows-generated.tex
@@ -1,9 +1,9 @@
-  linjärsökning & 1 & & A & koda objekt till avkodningsbar sekvens av symboler \\ 
-  tidskomplexitet & 2 & & B & hur minnesåtgången växer med problemstorleken \\ 
-  minneskomplexitet & 3 & & C & avkoda symbolsekvens och återskapa objekt i minnet \\ 
-  mängd & 4 & & D & egenskapen att finnas kvar efter programmets avslut \\ 
-  nyckel-värde-tabell & 5 & & E & unika element, kan snabbt se om element finns \\ 
-  nyckelmängd & 6 & & F & leta i sekvens tills sökkriteriet är uppfyllt \\ 
-  persistens & 7 & & G & för att snabbt hitta tillhörande värde \\ 
-  serialisera & 8 & & H & unika identifierare, associerade med ett enda värde \\ 
-  de-serialisera & 9 & & I & hur exekveringstiden växer med problemstorleken \\ 
\ No newline at end of file
+  linjärsökning & 1 & & A & egenskapen att finnas kvar efter programmets avslut \\ 
+  tidskomplexitet & 2 & & B & unika identifierare, associerade med ett enda värde \\ 
+  minneskomplexitet & 3 & & C & koda objekt till avkodningsbar sekvens av symboler \\ 
+  mängd & 4 & & D & leta i sekvens tills sökkriteriet är uppfyllt \\ 
+  nyckel-värde-tabell & 5 & & E & avkoda symbolsekvens och återskapa objekt i minnet \\ 
+  nyckelmängd & 6 & & F & för att snabbt hitta tillhörande värde \\ 
+  persistens & 7 & & G & hur minnesåtgången växer med problemstorleken \\ 
+  serialisera & 8 & & H & hur exekveringstiden växer med problemstorleken \\ 
+  de-serialisera & 9 & & I & unika element, kan snabbt se om element finns \\ 
\ No newline at end of file
diff --git a/compendium/modules/w04-objects-exercise-goals.tex b/compendium/modules/w04-objects-exercise-goals.tex
index 423a7eaab..c4c45352c 100644
--- a/compendium/modules/w04-objects-exercise-goals.tex
+++ b/compendium/modules/w04-objects-exercise-goals.tex
@@ -2,19 +2,23 @@
 %!TEX root = ../exercises.tex
 
 \item Kunna skapa och använda objekt som moduler.
-\item Kunna förklara vad ett block och en lokal variabel är.
-\item Kunna skapa och använda lokala funktioner och förklara nyttan med dessa.
+%\item Kunna förklara vad ett block och en lokal variabel är.
+%\item Kunna skapa och använda lokala funktioner och förklara nyttan med dessa.
 \item Kunna förklara hur nästlade block påverkar namnsynlighet och namnöverskuggning.
-\item Kunna förklara begreppen synlighet, privat medlem, import, namnrymd och namnskuggning.
+\item Kunna förklara begreppen synlighet, privat medlem, namnrymd och namnskuggning.
 %https://it-ord.idg.se/ord/overskuggning/
 
+\item Kunna skapa och använda tupler.
+\item Kunna skapa funktioner som har multipla returvärden.
+
 \item Kunna förklara kopplingen mellan paketstruktur och kodfilstruktur.
-\item Kunna skapa en jar-fil.
+\item Kunna använda en jar-fil och classpath.
+
+\item Kunna använda import av medlemmar i objekt och paket.
+\item Kunna byta namn vid import.
 
 \item Kunna skapa och använda variabler med fördröjd initialisering.
-\item Kunna förklara skillnaden mellan värdeanrop och namnanrop.
-\item Känna till att det går att skapa egna kontrollstrukturer genom namnanrop.
+\item Kunna förklara när parenteserna kan skippas runt tupel-argument.
 
-\item Kunna skapa och använda tupler.
-\item Kunna skapa funktioner som har multipla returvärden.
-\item Känna till att parenteserna kan skippas runt tupel-argument.
+\item Känna till att det går att skapa egna kontrollstrukturer genom namnanrop.
+\item Känna till skillnaden mellan värdeanrop och namnanrop.
diff --git a/compendium/modules/w04-objects-exercise.tex b/compendium/modules/w04-objects-exercise.tex
index 85c874715..7a1193bb5 100644
--- a/compendium/modules/w04-objects-exercise.tex
+++ b/compendium/modules/w04-objects-exercise.tex
@@ -162,7 +162,7 @@
 
 \QUESTBEGIN
 
-\Task \what~ Tupler sammanför flera olika värden i ett oföränderligt objekt. Nedan används tupler för att representera en 3D-punkt i underjorden med koordinater av typen \code{(x: Int, y: Int, z: Double)}, där $z$-koordinaten anger hur djupt ner i underjorden punkten ligger. På en hemlig plats finns uppgången till överjorden.
+\Task \what~ Tupler sammanför flera olika värden i ett oföränderligt objekt. Nedan används tupler för att representera en 3D-punkt i underjorden med koordinater \code{(x, y, z)} av typen \code{(Int, Int, Double)}, där $z$-koordinaten anger hur djupt ner i underjorden punkten ligger. På en hemlig plats finns uppgången till överjorden.
 
 \begin{Code}
 object Underjorden3D {
@@ -221,7 +221,7 @@
 \QUESTEND
 
 
-\WHAT{Färdigkompilerad kod i jarfil. Classpath. Använda paket.}
+\WHAT{Jar-fil. Classpath. Paket.}
 
 \QUESTBEGIN
 
@@ -238,7 +238,7 @@
 > wget -O cslib.jar http://cs.lth.se/pgk/cslib
 \end{REPLnonum}
 
-\Subtask Testa \code{SimpleWindow} i REPL enligt nedan. Med argumentet \code{-cp cslib.jar}, där optionen \code{cp} är en förkortning av \emph{classpath}, gör du koden i \code{cslib.jar} synlig i REPL.  Skriv kod som ritar en kvadrat med sidan $100$:
+\Subtask Testa \code{SimpleWindow} i REPL enligt nedan. Med argumentet \code{-cp cslib.jar}, där optionen \code{cp} är en förkortning av \emph{classpath}, gör du koden i \code{cslib.jar} synlig i REPL.  Skriv kod som ritar en kvadrat med sidan $100$ och som har sitt vänstra, övre hörn i punkten $(100,100)$, genom att fortsätta på nedan påbörjade kod:
 
 \begin{REPL}
 > scala -cp cslib.jar
@@ -248,7 +248,7 @@
 scala> val w = new cslib.window.SimpleWindow(400,300,"HEJ")
 scala> w.moveTo(100, 100)
 scala> w.lineTo(200, 100)
-scala> // rita en kvadrat
+scala> // fortsätt så att en hel kvadrat ritas
 \end{REPL}
 
 \Subtask Skriv nedan program med en editor i filen \code{hello-simplewindow.scala} och fyll i de saknade delarna så att en kvadrat ritas ut.
@@ -290,7 +290,49 @@
 
 \SOLUTION
 
-\TaskSolved \what~\TODO
+\TaskSolved \what~
+
+\SubtaskSolved När man skapar ett fönster ska tre argument ges enligt dokumentationen:
+\begin{itemize}[nolistsep,noitemsep]
+  \item \code{width : Int   } fönstrets bredd
+  \item \code{height: Int   } fönstrets höjd
+  \item \code{title : String} fönstrets titel
+\end{itemize}
+
+
+\SubtaskSolved
+\begin{REPL}
+> scala -cp cslib.jar
+scala> val w = new cslib.window.SimpleWindow(400,300,"HEJ")
+scala> w.moveTo(100, 100)
+scala> w.lineTo(200, 100)
+scala> w.lineTo(200, 200)
+scala> w.lineTo(100, 200)
+scala> w.lineTo(100, 100)
+\end{REPL}
+
+\SubtaskSolved
+\begin{Code}
+package hello
+
+object Main {
+  val w = new cslib.window.SimpleWindow(400,300,"HEJ")
+
+  def square(topLeft: (Int, Int))(side: Int): Unit = {
+    w.moveTo( topLeft._1,        topLeft._2        )
+    w.lineTo( topLeft._1 + side, topLeft._2        )
+    w.lineTo( topLeft._1 + side, topLeft._2 + side )
+    w.lineTo( topLeft._1       , topLeft._2 + side )
+    w.lineTo( topLeft._1       , topLeft._2        )
+  }
+
+  def main(args: Array[String]): Unit = {
+    println("Rita kvadrat:")
+    square(300,100)(50)
+  }
+}
+\end{Code}
+
 
 \QUESTEND
 
@@ -310,19 +352,25 @@
 På veckans labb ska vi använda \code{SimpleWindow}, som beskriver RGB-färger med klassen \code{java.awt.Color}.
 Det finns några fördefinierade färger i \code{java.awt.Color}, till exempel \code{java.awt.Color.black} för svart och \code{java.awt.Color.green} för grönt.
 Andra färger kan skapas genom att ange mängden rött, grönt och blått.
+Den tre parametrarna till \code{new java.awt.Color(r, g, b)} anger hur mycket \emph{rött}, \emph{grönt} respektive \emph{blått} som färgen ska innehålla, och mängderna ska vara i intervallet 0--255.
+Färgen $(153, 102, 51)$ innebär ganska mycket rött, lite mindre grönt och ännu mindre blått och det upplevs som brunt.
 
-På laborationen behöver vi dessa tre brunaktiga färger:
+
+\Subtask
+På laborationen behöver vi dessa tre brunaktiga färger och vill samla dem i ett singelobjekt som heter \code{Color} enligt nedan.
 \begin{Code}
+object Color {
   val mole   = new java.awt.Color( 51,  51,   0)
   val soil   = new java.awt.Color(153, 102,  51)
   val tunnel = new java.awt.Color(204, 153, 102)
+}
 \end{Code}
+\noindent Men vi vill helst göra import på \code{java.awt.Color} för att kunna använda klassens namn utan att upprepa hela sökvägen, trots att namnet krockar med namnet på vårt singelobjekt. Skriv om koden ovan med hjälp av namnbyte vid import så att färgerna kan skapas med \code{new JColor(...)}. Gör importen lokalt i singelobjektet \code{Color}.
+
 
-Den tre parametrarna till \code{new java.awt.Color(r, g, b)} anger hur mycket \emph{rött}, \emph{grönt} respektive \emph{blått} som färgen ska innehålla, och mängderna ska vara i intervallet 0--255.
-Färgen $(153, 102, 51)$ innebär ganska mycket rött, lite mindre grönt och ännu mindre blått och det upplevs som brunt.
 
 \noindent\begin{minipage}{0.82\textwidth}
-Använd koden nedan för att rita tre kvadrater i REPL. Proceduren \code{rak} ska rita en horisontell linje från punkten \code{p} med längden \code{d}. Proceduren \code{fyll} ska rita en fylld kvadrat med övre vänstra hörnet i punkten \code{p} och sidan \code{s}. Det som ritas ut ska se ut som bilden till höger.
+\Subtask Använd koden nedan för att rita tre kvadrater i REPL. Proceduren \code{rak} ska rita en horisontell linje från punkten \code{p} med längden \code{d}. Proceduren \code{fyll} ska rita en fylld kvadrat med övre vänstra hörnet i punkten \code{p} och sidan \code{s}. Det som ritas ut ska se ut som bilden till höger.
 \end{minipage}
 \hfill\begin{minipage}{0.23\textwidth}
 \includegraphics[width=\textwidth]{../img/fyll-rak.png}
@@ -336,9 +384,9 @@
 scala> def fyll(p:Pt)(s:Int) = for (i <- 0 to s){rak(???)(s)}
 
 scala> :paste
-val mole   = new java.awt.Color( 51,  51,   0)
-val soil   = new java.awt.Color(153, 102,  51)
-val tunnel = new java.awt.Color(204, 153, 102)
+object Color {
+ ???
+}
 
 scala> w.setLineColor(soil)
 scala> fyll(100,100)(75)
@@ -349,126 +397,123 @@
 scala> w.setLineColor(mole)
 scala> fyll(150,150)(25)
 \end{REPL}
-\noindent Vid anropen av \code{rak} och \code{fyll} ovan utnyttjas att man kan skippa tupelparenteserna om ett tupelargument är ensamt i sin parameterlista.
-
+\Subtask Vid vilka anrop ovan utnyttjas att tupelparenteserna kan skippas?
 
 \SOLUTION
 
 \TaskSolved \what~
-\begin{Code}
-def rak(p: Pt)(d: Int)  = { w.moveTo(p._1, p._2); w.lineTo(p._1 + d, p._2) }
-def fyll(p: Pt)(s: Int) = for (i <- 0 to s){ rak(p._1, p._2 + i)(s) }
-\end{Code}
-
-\QUESTEND
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-
-
-
-
-
-\ExtraTasks %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
+\SubtaskSolved
+\begin{Code}
+object Color {
+  import java.awt.{Color => JColor}
 
-\WHAT{Använda färdiga paket. Skapa en färgväljare.}
-
-\QUESTBEGIN
+  val mole   = JColor( 51,  51,   0)
+  val soil   = JColor(153, 102,  51)
+  val tunnel = JColor(204, 153, 102)
+}
+\end{Code}
 
-\Task \what~På laborationen har du nytta av att kunna blanda egna färger så att du kan rita himmel och gräs. Du kan använda färgväljaren i Kojo eller skapa en färgväljare själv med hjälp av swing-paketet enligt nedan. Vad händer om du efter nedan skriver \code{f.setVisible(false)}?
+\SubtaskSolved
 
-\begin{REPL}
-scala> val f = new javax.swing.JFrame
-scala> val c = new javax.swing.JColorChooser
-scala> f.add(c)
-scala> f.setVisible(true)    // välj färg i RGB-fliken
-scala> c.getColor
-scala> c.getColor.getAlpha   // alpha styr genomskinlighet
-\end{REPL}
+\begin{Code}
+def rak(p: Pt)(d: Int)  = {
+  w.moveTo(p._1    , p._2)
+  w.lineTo(p._1 + d, p._2)
+}
+def fyll(p: Pt)(s: Int) = for (i <- 0 to s) rak(p._1, p._2 + i)(s)
+\end{Code}
 
+\SubtaskSolved Vid anropen av \code{rak} och \code{fyll} utnyttjas att man kan skippa tupelparenteserna om ett tupelargument är ensamt i sin parameterlista.
 
-\SOLUTION
 
-\TaskSolved \what~\\När du skriver \code{f.setVisible(false)} så stängs färgfäljarfönstret.
 
 \QUESTEND
 
 
 
-
-\AdvancedTasks %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-
-
-\WHAT{Undersök JDK.}
+\WHAT{Lat initialisering.}
 
 \QUESTBEGIN
 
-\Task \what~ Ta med hjälp av \url{http://stackoverflow.com/} reda på hur många klasser och paket det finns i Java-plattformen JDK8.
-
-\SOLUTION
-
-\TaskSolved \what~Med JDK8-plattformen kommer 4240 färdiga klasser, som är organiserade i 217 olika paket. Se Stackoverflow: \\\url{http://stackoverflow.com/questions/3112882}
-
-\QUESTEND
+\Task \what~ Med \code{lazy val} kan man fördröja initialiseringen.
 
+\Subtask Vad ger raderna 2 och 3 nedan för resultat?
+\begin{REPL}
+scala> lazy val z = { println("nu!"); Array.fill(1e1.toInt)(0)}
+scala> z
+scala> z
+\end{REPL}
 
+\Subtask Prova ovan igen men med så stor array att minnet blir fullt. När sker allokeringen?
 
-\WHAT{Tupler som funktionsresultat.}
+\Subtask Singelobjekt är lata. Initialiseringsordningen kan bli fel.
+\begin{Code}
+object test {
+  object zzz    { val a = { println("nu!"); 42} }
+  object buggig { val a = b ; val b = 42        }
+  object funkar { lazy val a = b; val b = 42    }
 
-\QUESTBEGIN
+}
+\end{Code}
+\noindent Klistra in modulen \code{test} i REPL. Vad ger kompilatorn för varning? Skrivs  \code{"nu!"} ut?
 
-\Task \what~Tupler möjliggör att en funktion kan returnera flera olika värden på samma gång. Implementera funktionen statistics nedan. Den ska returnera en 3-tupel som innehåller antalet element i \code{xs}, medelvärdet av elementen, samt en 2-tupel med variationsvidden $(min, max)$. Ange returtypen explicit i din implementation. Testa så att den fungerar i REPL. \emph{Tips:} Du har nytta av metoderna \code{size}, \code{sum}, \code{min} och \code{max} som fungerar på nummersekvenser.
+\Subtask Vad händer i REPL om du refererar de tre olika \code{a}-variablerna?
 
-\begin{Code}
-/** Returns the size, the mean, and the range of xs */
-def statistics(xs: Vector[Double]) = ???
-\end{Code}
+\Subtask Vad är det för skillnad på \code{ lazy val a = uttryck } och \code{ def b = uttryck }?
 
 \SOLUTION
 
 \TaskSolved \what~
 
-\begin{Code}
-def statistics(xs: Vector[Double]): (Int, Double, (Double, Double)) =
-  (xs.size, xs.sum / xs.size, (xs.min, xs.max))
-\end{Code}
-
+\SubtaskSolved \code{"nu!"} skrivs bara ut första gången \code{z} används.
 \begin{REPL}
-scala> statistics(Vector(0, 2.5, 5))
-res10: (Int, Double, (Double, Double)) = (3,2.5,(0.0,5.0))
-\end{REPL}
-
-\QUESTEND
-
-
-
+scala> z
+nu!
+res19: Array[Int] = Array(0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
 
+scala> z
+res20: Array[Int] = Array(0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
+\end{REPL}
 
-\WHAT{Skapa din egen \code{jar}-fil. \TODO}
-
-\QUESTBEGIN
-
-\Task  \what~
-
-\Subtask Skriv kommandot \code{jar} i terminalen och undersök vad som finns för optioner. Se speciellt ''Example 1.'' i hjälputskriften. Vilket kommando ska du använda för att packa ihop flera filer i en enda jar-fil?
+\SubtaskSolved Allokeringen av arrayen sker första gången \code{z} används (och inte vid deklarationen).
+\begin{REPL}
+scala> lazy val z = { println("nu!"); Array.fill(1e9.toInt)(0)}
+z: Array[Int] = <lazy>
 
-\Subtask Packa ihop biblioteket \TODO \code{gurka} i en jar-fil med nedan kommando, samt kör igång REPL med jar-filen på classpath.
+scala> z
+nu!
+java.lang.OutOfMemoryError: Java heap space
+\end{REPL}
 
+\SubtaskSolved Nej, utskriften av \code{"nu!"} sker först när singelobjektet \code{zzz} används för första gången. Varningen lyder:
 \begin{REPL}
-> jar cvf mittpaket.jar gurka
-> scala -cp mittpaket.jar
-scala> gurka.tomat.banan.Main.main(Array())
+warning: Reference to uninitialized value b
+         object buggig { val a = b ; val b = 42}
 \end{REPL}
+\noindent Detta är en varning om att det kan bli problem på grund av initialiseringsordningen. Vi borde lägga initialiseringen av \code{b} före \code{a} eller göra \code{a} till en \code{lazy val}.
 
+\SubtaskSolved
+\begin{REPL}
+scala> import test._
+import test._
 
-\SOLUTION
+scala> zzz.a      // först när vi använder zzz skrivs "nu!"
+nu!               // detta skedde *inte* när vi importerade test
+res0: Int = 42
 
+scala> buggig.a   // a blir 0 eftersom b inte är initialiserad
+res1: Int = 0
 
-\TaskSolved \what\TODO
+scala> funkar.a   // med lazy val unviker vi problemet
+res2: Int = 42
 
 
-\SubtaskSolved  jar cvf [namn på skapad fil] [namn på input-filer]
+scala> zzz.a     // andra gången är init redan gjort och ingen "nu!"
+res3: Int = 42
+\end{REPL}
 
-\SubtaskSolved  -
+\SubtaskSolved \code{lazy val a = uttryck } innebär att initialiseringsuttrycket evalueras \emph{en} gång, men evalueringen skjuts på framtiden tills det eventuellt händer att namnet \code{a} används, medan \code{ def b = uttryck } innebär att funktionskroppens uttryck evalueras \emph{varje gång} namnet \code{b} (eventuellt) används.
 
 
 \QUESTEND
@@ -477,67 +522,59 @@
 
 
 
+\clearpage
 
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-
-\subsection{\TODO Fixa detta som är hitflyttat från labben}
-
+\ExtraTasks %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
 
 
-\WHAT{Objekt som moduler.}
+\WHAT{Moduler med singelobjekt.}
 
 \QUESTBEGIN
 
-\Task  \what~ Deklarera modulerna \code{stringstat} och \code{Test} nedan i REPL eller i Kojo.
+\Task  \what~
+
+\Subtask Undersök i REPL vad uttrycket \code{"päronisglass".split('i')} har för värde.
 
+\Subtask Vad skrivs ut om du med \code{Test()} anropar \code{apply}-metoden nedan?
 \begin{Code}
-object stringstat {
-  object stringfun {
+object stringUtils {
+  object split {
     def sentences(s: String): Array[String] = s.split('.')
-    def words(s: String): Array[String] = s.split(' ')
-    def countWords(s: String): Int = words(s).size
-    def countSentences(s: String): Int = sentences(s).size
+    def words(s: String):     Array[String] = s.split(' ')
+  }
+
+  object count {
+    def letters(s: String):   Int = s.count(_.isLetter)
+    def words(s: String):     Int = split.words(s)    .size
+    def sentences(s: String): Int = split.sentences(s).size
   }
 
   object statistics {
-    var history = ""
-    def printFreq(s: String): Unit = {
-      println("\n---- Frekvenser ----")
-      println("Antal tecken:   " + s.size)
-      println("Antal ord:      " + stringfun.countWords(s))
-      println("Antal meningar: " + stringfun.countSentences(s))
+    private var history = ""
+    def printFreq(s: String = history): Unit = {
+      println("\n--- FREKVENSANALYS AV:\n" + s)
+      println("# bokstäver: " + count.letters(s))
+      println("# ord      : " + count.words(s))
+      println("# meningar : " + count.sentences(s))
       history = history + " " + s
     }
-    def printTotal: Unit = printFreq(history)
   }
 }
 
 object Test {
-  import stringstat._
-  def apply(n: Int = 42): Unit = {
+  import stringUtils._
+  def apply(): Unit = {
     val s1 = "Fem myror är fler än fyra elefanter. Ät gurka."
-    val s2 = "Galaxer i mina braxer. Tomat är gott. Hejsan."
-    statistics.printFreq(s1 * n)
-    statistics.printFreq(s2 * n)
-    statistics.printTotal
+    val s2 = "Galaxer i mina braxer. Tomat är gott. Päronsplitt."
+    statistics.printFreq(s1)
+    statistics.printFreq(s2)
+    statistics.printFreq()
   }
 }
 \end{Code}
 
-\Subtask Anropa \code{Test()} och förklara vad som händer. Vad skrivs ut?
-
-\Subtask Vilket av objekten i modulen \code{stringstat} har tillstånd och vilket av objekten är tillståndslöst? Vad består tillståndet av?
+\Subtask Vilket av objekten i modulen \code{stringUtils} har tillstånd? Är det förändringsbart?
 
 
 \SOLUTION
@@ -545,61 +582,109 @@ \subsection{\TODO Fixa detta som är hitflyttat från labben}
 
 \TaskSolved \what
 
+\SubtaskSolved
+\begin{REPLnonum}
+scala> "päronisglass".split('i')
+res0: Array[String] = Array(päron, sglass)
+\end{REPLnonum}
 
 \SubtaskSolved
 \begin{REPLnonum}
+scala> Test()
+
+--- FREKVENSANALYS AV:
+Fem myror är fler än fyra elefanter. Ät gurka.
+# bokstäver: 36
+# ord      : 9
+# meningar : 2
+
+--- FREKVENSANALYS AV:
+Galaxer i mina braxer. Tomat är gott. Päronsplitt.
+# bokstäver: 40
+# ord      : 8
+# meningar : 3
+
+--- FREKVENSANALYS AV:
+ Fem myror är fler än fyra elefanter. Ät gurka. Galaxer i mina
+ braxer. Tomat är gott. Päronsplitt.
+# bokstäver: 76
+# ord      : 18
+# meningar : 5
+
+\end{REPLnonum}
 
----- Frekvenser ----
-Antal tecken: 1932
-Antal ord: 337
-Antal meningar: 84
+\SubtaskSolved  Objektet \code{statistics} har ett förändringsbart tillstånd i variabeln \code{history}. Tillståndet ändras vid anrop av \code{printFreq}.
 
----- Frekvenser ----
-Antal tecken: 1890
-Antal ord: 295
-Antal meningar: 126
+\QUESTEND
 
----- Frekvenser ----
-Antal tecken: 3824
-Antal ord: 633
-Antal meningar: 210
 
-\end{REPLnonum}
+\WHAT{Tupler som parametrar.}
+
+\QUESTBEGIN
 
-Först och främst, vi har default argument 42 så det är det som används vid anropet. Detta används för att multiplicera \code{s1} och \code{s2} i \code{Test} när man anropar \code{printFreq}. \code{statistics} objektet använder i sin tur funktionerna i \code{stringfun} för att räkna ord och meningar. Resultatet presenteras av \code{statistics}, vilket är det vi ser.
+\Task  \what~ Implementera nedan olika varianter av beräkning av avståndet mellan två punkter. \emph{Tips:} Använd \code{math.hypot}.
+\begin{Code}
+def distxy(x1: Int, y1: Int, x2: Int, y2: Int): Double = ???
+def distpt(p1: (Int, Int), p2: (Int, Int)):     Double = ???
+def distp(p1: (Int, Int))(p2: (Int, Int)):      Double = ???
 
-\SubtaskSolved  Vi ser att \code{stringfun} enbart innehåller funktioner och därmed inte har något tillstånd. \code{statistics} har däremot ett tillstånd eftersom variabeln \code{history} sparar vad som skett, så när man anropar funktioner i objektet så kan objektet ändra beteende beroende på dess tillstånd, tillståndet består alltså av \code{history}.
+\end{Code}
 
+\SOLUTION
 
-\QUESTEND
+\TaskSolved \what
+
+\begin{Code}
+def distxy(x1: Int, y1: Int, x2: Int, y2: Int): Double =
+  hypot(x1 - x2, y1 - y2)
 
+def distpt(p1: (Int, Int), p2: (Int, Int)): Double =
+  hypot(p1._1 - p2._1, p2._2 - p2._2)
 
+def distp(p1: (Int, Int))(p2: (Int, Int)): Double =
+  hypot(p1._1 - p2._1, p2._2 - p2._2)
+\end{Code}
 
+\QUESTEND
 
 
-\WHAT{Paket, \code{import} och klassfilstrukturer.}
+\WHAT{Tupler som funktionsresultat.}
 
 \QUESTBEGIN
 
-\Task \what~
+\Task \what~Tupler möjliggör att en funktion kan returnera flera olika värden på samma gång. Implementera funktionen statistics nedan. Den ska returnera en 3-tupel som innehåller antalet element i \code{xs}, medelvärdet av elementen, samt en 2-tupel med variationsvidden $(min, max)$. Ange returtypen explicit i din implementation. Testa så att den fungerar i REPL. \emph{Tips:} Du har nytta av metoderna \code{size}, \code{sum}, \code{min} och \code{max} som fungerar på nummersekvenser.
 
-\Subtask Kör raderna nedan i REPL. Beskriv vad som händer för varje rad.
-\begin{REPL}[numbers=left, numberstyle=\color{black}\ttfamily\scriptsize\selectfont]
-scala> import javax.swing.JOptionPane
-scala> def msg(s: String) = JOptionPane.showMessageDialog(null, s)
-scala> msg("Hej på dej!")
-scala> def input(msg: String) = JOptionPane.showInputDialog(null, msg)
-scala> input("Vad heter du?")
-scala> import JOptionPane.{showOptionDialog => optDlg}
-scala> def inputOption(msg: String, opt: Array[Object]) =
-         optDlg(null, msg, "Option", 0, 0, null, opt, opt(0))
-scala> inputOption("Vad väljer du?", Array("Sten", "Sax", "Påse"))
+\begin{Code}
+/** Returns the size, the mean, and the range of xs */
+def statistics(xs: Vector[Double]) = ???
+\end{Code}
+
+\SOLUTION
+
+\TaskSolved \what~
+
+\begin{Code}
+def statistics(xs: Vector[Double]): (Int, Double, (Double, Double)) =
+  (xs.size, xs.sum / xs.size, (xs.min, xs.max))
+\end{Code}
+
+\begin{REPL}
+scala> statistics(Vector(0, 2.5, 5))
+res10: (Int, Double, (Double, Double)) = (3,2.5,(0.0,5.0))
 \end{REPL}
 
-\Subtask\Pen Vad hade du behövt ändra på efterföljande rader om import-satsen på rad 1 ovan ej hade gjorts?
+\QUESTEND
+
 
-\Subtask Skapa med en editor filen paket.scala och kompilera. Rita en bild av hur katalogstrukturen ser ut.
 
+
+\WHAT{Moduler med paket.}
+
+\QUESTBEGIN
+
+\Task \what~
+
+\Subtask Koden nedan ligger i filen \code{paket.scala}. Rita en bild av katalogstrukturen som skapas i aktuellt bibliotek när nedan kod kompileras med: \code{scalac paket.scala}
 \begin{Code}
 package gurka.tomat.banan
 
@@ -635,275 +720,332 @@ \subsection{\TODO Fixa detta som är hitflyttat från labben}
 }
 \end{Code}
 
-\begin{REPL}
-> gedit paket.scala
-> scalac paket.scala
-> scala gurka.tomat.banan.Main
-> ls -R
-\end{REPL}
+\Subtask Vad skrivs ut när programmet körs?
 
-\SOLUTION
+\Subtask Får paket ha tillståndsvariabler utan att de placeras inuti ett singelobjekt eller en klass?
 
+\SOLUTION
 
 \TaskSolved \what
 
+\SubtaskSolved
 
-\SubtaskSolved  \code{script   security   smartcardio   sound   sql   swing}
-
-\SubtaskSolved  Radernas funktion i ordning:
+\begin{REPL}
+> atom paket.scala
+> scalac paket.scala
+> find . -type d
+.
+./gurka
+./gurka/tomat
+./gurka/tomat/banan
+./gurka/tomat/banan/p1
+./gurka/tomat/banan/p1/p11
+./gurka/tomat/banan/p1/p12
+./gurka/tomat/banan/p2
+./gurka/tomat/banan/p2/p21
+\end{REPL}
 
-1. Importerar JOptionPane från javax.swing
+\SubtaskSolved
+\begin{REPL}
+> scala gurka.tomat.banan.Main
+Hej paket p1.p11!
+Hej paket p1.p12!
+Hej paket p2.p21!
+\end{REPL}
 
-2. Definierar en metod som tar en sträng och öppnar en dialogruta med strängen.
+\SubtaskSolved Nej, paket får varken ha variabler eller funktioner på toppnivå. Men det kan man i Scala lösa ändå med hjälp av ett s.k. \code{package object}. \\
+ \url{https://stackoverflow.com/questions/3400734}
 
-3. Testar funktionen med argumentet "Hej på dej!". En dialogruta öppnas med texten "Hej på dej!".
+\QUESTEND
 
-4. Definierar en metod som tar emot en sträng som argument och öppnar en input-dialogruta med strängen.
 
-5. Testar funktionen med argumentet "Vad heter du?". En dialogruta öppnas med texten "Vad heter du?". I ett fält kan man fylla i sitt namn. Funktionen returnerar namnet.
 
-6. Importerar showOptionDialog från JOptionPane under namnet optDlg.
 
-7. Definierar en metod som tar emot en sträng och en Array som argument och öppnar en flervalsdialog. Strängen ska innehålla frågan som flervalsdialogen visar upp. Arrayn ska innehålla alternativen som användaren ska välja mellan.
 
-8.Testar funktionen med argumenten \code{"Vad väljer du?"} och \\ \code{Array("Sten, "Sax", "Påse")}. En dialogruta kommer upp och man får möjlighet att välja sten sax eller påse. Funktionen returnerar valet som man gör.
+\AdvancedTasks %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
-\SubtaskSolved  På alla ställen där \code{JOptionPane} förekommer, hade man istället fått skriva \code{javax.swing.JOptionPane}.
 
-\SubtaskSolved  -
 
 
 
-\QUESTEND
 
+\WHAT{Använda färdigt paket: färgväljaren i \code{swing}.}
 
+\QUESTBEGIN
 
+\Task \what~På laborationen har du nytta av att kunna blanda egna färger så att du kan rita klarblå himmel och frodigt gräs. Du kan skapa en färgväljare med hjälp av swing-paketet enligt nedan. Vad händer om du efter nedan skriver \code{f.setVisible(false)}?
 
+\begin{REPL}
+scala> val f = new javax.swing.JFrame         // skapa osynligt fönster
+scala> val c = new javax.swing.JColorChooser  // skapa färgväljare
+scala> f.add(c)              // lägg färgväljaren i fönstret
+scala> f.setVisible(true)    // visa fönstret; välj färg i RGB-fliken
+scala> c.getColor            // undersök RGB-värdena
+scala> c.getColor.getAlpha   // alpha styr genomskinlighet
+\end{REPL}
 
 
+\SOLUTION
 
+\TaskSolved \what~\\När du skriver \code{f.setVisible(false)} så stängs färgfäljarfönstret.
 
+\QUESTEND
 
 
-\WHAT{Tupler som parametrar.}
+\WHAT{Använda färdigt paket: dialoger med \code{swing}.}
 
 \QUESTBEGIN
 
-\Task  \what~ Implementera nedan varianter av beräkning av avståndet mellan två punkter:
-\begin{Code}
-def distxy(x1: Int, y1: Int, x2: Int, y2: Int): Double = ???
+\Task \what~
+
+\Subtask Använd proceduren \code{msg} nedan för att meddela att det är \code{"Game over!"}.
+\begin{REPL}
+scala> import javax.swing.JOptionPane
+scala> def msg(s: String) = JOptionPane.showMessageDialog(null, s)
+\end{REPL}
 
-def distpt(p1: (Int, Int), p2: (Int, Int)): Double = ???
+\Subtask Använd funktionen \code{input} för att ta reda på användarens namn. Vad är returtypen? Vad händer om man klickar \emph{Cancel}?
+\begin{REPL}
+scala> def input(msg: String) = JOptionPane.showInputDialog(null, msg)
+\end{REPL}
 
-def distp(p1: (Int, Int))(p2: (Int, Int)): Double = ???
+\Subtask Använd funktionen \code{choice} för att be användaren välja mellan sten, sax och påse. Vad är returtypen?
+\begin{REPL}
+scala> import JOptionPane.{showOptionDialog => showOpt}
+scala> def choice(msg: String, opt: Vector[String], title: String = "?") =
+  showOpt(null, msg, title, 0, 0, null, opt.toArray[Object], opt(0))
+\end{REPL}
 
-\end{Code}
 
 \SOLUTION
 
-\TaskSolved \what
+\TaskSolved \what~
 
-\begin{Code}
-def distxy(x1: Int, y1: Int, x2: Int, y2: Int): Double =
-  hypot(x1 - x2, y1 - y2)
+\SubtaskSolved
+\begin{REPL}
+scala> msg("Game over!")
+\end{REPL}
 
-def distpt(p1: (Int, Int), p2: (Int, Int)): Double =
-  hypot(p1._1 - p2._1, p2._2 - p2._2)
+\SubtaskSolved Funktionen \code{input} returnerar en sträng som blir \code{null} om man klickar \emph{Cancel}.
+\begin{REPL}
+scala> val name = input("Vad heter du?")
+name: String = Oddput Kulkodare
+\end{REPL}
 
-def distp(p1: (Int, Int))(p2: (Int, Int)): Double =
-  hypot(p1._1 - p2._1, p2._2 - p2._2)
-\end{Code}
+\SubtaskSolved Funktionen \code{choice} returnerar ett heltal som är det index i argumentet till parametern \code{opt} som användaren valde.
+\begin{REPL}
+scala> choice("Vad väljer du?", Vector("Sten","Sax","Påse"))
+res0: Int = 2
+\end{REPL}
 
 \QUESTEND
 
 
 
 
-\WHAT{Värdeanrop och namnanrop (fördröjd evaluering, ''lata'' argument).}
+\WHAT{Skapa din egen \code{jar}-fil.}
 
 \QUESTBEGIN
 
-\Task  \what~  Deklarera nedan funktioner i REPL.
+\Task  \what~
 
-\begin{Code}
-def snark: Int = { print("snark "); Thread.sleep(1000); 42 }
+\Subtask Skriv kommandot \code{jar} i terminalen och undersök vad det finns för optioner. Se speciellt ''Example 1.'' i hjälputskriften. Vilket kommando ska du använda för att packa ihop flera filer i en enda jar-fil? Notera att man (konstigt nog) inte ska ha streck före optionerna när man använder kommandot \code{jar} enligt exempel 1.
 
-def callByValue(x: Int) = x + x
+\Subtask Skapa med en editor i filen \code{hello.scala} ett enkelt program som skriver ut \texttt{"Hello package!"} eller liknande. Koden ska ligga i paketet \code{hello} och innehålla ett object \code{Main} med en \code{main}-metod.
 
-def callByName(x: => Int) = x + x
-\end{Code}
+\Subtask Skriv kommando i terminalen som förpackar koden i en jar-fil med namnet \code{my.jar} och kör igång REPL med jar-filen på classpath. Anropa din \code{main}-funktion i REPL genom att ange sökvägen \textit{\texttt{paketnamn.objektnamn.metodnamn}} med en tom array som argument.
 
-Evaluera nedan uttryck. Förklara vad som händer.
+\Subtask Med vilket kommando kan du köra det kompilerade och jar-förpackade programmet direkt i terminalen (alltså utan att dra igång REPL)?
 
-\Subtask \code{snark}
+\SOLUTION
 
-\Subtask \code{snark; snark; snark}
+\TaskSolved \what
 
-\Subtask \code{callByValue(1)}
+\SubtaskSolved
 
-\Subtask \code{callByName(1)}
+\texttt{jar cvf \textit{<namn på skapad jar-fil> <namn på det som ska packas>}}
 
-\Subtask \code{callByValue(snark)}
+\SubtaskSolved
+\begin{Code}
+package hello
 
-\Subtask \code{callByName(snark)}
+object Main {
+  def main(args: Array[String]): Unit = println("Hello package!")
+}
+\end{Code}
 
+\SubtaskSolved
+\begin{REPL}
+> scalac hello.scala
+> jar cvf my.jar hello
+> ls
+> scala -cp my.jar
+scala> hello.Main.main(Array())
+\end{REPL}
 
-\Subtask Förklara vad som händer här:
+\SubtaskSolved
 \begin{REPL}
-scala> def görDetta(block: => Unit) = block
-scala> görDetta(println("hej"))
-scala> görDetta{println("goddag")}
-scala> görDetta{println("hej"); println("svejs")}
-scala> def görDettaTvåGånger(block: => Unit) = {block; block}
-scala> görDettaTvåGånger{println("goddag")}
+> scala -cp my.jar hello.Main
 \end{REPL}
 
+\QUESTEND
 
-\SOLUTION
 
 
-\TaskSolved \what
 
+\WHAT{Hur stor är JDK8?}
 
-\SubtaskSolved  \code{snark 42}
+\QUESTBEGIN
 
-\SubtaskSolved  \code{snark snark snark 42}
+\Task \what~ Ta med hjälp av \url{http://stackoverflow.com/} reda på hur många klasser och paket det finns i Java-plattformen JDK8.
 
-Den evaluerar inte uttrycket förrän det behövs, så flera snark ger bara ett resultat för det är bara det som begärs.
+\SOLUTION
 
-\SubtaskSolved  \code{2}
+\TaskSolved \what~Med JDK8-plattformen kommer 4240 färdiga klasser, som är organiserade i 217 olika paket. Se Stackoverflow: \\\url{http://stackoverflow.com/questions/3112882}
 
-\SubtaskSolved  \code{2}
+\QUESTEND
 
-Det är ingen större skillnad när vi bara skickar in en etta.
 
-\SubtaskSolved  \code{snark, Int = 84}
 
-\SubtaskSolved  När vi kallar på \code{callByValue} så skickar vi in snark som ett värde, och därmed behöver x bara beräknas en gång medans när vi kallar på \code{callByName} så skickar vi den som en funktion och därmed kallas snark på två gånger i funktionen för att beräkna x båda gångerna.
+\WHAT{Värdeanrop och namnanrop.}
 
-\code{snark snark, Int = 84}
+\QUESTBEGIN
 
-\SubtaskSolved  \code{görDetta} är en kontrollstruktur som helt enkelt exekverar koden den matas med, \code{görDettaTvåGånger} gör just vad den säger. Detta är dock grunderna för vad som kan bli mycket mer avancerat om man kombinerar detta med loopar eller if-satser, som i sig är kontrollstrukturer.
+\Task  \what~Normalt sker i Scala (och i Java) s.k. \emph{värdeanrop} vid anrop av funktioner, vilket innebär att argumentuttrycket evalueras \emph{före} bindningen till parameternamnet sker.
 
-\QUESTEND
+Man kan också i Scala (men inte i Java) med syntaxen \code{=>} framför parametertypen deklarera att \emph{namnanrop} ska ske, vilket innebär att evalueringen av argumentuttrycket fördröjs och sker \emph{varje gång} namnet används i metodkroppen.
 
+Deklarera nedan funktioner i REPL.
 
+\begin{Code}
+def snark: Int = { print("snark "); Thread.sleep(1000); 42 }
+def callByValue(x: Int):   Int = x + x
+def callByName(x: => Int): Int = x + x
+lazy val zzz = snark
+\end{Code}
 
+\noindent Förklara vad som händer när nedan uttryck evalueras.
 
-\WHAT{Skapa din egen kontrollstruktur.}
+\Subtask \code{snark + snark}
 
-\QUESTBEGIN
+\Subtask \code{callByValue(snark)}
 
-\Task  \what~
+\Subtask \code{callByName(snark)}
+
+\Subtask \code{callByName(zzz)}
+\SOLUTION
 
-\Subtask Använd fördröjd evaluering i kombination med en uppdelad parameterlista och skapa din egen kontrollstruktur enligt nedan. (Det är så här som loopen \code{upprepa} i Kojo är definierad.)
+\TaskSolved \what
+
+\SubtaskSolved Vid varje anrop av \code{snark} sker en utskrift och en fördröjnig innan $42$ returneras, \code{42 + 42 == 84} vilket blir värdet av uttrycket.
 \begin{REPL}
-scala> def upprepa(n: Int)(block: => Unit): Unit = {
-         var i = 0
-         while (i < n) {block; i += 1}
-       }
+scala> snark + snark
+snark snark res1: Int = 84
 \end{REPL}
 
-\Subtask Använd din nya loop-procedur och förklara vad som händer nedan.
+\SubtaskSolved Uttrycket \code{snark} evalueras direkt vid anropet och parametern \code{x} binds till värdet $42$ och i funktionskroppen beräknas $42+42$. Utskriften sker bara en gång.
 \begin{REPL}
-scala> upprepa(10)(println("hej"))
-scala> upprepa(1000){
-  val tärning = (math.random * 6 + 1).toInt
-  print(tärning + " ")
-}
+callByValue(snark)
+snark res2: Int = 84
 \end{REPL}
 
-\SOLUTION
-
-\TaskSolved \what
-
-\SubtaskSolved  -
+\SubtaskSolved Evalueringen av uttrycket \code{snark} fördröjs tills varje förekomst av parametern \code{x} i funktionskroppen. Utskriften sker två gånger.
+\begin{REPL}
+callByName(snark)
+snark snark res3: Int = 84
+\end{REPL}
 
-\SubtaskSolved  I den första parameterlistan så anges hur många gånger koden i den andra parameterlistan ska exekveras. så \code{upprepa(10)(println("hej"))} printar hej 10 gånger
+\SubtaskSolved Evalueringen av uttrycket \code{zzz} fördröjs tills varje förekomst av parametern \code{x} i funktionskroppen. Utskriften sker en gång eftersom \code{val}-variabler tilldelas sitt värde en gång för alla vid den fördröjda initialiseringen.
+\begin{REPL}
+callByName(zzz)
+snark res4: Int = 84
+\end{REPL}
 
 \QUESTEND
 
 
 
 
-
-
-\WHAT{Fördröjd initialisering (''lata'' variabler).}
+\WHAT{Skapa din egen kontrollstruktur med hjälp av namnanrop.}
 
 \QUESTBEGIN
 
 \Task  \what~
 
-\Subtask \label{subtask:delayalloc} Förklara vad som händer här:
-\begin{REPL}
-scala> val olat = 42
-scala> lazy val lat = 42
-scala> println(lat)
-scala> val nu = {Thread.sleep(1000); println("nu"); 42}
-scala> lazy val sen = {Thread.sleep(1000); println("sen"); 42}
-scala> def igen = {Thread.sleep(1000); println("hver gang"); 42}
-scala> println(nu)
-scala> println(sen)
-scala> println(igen)
-scala> println(nu)
-scala> println(sen)
-scala> println(igen)
-scala> object m {lazy val stor = Array.fill(1e9.toInt)(liten); val liten = 42}
-scala> m.liten
-scala> m.stor
-\end{REPL}
-
-\Subtask Vad är skillnaden mellan \code{val}, \code{lazy val} och \code{def}, vad gäller \emph{när} evalueringen sker?
-
-
-\Subtask \label{subtask:forwardref} Förklara vad som händer här:
-\begin{REPL}
-scala> object objektÄrLata { val sen = { println("nu!"); 42 } }
-scala> objektÄrLata
-scala> objektÄrLata.sen
-scala> {val x = y; val y = 42}
-scala> object buggig {val a = b; val b = 42}
-scala> buggig.a
-scala> object funkar {lazy val a = b; val b = 42}
-scala> funkar.a
-scala> object nowarning {val many = Array.fill(10)(one); val one = 1}
-scala> nowarning.many
-\end{REPL}
+\Subtask Deklarera denna procedur i REPL:
+\begin{Code}
+def görDettaTvåGånger(b: => Unit): Unit = { b; b }
+\end{Code}
 
-\Subtask Med ledning av uppgift \ref{subtask:delayalloc} och uppgift \ref{subtask:forwardref}, beskriv två olika situationer när kan man ha nytta av \code{lazy val}?
+\Subtask Anropa \code{görDettaTvåGånger} med ett block som parameter. Blocket ska innehålla en utskriftssats. Förklara vad som händer.
 
+\Subtask Använd namnanrop i kombination med en uppdelad parameterlista och skapa din egen kontrollstruktur enligt nedan.\footnote{Det är så loopen \code{upprepa} i Kojo är definierad.}
+\begin{Code}
+def upprepa(n: Int)(block: => Unit): Unit = {
+   var i = 0
+   while (i < n) { ??? }
+}
+\end{Code}
 
-\SOLUTION
+\Subtask
+Testa din kontrollstruktur i REPL. Låt upprepa 100 gånger att ett slumptal mellan 1 och 6 dras och sedan skrivs ut.
 
+\Subtask Fördelen med \code{upprepa} är att den är koncis och lättanvänd. Men den är inte lika lätt att använda om man behöver tillgång en loopvariabel. Definiera därför även nedan kontrollstruktur.
 
-\TaskSolved \what
+\begin{Code}
+def repeat(n: Int)(p: Int => Unit): Unit = {
+   var i = 0
+   while (i < n) { ??? }
+}
+\end{Code}
 
+\Subtask Använd \code{repeat} för att 100 gånger skriva ut loopvariabeln och ett slumpdecimaltal mellan 0 och 1.
 
-\SubtaskSolved  Notera vid deklarationen av \code{nu}, \code{sen} och \code{igen} så är det bara \code{nu} som tar tid och skriver ut sin text. För \code{nu} evalueras men de andra väntar.
 
-Men när vi ska kalla på dem så tar \code{nu} ingen tid och skriver inte ut nu medans \code{sen} och \code{igen} nu tar tid och skriver ut sin text. För \code{nu} har redan evaluerats men de andra behöver evalueras för de kallas på.
+\SOLUTION
 
-Och när vi kallar på dem för andra gången så är det bara \code{igen} som tar tid. För \code{nu} och \code{sen} är evaluerade och vid det här laget identiska medans \code{igen} behöver evalueras varje gång man kallar på den.
+\TaskSolved \what
 
-Vid deklaration av objektet så går allt bra, när vi kallar på \code{liten} så får vi 42 men när vi kallar på \code{stor} så får vi exception. Eftersom objekt är lata så evalueras inte objektet förrän vi anropar något ur det men \code{stor} är också lazy så den blir inte ett problem förrän just den anropas.
+\SubtaskSolved Blocket är ett uttryck som har värdet \code{(): Unit}. Evalueringen av blocket sker där namnet \code{b} förekommer i procedurkroppen, vilket är två gånger.
+\begin{REPL}
+scala> görDettaTvåGånger { println("goddag") }
+goddag
+goddag
+\end{REPL}
 
 \SubtaskSolved
-\code{val} evalueras direkt, \code{lazy val} evalueras när det behövs medans \code{def} evalueras varje gång det behövs.
+\begin{Code}
+def upprepa(n: Int)(block: => Unit): Unit = {
+   var i = 0
+   while (i < n) {block; i += 1}
+}
+\end{Code}
 
 \SubtaskSolved
-När vi skapar objektÄrLata så skrivs inget ut för det evalueras inte förrän vi kallar på det, som vi gör nästa rad då skrivs nu ut. När vi sedan anropar sen evalueras inget och nu skrivs inte ut.
-
-\{\code{val x=y; val y = 42}\} kastar error eftersom y inte är evaluerad när vi försöker evaluera x.
-
-När vi skapar \code{buggig} så varnar den och vi ser varför på nästa rad då att \code{a} verkar vara lika med 0. Eftersom \code{b} inte är evaluerad än så blir det 0 men till skillnad från tidigare vet \code{val a} iallafall att den är en Int eftersom objectet med \code{b} är åtminstone definerat.
+\begin{Code}
+upprepa(100){
+  val tärningskast = (math.random * 6 + 1).toInt
+  print(tärningskast + " ")
+}
+\end{Code}
 
-\code{funkar} fungerar just för att \code{a} är en \code{lazy val} och evalueras då inte förrän efter \code{b} evaluerats och ger därför 42 som den ska.
 
-\code{nowarning} har samma problem som \code{buggig} men ger ingen varning och därför försöker skriva ut innan \code{one} är evaluerad och ger därför nollor.
+\SubtaskSolved
+\begin{Code}
+def repeat(n: Int)(p: Int => Unit): Unit = {
+   var i = 0
+   while (i < n) {p(i); i += 1}
+}
+\end{Code}
 
 \SubtaskSolved
-När man vill skapa ett objekt som funkar eller fixa problemet i no warning, man kan vilja ha sina variabler i just den ordningen p.g.a. läslighet.
+\begin{Code}
+repeat(100){ i =>
+  print(i + ": ")
+  println(math.random)
+}
+\end{Code}
+
 
-Men även om man inte vill slöa ner ett system med en massa arbete när allt deklareras på en gång utan tar det hellre gradvis allteftersom det används.
 
 \QUESTEND
diff --git a/quiz/QuizData.scala b/quiz/QuizData.scala
index d51386b5b..c33eca80e 100644
--- a/quiz/QuizData.scala
+++ b/quiz/QuizData.scala
@@ -109,7 +109,7 @@ object QuizData {  // to generate tables for a concept connection quizes in late
 
     "quiz-w02-array-vector-equality" -> Vector(  //programs
       "Vector" -> "\\code|xs == ys| är \\code|true| om alla element lika",
-      "Array " -> "olikt andra samlingar kollar \\code|==| ej innehållslikhet",
+      "Array " -> "olikt andra Scala-samlingar kollar \\code|==| ej innehållslikhet",
       "" -> ""
     ).filter(_._1.trim.nonEmpty),