         self.completion = completion
     }
 
+    /**
+    When the operation executes, on the main queue, it calls `displayController` on the
+    ViewControllerDisplayStyle, which in turn will execute either `presentViewController`, 
+    `showViewController`, or `showDetailViewController`.
+    */
     public override func execute() {
         dispatch_async(Queue.Main.queue) {
             self.from.displayController(self.controller, sender: self.sender, completion: self.completion)


// MARK: - UI

public protocol PresentingViewController: class {
    func presentViewController(viewController: UIViewController, animated: Bool, completion: (() -> Void)?)

    @available(iOS 8.0, *)
    func showViewController(vc: UIViewController, sender: AnyObject?)

    @available(iOS 8.0, *)
    func showDetailViewController(vc: UIViewController, sender: AnyObject?)
}

extension UIViewController: PresentingViewController { }

public enum ViewControllerDisplayStyle<ViewController: PresentingViewController> {

    case Show(ViewController)
    case ShowDetail(ViewController)
    case Present(ViewController)

    public var controller: ViewController {
        switch self {
        case .Show(let controller):

    }
}

/**
`UIOperation` is an `Operation` subclass which is responsible for presenting one view controller
from another view controller. The operation is generic over both of these types. It uses
standard `UIViewController` presentation APIs. These APIs have been condensed into the 
`PresentingViewController` protocol, meaning that the *presenting* generic type is just something
conforming to this protocol. This is for testing purposes, don't let it confuse you, the From 
generic type is your view controller.

However, note that the presenting view controller is associated into a `ViewControllerDisplayStyle`.
This enum lets you define how the view controller should be presented. Either, "show", "show detail" or
"present".
*/
public class UIOperation<C, From where C: UIViewController, From: PresentingViewController>: Operation {

    /// The controller which will be presented.
    public let controller: C

    /// The presenting `ViewControllerDisplayStyle`
    public let from: ViewControllerDisplayStyle<From>

    /// The `AnyObject` sender.
    public let sender: AnyObject?
    let completion: (() -> Void)?

    /**
    Construct a `UIOperation` with the presented view controller, the presenting view controller display 
    style, and optional sender and completion blocks. For example...
    
        let ui = UIOperation(
            controller: detailViewController, 
            displayControllerFrom: .ShowDetail(myViewController)
        )
    
    - parameter controller: the generic `UIViewController` subclass.
    - parameter displayControllerFrom: a ViewControllerDisplayStyle<From> value.
    - parameter sender: an optional `AnyObject` see docs for UIViewController.
    - parameter completion: an optional void block, see docs for UIViewController.
    */
    public init(controller: C, displayControllerFrom from: ViewControllerDisplayStyle<From>, sender: AnyObject? = .None, completion: (() -> Void)? = .None) {
        self.controller = controller
        self.from = from
