Rewrote compound types tour

Author: travissarles

tutorials/tour/_posts/2017-02-13-compound-types.md

@@ -9,15 +9,16 @@ categories: tour
 num: 24
 next-page: explicitly-typed-self-references
 previous-page: abstract-types
+prerequisite-knowledge: traits, unified-types, mixin-class-composition
 ---
 
-Sometimes it is necessary to express that the type of an object is a subtype of several other types. In Scala this can be expressed with the help of *compound types*, which are intersections of object types.
+Sometimes it is necessary to have parameter has multiple supertypes. In Scala this can be expressed with the help of _compound types_, which are intersections of object types.
 
 Suppose we have two traits `Cloneable` and `Resetable`:
 
 ```tut
 trait Cloneable extends java.lang.Cloneable {
-  override def clone(): Cloneable = { 
+  override def clone(): Cloneable = {
     super.clone().asInstanceOf[Cloneable]
   }
 }
@@ -26,27 +27,15 @@ trait Resetable {
 }
 ```
 
-Now suppose we want to write a function `cloneAndReset` which takes an object, clones it and resets the original object:
+Now suppose we want to write a function `cloneAndReset` which takes an object, clones it and resets the original object. We use the keyword `with` to specify that the object must be a subtype of both types.
 
 ```
-def cloneAndReset(obj: ?): Cloneable = {
+def cloneAndReset(obj: Cloneable with Resetable): Cloneable = {
   val cloned = obj.clone()
   obj.reset
   cloned
 }
 ```
+Because the type of `obj` is `Cloneable with Resetable`, we know the object has both a `clone` and a `reset` method.
 
-The question arises what the type of the parameter `obj` is. If it's `Cloneable` then the object can be `clone`d, but not `reset`; if it's `Resetable` we can `reset` it, but there is no `clone` operation. To avoid type casts in such a situation, we can specify the type of `obj` to be both `Cloneable` and `Resetable`. This compound type is written like this in Scala: `Cloneable with Resetable`.
-
-Here's the updated function:
-
-```
-def cloneAndReset(obj: Cloneable with Resetable): Cloneable = {
-  //...
-}
-```
-
-Compound types can consist of several object types and they may have a single refinement which can be used to narrow the signature of existing object members.
-The general form is: `A with B with C ... { refinement }`
-
-An example for the use of refinements is given on the page about [abstract types](abstract-types.html). 
+Compound types can consist of several object types. The general form is: `A with B with C ...`.