add multiple examples and explanations to lists and related topics

Author: mohnoor94

src/main/scala/_010_functions/_02_1_HigherOrderFunctions.scala

@@ -2,6 +2,9 @@ package _010_functions
 
 import scala.language.postfixOps
 
+/**
+  * a function is "higher-order" if it takes one or more other functions as a parameters.
+  */
 object _02_1_HigherOrderFunctions extends App {
   // Functions with functions (Higher order functions)
   // function2...

src/main/scala/_010_functions/_03_Currying.scala

@@ -3,6 +3,12 @@ package _010_functions
 /**
   * Currying is the technique of transforming a function that takes multiple arguments
   * into a function that take a single argument
+  *
+  * ▶ When designing a polymorphic method that takes some non-function arguments and a function argument, place the
+  * function argument last in a curried parameter list on its own. That way, the method's correct instance type can
+  * be inferred from the non-function arguments, and that type can in turn be used to type check the function argument.
+  * The net effect is that users of the method will be able to give less type information and write function literals in
+  * more compact ways.
   */
 object _03_Currying extends App {
   {
@@ -33,8 +39,8 @@ object _03_Currying extends App {
     def baz(x: Int, y: Int)(z: Int): Int = x + y + z
 
     val f3 = foo _ // => function3
-    val f1 = bar _ // => function1
-    val f2 = baz _ // => function2
+  val f1 = bar _ // => function1
+  val f2 = baz _ // => function2
 
     val g1 = foo(5, _: Int, _: Int)
     val g2 = bar(5) _

src/main/scala/_020_collections/_01_Lists.scala

@@ -2,6 +2,22 @@ package _020_collections
 
 import java.time.LocalTime
 
+/**
+  * > Lists are quite similar to arrays, but there are two important differences.
+  * >> First, lists are immutable. That is, elements of a list cannot be changed by assignment.
+  * >> Second, lists have a recursive structure (i.e., a linked list), whereas arrays are flat.
+  *
+  * > The list type in Scala is covariant. This means that for each pair of types S and T, if S is a subtype of T, then
+  * List[S] is a subtype of List[T]. For instance, List[String] is a subtype of List[Object]
+  * >> This is natural because every list of strings can also be seen as a list of objects.
+  * >> The empty list has type List[Nothing].
+  * >> So the empty list object, which has type List[Nothing], can also be seen as an object of every other list type of
+  * the form List[T] (Nothing is the bottom type of every other type in Scala).
+  *
+  *
+  * >> IMPORTANT:
+  * Study '16.10 Understanding Scala's type inference algorithm', From: Programming in Scala, Third Edition.
+  */
 object _01_Lists extends App {
   val a = List(1, 2, 3, 4, 5)
   val a2 = List.apply(1, 2, 3, 4, 5)
@@ -24,6 +40,13 @@ object _01_Lists extends App {
   println(s"a.tail: ${a.tail}")
   println(s"a.tail.head: ${a.tail.head}")
   println(s"a.tail.tail.head: ${a.tail.tail.head}")
+  /**
+    * > Unlike head and tail, which both run in constant time, init and last need to traverse the whole list to compute
+    * their result.
+    * >> As a result, they take time proportional to the length of the list.
+    * ▶ It's a good idea to organize your data so that most accesses are at the head of a list, rather than the last
+    * element.
+    */
   println(s"a.init: ${a.init}")
   println(s"a.last: ${a.last}")
 
@@ -32,12 +55,23 @@ object _01_Lists extends App {
   println(s"a(3): ${a(3)}")
   println(s"a.min: ${a.min}")
   println(s"a.max: ${a.max}")
+  /**
+    * > On lists, unlike arrays, length is a relatively expensive operation.
+    * >> It needs to traverse the whole list to find its end, and therefore
+    * >> takes time proportional to the number of elements in the list.
+    * >> That's why it's not a good idea to replace a test such as xs.isEmpty by xs.length == 0.
+    * >> The result of the two tests is equivalent, but the second one is slower, in particular if the list xs is long.
+    */
   println(s"a.isEmpty: ${a.isEmpty}")
   println(s"a.nonEmpty: ${a.nonEmpty}")
   println(s"a.updated(3, 100): ${a.updated(3, 100)}")
 
   println("===================")
 
+  println(s"a indices ==> ${a.indices}")
+
+  println("===================")
+
   print("a.mkString(\",\"): ")
   println(a.mkString(","))
 
@@ -66,6 +100,10 @@ object _01_Lists extends App {
 
   println("===================")
 
+  /**
+    * If at some point in the computation an algorithm demands frequent accesses to the end of a list, it's sometimes
+    * better to reverse the list first and work with the result instead.
+    */
   println(s"a.reverse: ${a.reverse}")
 
   println("===================")

src/main/scala/_021_collections_with_functions/_02_Filter_FilterNot_Exsits_Functions.scala

@@ -1,46 +1,48 @@
 package _021_collections_with_functions
 
+import scala.language.postfixOps
+
 object _02_Filter_FilterNot_Exsits_Functions extends App {
   val a = 1 to 10
-  println(a.filter(x => x % 2 == 0))
-  println(a.filter(_ % 2 == 0))
-  println
-  println
-  println(a.filterNot(x => x % 2 == 0))
-  println(a.filterNot(_ % 2 == 0))
-  println
-  println
-  println(a.exists(x => x % 2 == 0))
-  println(a.exists(_ % 2 == 0))
-  println
-  println
+  println(s"a.filter(x => x % 2 == 0) ==> ${a.filter(x => x % 2 == 0)}")
+  println(s"a.filter(_ % 2 == 0) ==> ${a.filter(_ % 2 == 0)}")
+  println()
+
+  println(s"a.filterNot(x => x % 2 == 0) ==> ${a.filterNot(x => x % 2 == 0)}")
+  println(s"a.filterNot(_ % 2 == 0) ==> ${a.filterNot(_ % 2 == 0)}")
+  println()
+
+  println(s"a.exists(x => x % 2 == 0) ==> ${a.exists(x => x % 2 == 0)}")
+  println(s"a.exists(_ % 2 == 0) ==> ${a.exists(_ % 2 == 0)}")
+  println()
+
+  println(s"a.forall(x => x % 2 == 0) ==> ${a.forall(x => x % 2 == 0)}")
+  println(s"a.forall(_ % 2 == 0) ==> ${a.forall(_ % 2 == 0)}")
+  println()
 
   // you may use Regex for this!
-  def filterVowels(s: String) = s.toLowerCase.filter(c => Set('a', 'e', 'i', 'o', 'u').contains(c))
+  def filterVowels(s: String): String = s.toLowerCase.filter(c => Set('a', 'e', 'i', 'o', 'u').contains(c))
 
+  print("filterVowels(\"Orange\") ==> ")
   println(filterVowels("Orange"))
-  println
-  println
+  println()
+
   val b = Set("Brown", "Red", "Green", "purple", "Gray", "Yellow")
-  println(b.filter(s => filterVowels(s).length > 1))
+  println(s"b.filter(s => filterVowels(s).length > 1) ==> ${b.filter(s => filterVowels(s).length > 1)}")
+  println()
 
-  println
-  println
   val m = Map(1 -> "One", 2 -> "Two", 3 -> "Three", 4 -> "Four")
-  println(m.filterKeys(_ % 2 == 0))
-
-  println
-  println
-  println(Some(5).filter(_ % 2 == 0)) // THIS IS WOW!
-  println(Some(4).filter(_ % 2 == 0))
-
-  println
-  println
-  val xs = Array(1, 2, 3, 44)
-  println((xs map (2 *)).toList) // convert to list only to show contents
-
-  println
-  println
-  val s = "Hello World"
-  println(s filter (_.isUpper))
-}
+  println(s"m.filterKeys(_ % 2 == 0) ==> ${m.filterKeys(_ % 2 == 0)}")
+  println()
+
+  println(s"Some(5).filter(_ % 2 == 0) ==> ${Some(5).filter(_ % 2 == 0)}") // THIS IS WOW!
+  println(s"Some(4).filter(_ % 2 == 0) ==> ${Some(4).filter(_ % 2 == 0)}")
+  println()
+
+  // convert to list only to show contents
+  println(s"(Array(1, 2, 3, 44) map (2 *)).toList ==> ${(Array(1, 2, 3, 44) map (2 *)).toList}")
+  println()
+
+  print("\"Hello World\" filter (_.isUpper) ==> ")
+  println("Hello World" filter (_.isUpper))
+}

src/main/scala/_021_collections_with_functions/_07_ZipAndUnzip.scala

@@ -1,13 +1,36 @@
 package _021_collections_with_functions
 
+import scala.language.postfixOps
+
+/**
+  * > The zip and unzip methods provide one way to operate on multiple lists together.
+  * > Useful special case is to zip a list with its index. This is done most efficiently with the zipWithIndex
+  * method, which pairs every element of a list with the position where it appears in the list.
+  * > The zipped method on tuples generalizes several common operations to work on multiple lists instead of just one.
+  * >> One such operation is map. The map method for two zipped lists maps pairs of elements rather than individual
+  * elements. One pair is for the first element of each list, another pair is for the second element of each list, and so on
+  */
 object _07_ZipAndUnzip extends App {
   val a = List(1, 2, 3, 4)
   val b = List(5, 6, 7, 8)
   val z = a zip b
+
   println("zip: " + z)
+  println()
 
-  println((1 to 5) zip (6 to 9))
-  println((1 to 2) zip (6 to 9))
+  println(s"(1 to 5) zip (6 to 9) ==> ${(1 to 5) zip (6 to 9)}")
+  println(s"(1 to 2) zip (6 to 9) ==> ${(1 to 2) zip (6 to 9)}")
+  println()
+
+  println(s"a zipWithIndex ==> ${a zipWithIndex}")
+  println()
 
   println("unzip: " + z.unzip)
+  println()
+
+  val intPair = (List(10, 20), List(3, 4, 5))
+  val stringLengths = (List("abc", "de"), List(3, 2))
+  println(s"intPair.zipped.map(_ * _) ==> ${intPair.zipped.map(_ * _)}")
+  println(s"stringLengths.zipped.forall(_.length == _) ==> ${stringLengths.zipped.forall(_.length == _)}")
+  println(s"stringLengths.zipped.exists(_.length != _) ==> ${stringLengths.zipped.exists(_.length != _)}")
 }

src/main/scala/_021_collections_with_functions/_99_MoreFunctions.scala

@@ -5,6 +5,7 @@ import scala.language.postfixOps
 object _99_MoreFunctions extends App {
   val a = List(1, 2, 3, 4, 5, 6)
   //  val b = a partition (x => x % 2 == 0)
+  /** xs partition p    equals    (xs filter p, xs filter (!p(_))) */
   val b = a partition (_ % 2 == 0)
   println("===== partition =====")
   println(b)
@@ -15,76 +16,105 @@ object _99_MoreFunctions extends App {
   println(a filter (_ % 2 == 0))
   println(a filterNot (_ % 2 == 0))
 
-  println
+  println()
+  /** The find method is also similar to filter, but it returns the first element satisfying a given predicate,
+    * rather than all such elements. */
+  println("===== find =====")
+  println(a find (_ % 2 == 0))
+
+  println()
 
   val colours = List("Red", "Orange", "Green", "Grey", "Purple", "Pink")
   //  val gb = colours.groupBy(x => x.head)
   val gb = colours groupBy (_.head)
   println("===== groupBy =====")
   println(gb)
 
-  println
+  println()
 
   println("===== sort =====")
   println(colours sortWith (_.length < _.length))
   println(colours sortBy (_.head))
   println(colours sorted)
 
-  println
+  println()
 
   println("===== take =====")
   println((1 to 100).take(10).toList)
   println((1 to 100).takeRight(10).toList)
   println((1 to 100).takeWhile(_ < 10).toList)
 
-  println
+  println()
 
   println("===== drop =====")
   println((1 to 100).drop(90).toList)
   println((1 to 100).dropRight(90).toList)
   println((1 to 100).dropWhile(_ < 90).toList)
 
-  println
-  println("*------*")
-  println
+  println()
+
+  println("===== splitAt =====")
+  println("> xs splitAt n equals (xs take n, xs drop n)")
+  println(">> However, splitAt avoids traversing the list xs twice.")
+  println((1 to 100).splitAt(50))
+  println((1 to 100).splitAt(20))
+
+  println()
 
   println("===== span =====")
+  /** xs span p    equals    (xs takeWhile p, xs dropWhile p)
+    * Like splitAt, span avoids traversing the list xs twice */
   println("> span is takeWhile + dropWhile")
   println((1 to 100).span(_ < 10))
   println((1 to 100).span(_ < 90))
 
-  println
+  println()
 
   println("===== reverse =====")
   println((1 to 10).reverse.toList)
 
-  println
+  println()
 
   println("===== distinct =====")
   println(List(1, 1, 2, 3, 4, 5, 6, 6, 4, 7, 8, 9, 10, 9, 10).distinct)
 
-  println
+  println()
 
   println("===== empty =====")
   println(List.empty)
   println(List.empty[Int])
   println(List.empty[String])
   println(List.empty[List[Int]])
 
-  println
+  println()
 
   println("===== exists =====")
   println(a exists (_ >= 5))
   println(a exists (_ <= 5))
 
-  println
+  println()
 
   println("===== forall =====")
   println(a forall (_ >= 5))
   println(a forall (_ <= 5))
   println(a forall (_ <= 6))
 
-  println
+  println()
+
+  println("===== fill =====")
+  println(List.fill(10)('a'))
+  println(List.fill(10)(5))
+  println(List.fill(10)(" "))
+  println(List.fill(2, 3)('b'))
+
+  println()
+
+  println("===== tabulate =====")
+  /** The tabulate method creates a list whose elements are computed according to a supplied function. */
+  println(List.tabulate(5)(n => n * n))
+  println(List.tabulate(5, 5)(_ * _))
+
+  println()
 
   println("===== collect =====")
   /* collect will apply a partial function to all elements
@@ -96,7 +126,7 @@ object _99_MoreFunctions extends App {
     .collect { case x: Int if x % 2 == 0 => x * 2 }
   println(collectResult)
 
-  println
+  println()
 
   println("===== scan =====")
   /* scan is like a reduce but maintains a running total
@@ -105,7 +135,7 @@ object _99_MoreFunctions extends App {
   val scanResult = List(1, 2, 3).scan(1) { (total, next) => total * next }
   println(scanResult)
 
-  println
+  println()
 
   println("===== view =====")
   /* view will not immediately evaluate a chain until a terminal
@@ -115,7 +145,7 @@ object _99_MoreFunctions extends App {
   val viewResult = (1 to 1000000000).view.map(x => x * 2).take(10).mkString(", ")
   println(viewResult)
 
-  println
+  println()
 
   println("===== by name example =====")
   val f = List.fill(10) {
@@ -125,8 +155,4 @@ object _99_MoreFunctions extends App {
   }
 
   println(f)
-
-  println
-  println("*------*")
-  println
 }