 }
 
 let length = "I should be the length of 28".length
-
 /*:
  ## Adding New Methods
  In similar fashion as adding new computed properties, you add new methods to an existing type by creating an extension and add the new methods. You are not able to override properties and methods.
- - example: ADD
+ - example: Extending the `Double` type.\
+ Below is an extension on a `Double`. Have have added three methods, all of which use the `self` keyword to reference the current instance.
  */
 extension Double {
 

 [Table of Contents](@first) | [Previous](@previous) | [Next](@next)
 - - -
 # Extensions
 * callout(Session Overview): Extensions provide the capability of adding new functionality to existing types. The existing types include types provided to you either by [The Swift Standard Library](https://developer.apple.com/library/ios/documentation/General/Reference/SwiftStandardLibraryReference/index.html) such as `Int` or `String`, types from a  third party framework, or custom types authored by you. In the [Inheritance](Inheritance) session we learned that Inheritance gives you the capability of reusing code that is generic across all subtypes and subtypes can override a superclass’s properties or methods. Extensions are similar in that they allow for sharing of code, but the key difference is that extensions cannot override existing properties or methods. The Swift Standard Library uses extensions extensively.
 */
import Foundation
/*:
 ## Creating
 Extensions are created with the `extension` keyword. The type that you are extending must exist and be visible for you to create the extension. With extensions, you can:
 - add new type & instance computed properties
 - new type & instance methods
 - new initializers
 - new subscripts
 - new nested types
 - protocol conformance
 - note: Extensions *cannot* add stored properties or property observers, **only computed** properties. Both stored & computed properties can be access within an extension.
 - example: Extending the `Int` type.
 This example creates an extension of the `Int` type. You are allowed to creates as many extension as you like on the same type.
 */
extension Int {


}
/*:
 ## Protocol Extensions
Protocol extensions are an impressive feature of the Swift programming language. With extensions applied to protocols, protocols can be extended to provide the implementation of what is defined in the protocol. Think of it as the default implementation of the protocol that the conforming type can leverage.
 - note: Remember, extensions cannot override functionality, only provide new functionality. Also, if the conforming type also provides the implementation, the implementation in the protocol extension *will not* be use.
 - example: Default implementation of a protocol.\
 Below we leverage protocol extensions by providing the default implementation of the `func run(speed: Float)` method on the `Runnable` protocol.
 */
protocol Runnable: Walkable {

