Rewrote extractors section of tour

Author: travissarles

tutorials/tour/_posts/2017-02-13-extractor-objects.md

@@ -11,25 +11,25 @@ next-page: sequence-comprehensions
 previous-page: regular-expression-patterns
 ---
 
-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. An extractor can be thought of as a special method that reverses the effect of applying a particular object on some inputs. Its purpose is to 'extract' the inputs that were present before the 'apply' operation. For instance, the following code defines an extractor [object](singleton-objects.html) Twice.
-
-```tut
-object Twice {
-  def apply(x: Int): Int = x * 2
-  def unapply(z: Int): Option[Int] = if (z%2 == 0) Some(z/2) else None
-}
-
-object TwiceTest extends App {
-  val x = Twice(21)
-  x match { case Twice(n) => Console.println(n) } // prints 21
-}
+An extractor object is an object with an `unapply` method. Whereas the a `apply` method is like a constructor which takes arguments and creates an object, the `unapply` takes an object and tries to give back the arguments.
 ```
+import scala.util.Random
 
-There are two syntactic conventions at work here:
+object CustomerID{
 
-The pattern `case Twice(n)` will cause an invocation of `Twice.unapply`, which is used to match any even number; the return value of the `unapply` signals whether the argument has matched or not, and any sub-values that can be used for further matching. Here, the sub-value is `z/2`
+  def apply(name: String) = s"$name--${Random.nextLong}"
 
-The `apply` method is not necessary for pattern matching.  It is only used to mimick a constructor. `val x = Twice(21)` expands to `val x = Twice.apply(21)`.
+  def unapply(customerID: String): Option[String] = {
+    val name = customerID.split("--")(0)
+    if (!name.isEmpty) Some(name) else None
+  }
+}
+
+val customer1ID = CustomerID("Sukyoung")  // Sukyoung-23098234908
+val CustomerID(name) = customer1ID
+println(name)  //  Sukyoung
+```
+The `apply` method creates a `CustomerID` string from a `name`. The `unapply` does the inverse to get the `name` back. Although `CustomerID` doesn't take any parameters, when we call `CustomerID("Sukyoung")`, this is shorthand syntax for calling `CustomerID.apply("Sukyoung")`. When we call `val CustomerID(name) = customer1ID`, this is shorthand for `val name = CustomerID.unapply(name)`.
 
 The return type of an `unapply` should be chosen as follows:
 
@@ -38,5 +38,3 @@ The return type of an `unapply` should be chosen as follows:
 * If you want to return several sub-values `T1,...,Tn`, group them in an optional tuple `Option[(T1,...,Tn)]`.
 
 Sometimes, the number of sub-values is fixed and we would like to return a sequence. For this reason, you can also define patterns through `unapplySeq`. The last sub-value type `Tn` has to be `Seq[S]`. This mechanism is used for instance in pattern `case List(x1, ..., xn)`.
-
-Extractors can make code more maintainable. For details, read the paper ["Matching Objects with Patterns"](https://infoscience.epfl.ch/record/98468/files/MatchingObjectsWithPatterns-TR.pdf) (see section 4) by Emir, Odersky and Williams (January 2007).