Removed deprecation warnings from main project and tests

Author: kiroco12

build.sbt

@@ -10,10 +10,10 @@ lazy val stdlib = (project in file("."))
     libraryDependencies ++= Seq(
       dep("exercise-compiler"),
       dep("definitions"),
-      %%("shapeless"),
-      %%("scalatest"),
-      %%("scalacheck"),
-      %%("scheckShapeless")
+      "com.chuusai"                %% "shapeless"                 % "2.3.3",
+      "org.scalatest"              %% "scalatest"                 % V.scalatest,
+      "org.scalacheck"             %% "scalacheck"                % V.scalacheck,
+      "com.github.alexarchambault" %% "scalacheck-shapeless_1.14" % V.scalacheckShapeless
     )
   )
 

project/ProjectPlugin.scala

@@ -16,7 +16,11 @@ object ProjectPlugin extends AutoPlugin {
   object autoImport {
 
     lazy val V = new {
-      val scala212: String = "2.12.10"
+      val scala212: String            = "2.12.10"
+      val shapeless: String           = "2.3.3"
+      val scalatest: String           = "3.0.8"
+      val scalacheck: String          = "1.14.2"
+      val scalacheckShapeless: String = "1.2.3"
     }
   }
 

src/main/scala/stdlib/Extractors.scala

@@ -71,7 +71,7 @@ object Extractors extends FlatSpec with Matchers with org.scalaexercises.definit
     class Car(val make: String, val model: String, val year: Short, val topSpeed: Short)
 
     object ChopShop {
-      def unapply(x: Car) = Some(x.make, x.model, x.year, x.topSpeed)
+      def unapply(x: Car) = Some((x.make, x.model, x.year, x.topSpeed))
     }
 
     val ChopShop(a, b, c, d) = new Car("Chevy", "Camaro", 1978, 120)
@@ -88,7 +88,7 @@ object Extractors extends FlatSpec with Matchers with org.scalaexercises.definit
     class Car(val make: String, val model: String, val year: Short, val topSpeed: Short)
 
     object ChopShop {
-      def unapply(x: Car) = Some(x.make, x.model, x.year, x.topSpeed)
+      def unapply(x: Car) = Some((x.make, x.model, x.year, x.topSpeed))
     }
 
     val x = new Car("Chevy", "Camaro", 1978, 120) match {
@@ -106,7 +106,7 @@ object Extractors extends FlatSpec with Matchers with org.scalaexercises.definit
     class Car(val make: String, val model: String, val year: Short, val topSpeed: Short)
 
     object ChopShop {
-      def unapply(x: Car) = Some(x.make, x.model, x.year, x.topSpeed)
+      def unapply(x: Car) = Some((x.make, x.model, x.year, x.topSpeed))
     }
 
     val x = new Car("Chevy", "Camaro", 1978, 120) match {
@@ -125,9 +125,9 @@ object Extractors extends FlatSpec with Matchers with org.scalaexercises.definit
     class Employee(val firstName: String, val middleName: Option[String], val lastName: String)
 
     object Tokenizer {
-      def unapply(x: Car) = Some(x.make, x.model, x.year, x.topSpeed)
+      def unapply(x: Car) = Some((x.make, x.model, x.year, x.topSpeed))
 
-      def unapply(x: Employee) = Some(x.firstName, x.lastName)
+      def unapply(x: Employee) = Some((x.firstName, x.lastName))
     }
 
     val result = new Employee("Kurt", None, "Vonnegut") match {
@@ -142,7 +142,7 @@ object Extractors extends FlatSpec with Matchers with org.scalaexercises.definit
    */
   def anyObjectExtractors(res0: String) {
     class Car(val make: String, val model: String, val year: Short, val topSpeed: Short) {
-      def unapply(x: Car) = Some(x.make, x.model)
+      def unapply(x: Car) = Some((x.make, x.model))
     }
 
     val camaro = new Car("Chevy", "Camaro", 1978, 122)
@@ -168,7 +168,7 @@ object Extractors extends FlatSpec with Matchers with org.scalaexercises.definit
       //factory methods, extractors, apply
       //Extractor: Create tokens that represent your object
       def unapply(x: Employee) =
-        Some(x.lastName, x.middleName, x.firstName)
+        Some((x.lastName, x.middleName, x.firstName))
     }
 
     val singri = new Employee("Singri", None, "Keerthi")
@@ -193,7 +193,7 @@ object Extractors extends FlatSpec with Matchers with org.scalaexercises.definit
       //factory methods, extractors, apply
       //Extractor: Create tokens that represent your object
       def unapply(x: Employee) =
-        Some(x.lastName, x.middleName, x.firstName)
+        Some((x.lastName, x.middleName, x.firstName))
     }
 
     val singri = new Employee("Singri", None, "Keerthi")

src/main/scala/stdlib/Formatting.scala

@@ -33,18 +33,16 @@ object Formatting extends FlatSpec with Matchers with org.scalaexercises.definit
     "%c".format(b) should be(res1)
   }
 
-  /** Character Literals can be an escape sequence, including octal or hexidecimal:
+  /** Character Literals can be an escape sequence, including hexidecimal:
    */
-  def escapeSequenceFormatting(res0: String, res1: String, res2: String, res3: String) {
+  def escapeSequenceFormatting(res0: String, res1: String, res2: String) {
     val c = '\u0061' //unicode for a
-    val d = '\141' //octal for a
     val e = '\"'
     val f = '\\'
 
     "%c".format(c) should be(res0)
-    "%c".format(d) should be(res1)
-    "%c".format(e) should be(res2)
-    "%c".format(f) should be(res3)
+    "%c".format(e) should be(res1)
+    "%c".format(f) should be(res2)
   }
 
   /** Formatting can also include numbers:

src/main/scala/stdlib/LiteralStrings.scala

@@ -31,13 +31,6 @@ object LiteralStrings extends FlatSpec with Matchers with org.scalaexercises.def
     c.toString should be(res0)
   }
 
-  /** Character literals can use octal as well:
-   */
-  def characterLiteralsOctalLiteralStrings(res0: String) {
-    val d = '\141' //octal for a
-    d.toString should be(res0)
-  }
-
   /** Character literals can use escape sequences:
    */
   def escapeSequenceLiteralStrings(res0: String, res1: String) {

src/main/scala/stdlib/Traversables.scala

@@ -424,54 +424,38 @@ object Traversables extends FlatSpec with Matchers with org.scalaexercises.defin
     result should be(res0)
   }
 
-  /** `/:` or `foldLeft` will combine an operation starting with a seed and combining from the left.  `foldLeft` is defined as (seed /: list), where seed is the initial value.  Once the fold is established, you provide a function that takes two arguments.  The first argument is the running total of the operation, and the second element is the next element of the list.
+  /** `foldLeft` will combine an operation starting with a seed and combining from the left.  `foldLeft` takes as a first parameter the initial value of the fold.  Once the fold is established, you provide a function that takes two arguments.  The first argument is the running total of the operation, and the second element is the next element of the list.
    *
    * Given a `Traversable (x1, x2, x3, x4)`, an initial value of `init`, an operation `op`, `foldLeft` is defined as: `(((init op x1) op x2) op x3) op x4)`
    */
-  def foldLeftFunctionTraversables(res0: Int, res1: Int, res2: Int, res3: Int, res4: Int) {
+  def foldLeftFunctionTraversables(res0: Int, res1: Int, res2: Int) {
     val list = List(5, 4, 3, 2, 1)
-    val result = (0 /: list) { (`running total`, `next element`) ⇒
+    val result = list.foldLeft(0) { (`running total`, `next element`) ⇒
       `running total` - `next element`
     }
     result should be(res0)
 
-    val result2 = list.foldLeft(0) { (`running total`, `next element`) ⇒
-      `running total` - `next element`
-    }
+    val result2 = list.foldLeft(0)(_ - _) //Short hand
     result2 should be(res1)
 
-    val result3 = (0 /: list)(_ - _) //Short hand
-    result3 should be(res2)
-
-    val result4 = list.foldLeft(0)(_ - _)
-    result4 should be(res3)
-
-    (((((0 - 5) - 4) - 3) - 2) - 1) should be(res4)
+    (((((0 - 5) - 4) - 3) - 2) - 1) should be(res2)
   }
 
-  /** `:\` or `foldRight` will combine an operation starting with a seed and combining from the right.  Fold right is defined as (list :\ seed), where seed is the initial value.  Once the fold is established, you  provide a function that takes two elements.  The first is the next element of the list, and the second element is the running total of the operation.
+  /** `foldRight` will combine an operation starting with a seed and combining from the right.  `foldRight` takes as a first parameter the initial value of the fold.  Once the fold is established, you  provide a function that takes two elements.  The first is the next element of the list, and the second element is the running total of the operation.
    *
    * Given a `Traversable (x1, x2, x3, x4)`, an initial value of `init`, an operation `op`, `foldRight` is defined as: `x1 op (x2 op (x3 op (x4 op init)))`
    */
-  def foldRightFunctionTraversables(res0: Int, res1: Int, res2: Int, res3: Int, res4: Int) {
+  def foldRightFunctionTraversables(res0: Int, res1: Int, res2: Int) {
     val list = List(5, 4, 3, 2, 1)
-    val result = (list :\ 0) { (`next element`, `running total`) ⇒
+    val result = list.foldRight(0) { (`next element`, `running total`) ⇒
       `next element` - `running total`
     }
     result should be(res0)
 
-    val result2 = list.foldRight(0) { (`next element`, `running total`) ⇒
-      `next element` - `running total`
-    }
+    val result2 = list.foldRight(0)(_ - _) //Short hand
     result2 should be(res1)
 
-    val result3 = (list :\ 0)(_ - _) //Short hand
-    result3 should be(res2)
-
-    val result4 = list.foldRight(0)(_ - _)
-    result4 should be(res3)
-
-    (5 - (4 - (3 - (2 - (1 - 0))))) should be(res4)
+    (5 - (4 - (3 - (2 - (1 - 0))))) should be(res2)
   }
 
   /** `reduceLeft` is similar to `foldLeft`, except that the seed is the head value:

src/test/scala/stdlib/AssertsSpec.scala

@@ -6,13 +6,13 @@
 
 package stdlib
 
-import org.scalacheck.Shapeless._
+import org.scalacheck.ScalacheckShapeless._
 import org.scalaexercises.Test
-import org.scalatest.Spec
+import org.scalatest.refspec.RefSpec
 import org.scalatest.prop.Checkers
 import shapeless.HNil
 
-class AssertsSpec extends Spec with Checkers {
+class AssertsSpec extends RefSpec with Checkers {
   def `scalatest asserts` =
     check(Test.testSuccess(Asserts.scalaTestAsserts _, true :: HNil))
 

src/test/scala/stdlib/ByNameParameterSpec.scala

@@ -6,13 +6,13 @@
 
 package stdlib
 
-import org.scalacheck.Shapeless._
+import org.scalacheck.ScalacheckShapeless._
 import org.scalaexercises.Test
-import org.scalatest.Spec
+import org.scalatest.refspec.RefSpec
 import org.scalatest.prop.Checkers
 import shapeless.HNil
 
-class ByNameParameterSpec extends Spec with Checkers {
+class ByNameParameterSpec extends RefSpec with Checkers {
   def `takes unit by name parameter` = {
     val right: Either[Throwable, Int] = Right(29)
 

src/test/scala/stdlib/CaseClassesSpec.scala

@@ -6,13 +6,13 @@
 
 package stdlib
 
-import org.scalacheck.Shapeless._
+import org.scalacheck.ScalacheckShapeless._
 import org.scalaexercises.Test
-import org.scalatest.Spec
+import org.scalatest.refspec.RefSpec
 import org.scalatest.prop.Checkers
 import shapeless.HNil
 
-class CaseClassesSpec extends Spec with Checkers {
+class CaseClassesSpec extends RefSpec with Checkers {
   def `case classes comparisons` = {
     check(
       Test.testSuccess(

src/test/scala/stdlib/ClassesSpec.scala

@@ -6,13 +6,13 @@
 
 package stdlib
 
-import org.scalacheck.Shapeless._
+import org.scalacheck.ScalacheckShapeless._
 import org.scalaexercises.Test
-import org.scalatest.Spec
+import org.scalatest.refspec.RefSpec
 import org.scalatest.prop.Checkers
 import shapeless.HNil
 
-class ClassesSpec extends Spec with Checkers {
+class ClassesSpec extends RefSpec with Checkers {
   def `classes with val parameters` = {
     check(
       Test.testSuccess(