Merge pull request #40 from scala-exercises/new-minor-release

Bump new minor release

build.sbt

@@ -5,7 +5,7 @@ lazy val stdlib = (project in file("."))
   organization := "org.scala-exercises",
   name         := "exercises-stdlib",
   scalaVersion := "2.11.7",
-  version := "0.1.2",
+  version := "0.2.1-SNAPSHOT",
   resolvers ++= Seq(
     Resolver.sonatypeRepo("snapshots"),
     Resolver.sonatypeRepo("releases")

project/plugins.sbt

@@ -1,2 +1,6 @@
-addSbtPlugin("org.scala-exercises" % "sbt-exercise" % "0.1.1", "0.13", "2.10")
+resolvers ++= Seq(
+  Resolver.sonatypeRepo("snapshots")
+)
+
+addSbtPlugin("org.scala-exercises" % "sbt-exercise" % "0.2.1-SNAPSHOT", "0.13", "2.10")
 addSbtPlugin("com.jsuereth" % "sbt-pgp" % "1.0.0")

src/main/scala/stdlib/Asserts.scala

@@ -4,7 +4,7 @@ import org.scalatest._
 
 /** @param name asserts
   */
-object Asserts extends FlatSpec with Matchers with exercise.Section {
+object Asserts extends FlatSpec with Matchers with org.scalaexercises.definitions.Section {
 
   /** ScalaTest makes three assertions available by default in any style trait. You can use:
     *

src/main/scala/stdlib/ByNameParameter.scala

@@ -4,7 +4,7 @@ import org.scalatest._
 
 /** @param name byname_parameter
   */
-object ByNameParameter extends FlatSpec with Matchers with exercise.Section {
+object ByNameParameter extends FlatSpec with Matchers with org.scalaexercises.definitions.Section {
 
   /** `() => Int` is a Function type that takes a `Unit` type. `Unit` is known as `void` to a Java programmer. The function returns an `Int`. You can place this as a method parameter so that you can you use it as a block, but still it doesn't look quite right.
     */

src/main/scala/stdlib/CaseClasses.scala

@@ -4,7 +4,7 @@ import org.scalatest._
 
 /** @param name case_classes
   */
-object CaseClasses extends FlatSpec with Matchers with exercise.Section {
+object CaseClasses extends FlatSpec with Matchers with org.scalaexercises.definitions.Section {
 
   /** Scala supports the notion of ''case classes''. Case classes are regular classes which export their constructor parameters and which provide a recursive decomposition mechanism via pattern matching.
     *

src/main/scala/stdlib/Classes.scala

@@ -4,7 +4,7 @@ import org.scalatest._
 
 /** @param name classes
   */
-object Classes extends FlatSpec with Matchers with exercise.Section {
+object Classes extends FlatSpec with Matchers with org.scalaexercises.definitions.Section {
 
   /** Classes in Scala are static templates that can be instantiated into many objects at runtime.
     * Here is a class definition which defines a class Point:

src/main/scala/stdlib/EmptyValues.scala

@@ -5,7 +5,7 @@ import org.scalatest._
 /** @param name empty_values
   *
   */
-object EmptyValues extends FlatSpec with Matchers with exercise.Section {
+object EmptyValues extends FlatSpec with Matchers with org.scalaexercises.definitions.Section {
 
   /** ==null==
     *

src/main/scala/stdlib/Enumerations.scala

@@ -5,7 +5,7 @@ import org.scalatest._
 /** @param name enumerations
   *
   */
-object Enumerations extends FlatSpec with Matchers with exercise.Section {
+object Enumerations extends FlatSpec with Matchers with org.scalaexercises.definitions.Section {
 
   /** To create an enumeration, create an object that extends the abstract class `Enumeration`, and set a `val` variable to the method `Value`.  This is a trick to give values to each `val`.
     *

src/main/scala/stdlib/Extractors.scala

@@ -5,7 +5,7 @@ import org.scalatest._
 /** @param name extractors
   *
   */
-object Extractors extends FlatSpec with Matchers with exercise.Section {
+object Extractors extends FlatSpec with Matchers with org.scalaexercises.definitions.Section {
 
   /** In Scala, patterns can be defined independently of case classes. To this end, a method named `unapply` is defined to yield a so-called extractor.
     *

src/main/scala/stdlib/ForExpressions.scala

@@ -5,7 +5,7 @@ import org.scalatest._
 /** @param name for_expressions
   *
   */
-object ForExpressions extends FlatSpec with Matchers with exercise.Section {
+object ForExpressions extends FlatSpec with Matchers with org.scalaexercises.definitions.Section {
 
   /** For expressions can nest, with later generators varying more rapidly than earlier ones:
     */

src/main/scala/stdlib/Formatting.scala

@@ -5,7 +5,7 @@ import org.scalatest._
 /** @param name formatting
   *
   */
-object Formatting extends FlatSpec with Matchers with exercise.Section {
+object Formatting extends FlatSpec with Matchers with org.scalaexercises.definitions.Section {
 
   /** String can be placed in format:
     */

src/main/scala/stdlib/HigherOrderFunctions.scala

@@ -5,7 +5,7 @@ import org.scalatest._
 /** @param name higher_order_functions
   *
   */
-object HigherOrderFunctions extends FlatSpec with Matchers with exercise.Section {
+object HigherOrderFunctions extends FlatSpec with Matchers with org.scalaexercises.definitions.Section {
 
   /** Meet lambda. Scala provides a relatively lightweight syntax for defining anonymous functions. Anonymous functions in source code are called function literals and at run time, function literals are instantiated into objects called function values.
     *

src/main/scala/stdlib/Implicits.scala

@@ -6,7 +6,7 @@ import scala.language.implicitConversions
 /** @param name implicits
   *
   */
-object Implicits extends FlatSpec with Matchers with exercise.Section {
+object Implicits extends FlatSpec with Matchers with org.scalaexercises.definitions.Section {
 
   /** The actual arguments that are eligible to be passed to an implicit parameter fall into two categories: * First, eligible are all identifiers x that can be accessed at the point of the method call without a prefix and that denote an implicit definition or an implicit parameter. * Second, eligible are also all members of companion modules of the implicit parameter's type that are labeled implicit.
     *

src/main/scala/stdlib/InfixPrefixandPostfixOperators.scala

@@ -6,7 +6,7 @@ import scala.language.postfixOps
 /** @param name infix_prefix_and_postfix_operators
   *
   */
-object InfixPrefixandPostfixOperators extends FlatSpec with Matchers with exercise.Section {
+object InfixPrefixandPostfixOperators extends FlatSpec with Matchers with org.scalaexercises.definitions.Section {
 
   /** Any method which takes a single parameter can be used as an infix operator: `a.m(b)` can be written `a m b`.
     */

src/main/scala/stdlib/InfixTypes.scala

@@ -5,7 +5,7 @@ import org.scalatest._
 /** @param name infix_types
   *
   */
-object InfixTypes extends FlatSpec with Matchers with exercise.Section {
+object InfixTypes extends FlatSpec with Matchers with org.scalaexercises.definitions.Section {
 
   /** An infix type `T1 op T2` consists of an infix operator `op` which gets applied to two
     * type operands `T1` and `T2`. The type is equivalent to the type application `op[T1,T2]`.

src/main/scala/stdlib/Iterables.scala

@@ -5,7 +5,7 @@ import org.scalatest._
 /** @param name iterables
   *
   */
-object Iterables extends FlatSpec with Matchers with exercise.Section {
+object Iterables extends FlatSpec with Matchers with org.scalaexercises.definitions.Section {
 
   /** The next trait from the top in the collections hierarchy is `Iterable`. All methods in this trait are defined in terms of an abstract method, `iterator`, which yields the collection's elements one by one. The `foreach` method from trait `Traversable` is implemented in `Iterable` in terms of `iterator`. Here is the actual implementation:
     *

src/main/scala/stdlib/Lists.scala

@@ -5,7 +5,7 @@ import org.scalatest._
 /** @param name lists
   *
   */
-object Lists extends FlatSpec with Matchers with exercise.Section {
+object Lists extends FlatSpec with Matchers with org.scalaexercises.definitions.Section {
 
   /** Scala Lists are quite similar to arrays which means, all the elements of a list have the same type but there are two important differences. First, lists are immutable, which means elements of a list cannot be changed by assignment. Second, lists represent a linked list whereas arrays are flat. The type of a list that has elements of type `T` is written as `List[T]`.
     *

src/main/scala/stdlib/LiteralBooleans.scala

@@ -5,7 +5,7 @@ import org.scalatest._
 /** @param name literal_booleans
   *
   */
-object LiteralBooleans extends FlatSpec with Matchers with exercise.Section {
+object LiteralBooleans extends FlatSpec with Matchers with org.scalaexercises.definitions.Section {
 
   /** Boolean literals are either true or false, using the true or false keyword
     */

src/main/scala/stdlib/LiteralNumbers.scala

@@ -5,7 +5,7 @@ import org.scalatest._
 /** @param name literal_numbers
   *
   */
-object LiteralNumbers extends FlatSpec with Matchers with exercise.Section {
+object LiteralNumbers extends FlatSpec with Matchers with org.scalaexercises.definitions.Section {
 
   /** Integer Literals are 32-bit and can be created from decimal, hexadecimal:
     */

src/main/scala/stdlib/LiteralStrings.scala

@@ -5,7 +5,7 @@ import org.scalatest._
 /** @param name literal_strings
   *
   */
-object LiteralStrings extends FlatSpec with Matchers with exercise.Section {
+object LiteralStrings extends FlatSpec with Matchers with org.scalaexercises.definitions.Section {
 
   /** Character Literals are quoted with single quotes:
     */

src/main/scala/stdlib/Maps.scala

@@ -5,7 +5,7 @@ import org.scalatest._
 /** @param name maps
   *
   */
-object Maps extends FlatSpec with Matchers with exercise.Section {
+object Maps extends FlatSpec with Matchers with org.scalaexercises.definitions.Section {
 
   /** A `Map` is an `Iterable` consisting of pairs of keys and values (also named mappings or associations). Scala's Predef class offers an implicit conversion that lets you write `key -> value` as an alternate syntax for the pair `(key, value)`. For instance `Map("x" -> 24, "y" -> 25, "z" -> 26)` means exactly the same as `Map(("x", 24), ("y", 25), ("z", 26))`, but reads better.
     *

src/main/scala/stdlib/NamedandDefaultArguments.scala

@@ -6,7 +6,7 @@ import org.scalatest._
 /** @param name named_and_default_arguments
   *
   */
-object NamedandDefaultArguments extends FlatSpec with Matchers with exercise.Section {
+object NamedandDefaultArguments extends FlatSpec with Matchers with org.scalaexercises.definitions.Section {
 
   /** When calling methods and functions, you can use the name of the variables explicitly in the call, like so:
     *

src/main/scala/stdlib/Objects.scala

@@ -5,7 +5,7 @@ import org.scalatest._
 /** @param name objects
   *
   */
-object Objects extends FlatSpec with Matchers with exercise.Section {
+object Objects extends FlatSpec with Matchers with org.scalaexercises.definitions.Section {
 
   /** An object is a singleton. One object, that's it. This object is a replacement of static in Java, and is called upon much in the same way.
     */

src/main/scala/stdlib/Options.scala

@@ -6,7 +6,7 @@ import org.scalatest._
 /** @param name options
   *
   */
-object Options extends FlatSpec with Matchers with exercise.Section {
+object Options extends FlatSpec with Matchers with org.scalaexercises.definitions.Section {
 
   /** If you have worked with Java at all in the past, it is very likely that you have come across a `NullPointerException` at some time (other languages will throw similarly named errors in such a case). Usually this happens because some method returns null when you were not expecting it and thus not dealing with that possibility in your client code. A value of `null` is often abused to represent an absent optional value.
     *

src/main/scala/stdlib/ParentClasses.scala

@@ -5,7 +5,7 @@ import org.scalatest._
 /** @param name parent_classes
   *
   */
-object ParentClasses extends FlatSpec with Matchers with exercise.Section {
+object ParentClasses extends FlatSpec with Matchers with org.scalaexercises.definitions.Section {
 
   /** In contrast to Java, all values in Scala are objects (including numerical values and functions). Since Scala is class-based, all values are instances of a class.
     *

src/main/scala/stdlib/PartialFunctions.scala

@@ -5,7 +5,7 @@ import org.scalatest._
 /** @param name partial_functions
   *
   */
-object PartialFunctions extends FlatSpec with Matchers with exercise.Section {
+object PartialFunctions extends FlatSpec with Matchers with org.scalaexercises.definitions.Section {
 
   /** A partial function is a `trait` that when implemented can be used as building blocks to determine a solution.  The trait `PartialFunction` requires that the method `isDefinedAt` and `apply` be implemented.
     */

src/main/scala/stdlib/PartiallyAppliedFunctions.scala

@@ -5,7 +5,7 @@ import org.scalatest._
 /** @param name partially_applied_functions
   *
   */
-object PartiallyAppliedFunctions extends FlatSpec with Matchers with exercise.Section {
+object PartiallyAppliedFunctions extends FlatSpec with Matchers with org.scalaexercises.definitions.Section {
 
   /** A partially applied function is a function that you do not apply any or all the arguments, creating another function. This partially applied function doesn't apply any arguments.
     */

src/main/scala/stdlib/PatternMatching.scala

@@ -5,7 +5,7 @@ import org.scalatest._
 /** @param name pattern_matching
   *
   */
-object PatternMatching extends FlatSpec with Matchers with exercise.Section {
+object PatternMatching extends FlatSpec with Matchers with org.scalaexercises.definitions.Section {
 
   /** Scala has a built-in general pattern matching mechanism. It allows to match on any sort of data with a first-match policy.
     * Here is a small example which shows how to match against an integer value:

src/main/scala/stdlib/Ranges.scala

@@ -5,7 +5,7 @@ import org.scalatest._
 /** @param name ranges
   *
   */
-object Ranges extends FlatSpec with Matchers with exercise.Section {
+object Ranges extends FlatSpec with Matchers with org.scalaexercises.definitions.Section {
 
   /** A range's upper bound is not inclusive:
     */

src/main/scala/stdlib/RepeatedParameters.scala

@@ -6,7 +6,7 @@ import org.scalatest._
 /** @param name repeated_parameters
   *
   */
-object RepeatedParameters extends FlatSpec with Matchers with exercise.Section {
+object RepeatedParameters extends FlatSpec with Matchers with org.scalaexercises.definitions.Section {
 
   /** A repeated parameter must be the last parameter and this will let you add as many extra parameters as needed.
     *

src/main/scala/stdlib/SequencesandArrays.scala

@@ -5,7 +5,7 @@ import org.scalatest._
 /** @param name sequences_and_arrays
   *
   */
-object SequencesandArrays extends FlatSpec with Matchers with exercise.Section {
+object SequencesandArrays extends FlatSpec with Matchers with org.scalaexercises.definitions.Section {
 
   /** Scala provides a data structure, the array, which stores a fixed-size sequential collection of elements of the same type. An array is used to store a collection of data, but it is often more useful to think of an array as a collection of variables of the same type.
     *

src/main/scala/stdlib/Sets.scala

@@ -5,7 +5,7 @@ import org.scalatest._
 /** @param name sets
   *
   */
-object Sets extends FlatSpec with Matchers with exercise.Section {
+object Sets extends FlatSpec with Matchers with org.scalaexercises.definitions.Section {
 
   /** `Set`s are `Iterable`s that contain no duplicate elements. The operations on sets are summarized in the following table for general sets and in the table after that for mutable sets. They fall into the following categories:
     *

src/main/scala/stdlib/StdLib.scala

@@ -9,7 +9,7 @@ package stdlib
   *
   * @param name std_lib
   */
-object StdLib extends exercise.Library {
+object StdLib extends org.scalaexercises.definitions.Library {
   override def owner = "scala-exercises"
   override def repository = "exercises-stdlib"
 

src/main/scala/stdlib/Traits.scala

@@ -4,7 +4,7 @@ import org.scalatest._
 
 /** @param name traits
   */
-object Traits extends FlatSpec with Matchers with exercise.Section {
+object Traits extends FlatSpec with Matchers with org.scalaexercises.definitions.Section {
 
   /** Similar to *interfaces* in Java, traits are used to define object types by specifying the signature of the supported methods. Unlike Java, Scala allows traits to be partially implemented; i.e. it is possible to define default implementations for some methods. In contrast to classes, traits may not have constructor parameters.
     *

src/main/scala/stdlib/Traversables.scala

@@ -7,7 +7,7 @@ import Stream.cons
 
 /** @param name traversables
   */
-object Traversables extends FlatSpec with Matchers with exercise.Section {
+object Traversables extends FlatSpec with Matchers with org.scalaexercises.definitions.Section {
 
   /** At the top of the collection hierarchy is trait *Traversable*. Its only abstract operation is `foreach`:
     *

src/main/scala/stdlib/Tuples.scala

@@ -7,7 +7,7 @@ import org.scalatest._
 /** @param name tuples
   *
   */
-object Tuples extends FlatSpec with Matchers with exercise.Section {
+object Tuples extends FlatSpec with Matchers with org.scalaexercises.definitions.Section {
 
   /** Scala tuple combines a fixed number of items together so that they can be passed around as a whole. They are one indexed. Unlike an array or list, a tuple can hold objects with different types but they are also immutable. Here is an example of a tuple holding an integer, a string, and the console:
     *

src/main/scala/stdlib/TypeSignatures.scala

@@ -4,7 +4,7 @@ import org.scalatest._
 
 /** @param name type_signatures
   */
-object TypeSignatures extends FlatSpec with Matchers with exercise.Section {
+object TypeSignatures extends FlatSpec with Matchers with org.scalaexercises.definitions.Section {
 
   /** A method's *type signature* comprises its name, the number, order, and types of its parameters, if any, and its result type. The type signature of a class, trait, or singleton object comprises its name, the type signatures of all of its members and constructors, and its declared inheritance and mixin relations.
     *

src/main/scala/stdlib/TypeVariance.scala

@@ -5,7 +5,7 @@ import org.scalatest._
 
 /** @param name type_variance
   */
-object TypeVariance extends FlatSpec with Matchers with exercise.Section {
+object TypeVariance extends FlatSpec with Matchers with org.scalaexercises.definitions.Section {
 
   /** A traditional objection to static typing is that it has much syntactic overhead. Scala alleviates this by providing *type inference*.
     *

src/main/scala/stdlib/UniformAccessPrinciple.scala

@@ -5,7 +5,7 @@ import org.scalatest._
 /** @param name uniform_access_principle
   *
   */
-object UniformAccessPrinciple extends FlatSpec with Matchers with exercise.Section {
+object UniformAccessPrinciple extends FlatSpec with Matchers with org.scalaexercises.definitions.Section {
 
   /** The Scala language implements a programming concept known as the [Uniform Access Principle](http://en.wikipedia.org/wiki/Uniform_access_principle) which was first put forth by Bertrand Meyer, inventor of the Eiffel programming language.
     *