0001    // Result.swift
0002    //
0003    // Copyright (c) 2015 Jens Ravens (http://jensravens.de)
0004    //
0005    // Permission is hereby granted, free of charge, to any person obtaining a copy
0006    // of this software and associated documentation files (the "Software"), to deal
0007    // in the Software without restriction, including without limitation the rights
0008    // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
0009    // copies of the Software, and to permit persons to whom the Software is
0010    // furnished to do so, subject to the following conditions:
0011    //
0012    // The above copyright notice and this permission notice shall be included in
0013    // all copies or substantial portions of the Software.
0014    //
0015    // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
0016    // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
0017    // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
0018    // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
0019    // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
0020    // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
0021    // THE SOFTWARE.
0022    
0023    
0024    /**
0025        A result contains the result of a computation or task. It might be either successfull
0026        with an attached value or a failure with an attached error (which conforms to Swift 2's
0027        ErrorType). You can read more about the implementation in
0028        [this blog post](http://jensravens.de/a-swifter-way-of-handling-errors/).
0029    */
0030    public enum Result
Debounce.swift:52
            func updateIfNeeded(signal: Signal<T>) -> Result<T> -> Void {
Result.swift:38
        self = Success(value)
Result.swift:45
        self = Error(error)
Result.swift:52
    public func map<U>(@noescape f: T -> U) -> Result<U> {
Result.swift:63
    public func map<U>(f:(T, (U->Void))->Void) -> (Result<U>->Void)->Void {
Result.swift:78
    public func flatMap<U>(@noescape f: T -> Result<U>) -> Result<U> {
Result.swift:78
    public func flatMap<U>(@noescape f: T -> Result<U>) -> Result<U> {
Result.swift:89
    public func flatMap<U>(@noescape f: T throws -> U) -> Result<U> {
Result.swift:102
    public func flatMap<U>(f:(T, (Result<U>->Void))->Void) -> (Result<U>->Void)->Void {
Result.swift:102
    public func flatMap<U>(f:(T, (Result<U>->Void))->Void) -> (Result<U>->Void)->Void {
Result.swift:115
    public func ensure<U>(@noescape f: Result<T> -> Result<U>) -> Result<U> {
Result.swift:115
    public func ensure<U>(@noescape f: Result<T> -> Result<U>) -> Result<U> {
Result.swift:115
    public func ensure<U>(@noescape f: Result<T> -> Result<U>) -> Result<U> {
Result.swift:123
    public func ensure<U>(f:(Result<T>, (Result<U>->Void))->Void) -> (Result<U>->Void)->Void {
Result.swift:123
    public func ensure<U>(f:(Result<T>, (Result<U>->Void))->Void) -> (Result<U>->Void)->Void {
Result.swift:123
    public func ensure<U>(f:(Result<T>, (Result<U>->Void))->Void) -> (Result<U>->Void)->Void {
Result.swift:166
public func ?? <T> (result: Result<T>, @autoclosure defaultValue: () -> T) -> T {
Signal.swift:49
    private var value: Result<T>?
Signal.swift:50
    private var callbacks: [Result<T> -> Void] = []
Signal.swift:77
    public func flatMap<U>(f: T -> Result<U>) -> Signal<U> {
Signal.swift:99
    public func flatMap<U>(f: (T, (Result<U>->Void))->Void) -> Signal<U> {
Signal.swift:133
    public func ensure<U>(f: (Result<T>, (Result<U>->Void))->Void) -> Signal<U> {
Signal.swift:133
    public func ensure<U>(f: (Result<T>, (Result<U>->Void))->Void) -> Signal<U> {
Signal.swift:145
    public func subscribe(f: Result<T> -> Void) -> Signal<T> {
Signal.swift:230
    public func update(result: Result<T>) {
Threading.swift:34
    public static func main<T>(a: Result<T>, completion: Result<T>->Void) {
Threading.swift:34
    public static func main<T>(a: Result<T>, completion: Result<T>->Void) {
Threading.swift:42
    public static func queue<T>(queue: dispatch_queue_t) -> (Result<T>, Result<T>->Void) -> Void {
Threading.swift:42
    public static func queue<T>(queue: dispatch_queue_t) -> (Result<T>, Result<T>->Void) -> Void {
Threading.swift:54
    public static func background<T>(a: Result<T>, completion: Result<T>->Void) {
Threading.swift:54
    public static func background<T>(a: Result<T>, completion: Result<T>->Void) {
Waiting.swift:50
        var result: Result<T>?
<T
Result.swift:31
    case Success(T)
Result.swift:37
    public init(success value: T) {
Result.swift:52
    public func map<U>(@noescape f: T -> U) -> Result<U> {
Result.swift:63
    public func map<U>(f:(T, (U->Void))->Void) -> (Result<U>->Void)->Void {
Result.swift:78
    public func flatMap<U>(@noescape f: T -> Result<U>) -> Result<U> {
Result.swift:89
    public func flatMap<U>(@noescape f: T throws -> U) -> Result<U> {
Result.swift:102
    public func flatMap<U>(f:(T, (Result<U>->Void))->Void) -> (Result<U>->Void)->Void {
Result.swift:115
    public func ensure<U>(@noescape f: Result<T> -> Result<U>) -> Result<U> {
Result.swift:123
    public func ensure<U>(f:(Result<T>, (Result<U>->Void))->Void) -> (Result<U>->Void)->Void {
Result.swift:133
    public var value: T? {
Result.swift:154
    public func get() throws -> T {
> {
0031        case Success
Result.swift:38
        self = Success(value)
Result.swift:54
        case let .Success(v): return .Success(f(v))
Result.swift:54
        case let .Success(v): return .Success(f(v))
Result.swift:66
            case let .Success(v): f(v){ transformed in
Result.swift:67
                    g(.Success(transformed))
Result.swift:80
        case let .Success(v): return f(v)
Result.swift:92
                return .Success(try f(t))
Result.swift:105
            case let .Success(v): f(v, g)
Result.swift:135
        case let .Success(v): return v
Result.swift:146
        case Success: return nil
Result.swift:156
        case let Success(value): return value
Result.swift:168
    case .Success(let x): return x
Signal.swift:56
        self.value = .Success(value)
Signal.swift:115
            case let .Success(value):
Signal.swift:159
            case let .Success(value):
Signal.swift:176
            case let .Success(value): g(value)
Signal.swift:190
            case .Success(_): return
Signal.swift:210
                signal.update(.Success((a,b)))
Signal.swift:215
                signal.update(.Success((a,b)))
Signal.swift:242
        update(.Success(value))
Waiting.swift:61
        case let .Success(t): return t
(T)
0032        case Error
Result.swift:45
        self = Error(error)
Result.swift:55
        case let .Error(error): return .Error(error)
Result.swift:55
        case let .Error(error): return .Error(error)
Result.swift:69
            case let .Error(error): g(.Error(error))
Result.swift:69
            case let .Error(error): g(.Error(error))
Result.swift:81
        case let .Error(error): return .Error(error)
Result.swift:81
        case let .Error(error): return .Error(error)
Result.swift:94
                return .Error(error)
Result.swift:106
            case let .Error(error): g(.Error(error))
Result.swift:106
            case let .Error(error): g(.Error(error))
Result.swift:136
        case .Error(_): return nil
Result.swift:147
        case Error(let x): return x
Result.swift:157
        case Error(let error): throw error
Result.swift:169
    case .Error: return defaultValue()
Signal.swift:120
            case let .Error(error):
Signal.swift:121
                signal.update(.Error(error))
Signal.swift:163
            case let .Error(error): signal.update(.Error(error))
Signal.swift:163
            case let .Error(error): signal.update(.Error(error))
Signal.swift:177
            case .Error(_): return
Signal.swift:191
            case let .Error(error): g(error)
Signal.swift:219
            signal.update(.Error(error))
Signal.swift:250
        update(.Error(error))
Waiting.swift:62
        case let .Error(e): throw e
(ErrorType)
0033        
0034        /**
0035            Initialize a result containing a successful value.
0036        */
0037        public init(success value: T) {
0038            self = Success(value)
0039        }
0040        
0041        /**
0042            Initialize a result containing an error
0043        */
0044        public init(error: ErrorType) {
0045            self = Error(error)
0046        }
0047        
0048        /**
0049            Transform a result into another result using a function. If the result was an error,
0050            the function will not be executed and the error returned instead.
0051        */
0052        public func map
Signal.swift:69
            signal.update(result.map(f))
<U>(@noescape f: T -> U) -> Result<U> {
0053            switch self {
0054            case let .Success(v): return .Success(f(v))
0055            case let .Error(error): return .Error(error)
0056            }
0057        }
0058        
0059        /**
0060            Transform a result into another result using a function. If the result was an error,
0061            the function will not be executed and the error returned instead.
0062        */
0063        public func map<U>(f:(T, (U->Void))->Void) -> (Result<U>->Void)->Void {
0064            return { g in
0065                switch self {
0066                case let .Success(v): f(v){ transformed in
0067                        g(.Success(transformed))
0068                    }
0069                case let .Error(error): g(.Error(error))
0070                }
0071            }
0072        }
0073        
0074        /**
0075            Transform a result into another result using a function. If the result was an error,
0076            the function will not be executed and the error returned instead.
0077        */
0078        public func flatMap
Result.swift:90
        return flatMap { t in
Signal.swift:80
            signal.update(result.flatMap(f))
<U>(@noescape f: T -> Result<U>) -> Result<U> {
0079            switch self {
0080            case let .Success(v): return f(v)
0081            case let .Error(error): return .Error(error)
0082            }
0083        }
0084        
0085        /**
0086        Transform a result into another result using a function. If the result was an error,
0087        the function will not be executed and the error returned instead.
0088        */
0089        public func flatMap
Signal.swift:91
            signal.update(result.flatMap(f))
<U>(@noescape f: T throws -> U) -> Result<U> {
0090            return flatMap { t in
0091                do {
0092                    return .Success(try f(t))
0093                } catch let error {
0094                    return .Error(error)
0095                }
0096            }
0097        }
0098        /**
0099            Transform a result into another result using a function. If the result was an error,
0100            the function will not be executed and the error returned instead.
0101        */
0102        public func flatMap
Signal.swift:102
            result.flatMap(f)(signal.update)
<U>(f:(T, (Result<U>->Void))->Void) -> (Result<U>->Void)->Void {
0103            return { g in
0104                switch self {
0105                case let .Success(v): f(v, g)
0106                case let .Error(error): g(.Error(error))
0107                }
0108            }
0109        }
0110        
0111        /** 
0112            Call a function with the result as an argument. Use this if the function should be
0113            executed no matter if the result was a success or not.
0114        */
0115        public func ensure<U>(@noescape f: Result<T> -> Result<U>) -> Result<U> {
0116            return f(self)
0117        }
0118        
0119        /**
0120            Call a function with the result as an argument. Use this if the function should be
0121            executed no matter if the result was a success or not.
0122        */
0123        public func ensure<U>(f:(Result<T>, (Result<U>->Void))->Void) -> (Result<U>->Void)->Void {
0124            return { g in
0125                f(self, g)
0126            }
0127        }
0128        
0129        /**
0130            Direct access to the content of the result as an optional. If the result was a success,
0131            the optional will contain the value of the result.
0132        */
0133        public var value
Signal.swift:258
        return value?.value
: T? {
0134            switch self {
0135            case let .Success(v): return v
0136            case .Error(_): return nil
0137            }
0138        }
0139        
0140        /**
0141            Direct access to the error of the result as an optional. If the result was an error,
0142            the optional will contain the error of the result.
0143        */
0144        public var error: ErrorType? {
0145            switch self {
0146            case Success: return nil
0147            case Error(let x): return x
0148            }
0149        }
0150        
0151        /**
0152            Access the value of this result. If the result contains an error, that error is thrown.
0153        */
0154        public func get() throws -> T {
0155            switch self {
0156            case let Success(value): return value
0157            case Error(let error): throw error
0158            }
0159        }
0160    }
0161    
0162    
0163    /**
0164        Provide a default value for failed results.
0165    */
0166    public func ?? <T> (result: Result<T>, @autoclosure defaultValue: () -> T) -> T {
0167        switch result {
0168        case .Success(let x): return x
0169        case .Error: return defaultValue()
0170        }
0171    }
0172