 
 public class LocationTracker: NSObject, CLLocationManagerDelegate {
     
+    private var lastResult: LocationResult = .Failure(.NoData)
+    private var observers: [Observer] = []
+    
     var currentLocation: LocationResult {
-        if let result = lastResult {
-            return result
-        }
-        else {
-            return Result.Failure(Reason.NoData)
-        }
+        return self.lastResult
     }
     
     override init() {

    }
    
    private func shouldUpdateWithLocation(location: CLLocation) -> Bool {
        if let result = lastResult {
            switch result {
            case .Success(let box):
                return location.distanceFromLocation(box.unbox.physical) > 100
            case .Failure:
                return true
            }
        }
        
        return true
    }
    
    private func shouldUpdateWithResult(result: LocationResult) -> Bool {
        var shouldUpdate = false
        if let lastResult = self.lastResult {
            switch lastResult {
            case .Success(let box):
                let location = box.unbox.physical
                shouldUpdate = self.shouldUpdateWithLocation(location)
            case .Failure(let reason):
                // TODO: implement
                shouldUpdate = true
            }
        } else {
            shouldUpdate = true
        }
        
        return shouldUpdate
    }
}


    
    // MARK: - Private
    
    private lazy var locationManager: CLLocationManager = {
        let locationManager = CLLocationManager()
        locationManager.delegate = self
