0001    //  Copyright (c) 2015 Rob Rix. All rights reserved.
0002    
0003    /// A type that can represent either failure with an error or success with a result value.
0004    public protocol ResultType
Result.swift:4
public enum Result<T, Error: ErrorType>: ResultType, CustomStringConvertible, CustomDebugStringConvertible {
ResultType.swift:30
public extension ResultType {
ResultType.swift:73
public extension ResultType where Error: ErrorTypeConvertible {
ResultType.swift:101
public func &&& <L: ResultType, R: ResultType where L.Error == R.Error> (left: L, @autoclosure right: () -> R) -> Result<(L.Value, R.Value), L.Error> {
ResultType.swift:101
public func &&& <L: ResultType, R: ResultType where L.Error == R.Error> (left: L, @autoclosure right: () -> R) -> Result<(L.Value, R.Value), L.Error> {
 {
0005    	typealias Value
ResultType.swift:9
	init(value: Value)
ResultType.swift:17
	func analysis<U>(@noescape ifSuccess ifSuccess: Value -> U, @noescape ifFailure: Error -> U) -> U
ResultType.swift:22
	var value: Value? { get }
ResultType.swift:33
	public var value: Value? {
ResultType.swift:43
	public func map<U>(@noescape transform: Value -> U) -> Result<U, Error> {
ResultType.swift:48
	public func flatMap<U>(@noescape transform: Value -> Result<U, Error>) -> Result<U, Error> {
ResultType.swift:55
	public func mapError<Error2>(@noescape transform: Error -> Error2) -> Result<Value, Error2> {
ResultType.swift:60
	public func flatMapError<Error2>(@noescape transform: Error -> Result<Value, Error2>) -> Result<Value, Error2> {
ResultType.swift:60
	public func flatMapError<Error2>(@noescape transform: Error -> Result<Value, Error2>) -> Result<Value, Error2> {
ResultType.swift:62
			ifSuccess: Result<Value, Error2>.Success,
ResultType.swift:76
	public func tryMap<U>(@noescape transform: Value throws -> U) -> Result<U, Error> {
ResultType.swift:101
public func &&& <L: ResultType, R: ResultType where L.Error == R.Error> (left: L, @autoclosure right: () -> R) -> Result<(L.Value, R.Value), L.Error> {
ResultType.swift:101
public func &&& <L: ResultType, R: ResultType where L.Error == R.Error> (left: L, @autoclosure right: () -> R) -> Result<(L.Value, R.Value), L.Error> {

0006    	typealias Error
ResultType.swift:12
	init(error: Error)
ResultType.swift:17
	func analysis<U>(@noescape ifSuccess ifSuccess: Value -> U, @noescape ifFailure: Error -> U) -> U
ResultType.swift:27
	var error: Error? { get }
ResultType.swift:38
	public var error: Error? {
ResultType.swift:43
	public func map<U>(@noescape transform: Value -> U) -> Result<U, Error> {
ResultType.swift:48
	public func flatMap<U>(@noescape transform: Value -> Result<U, Error>) -> Result<U, Error> {
ResultType.swift:48
	public func flatMap<U>(@noescape transform: Value -> Result<U, Error>) -> Result<U, Error> {
ResultType.swift:51
			ifFailure: Result<U, Error>.Failure)
ResultType.swift:55
	public func mapError<Error2>(@noescape transform: Error -> Error2) -> Result<Value, Error2> {
ResultType.swift:60
	public func flatMapError<Error2>(@noescape transform: Error -> Result<Value, Error2>) -> Result<Value, Error2> {
ResultType.swift:76
	public func tryMap<U>(@noescape transform: Value throws -> U) -> Result<U, Error> {
ResultType.swift:82
				let convertedError = Error.errorFromErrorType(error) as! Error
ResultType.swift:82
				let convertedError = Error.errorFromErrorType(error) as! Error
ResultType.swift:101
public func &&& <L: ResultType, R: ResultType where L.Error == R.Error> (left: L, @autoclosure right: () -> R) -> Result<(L.Value, R.Value), L.Error> {
ResultType.swift:101
public func &&& <L: ResultType, R: ResultType where L.Error == R.Error> (left: L, @autoclosure right: () -> R) -> Result<(L.Value, R.Value), L.Error> {
ResultType.swift:101
public func &&& <L: ResultType, R: ResultType where L.Error == R.Error> (left: L, @autoclosure right: () -> R) -> Result<(L.Value, R.Value), L.Error> {
: ErrorType
0007    	
0008    	/// Constructs a successful result wrapping a `value`.
0009    	init(value: Value)
0010    
0011    	/// Constructs a failed result wrapping an `error`.
0012    	init(error: Error)
0013    	
0014    	/// Case analysis for ResultType.
0015    	///
0016    	/// Returns the value produced by appliying `ifFailure` to the error if self represents a failure, or `ifSuccess` to the result value if self represents a success.
0017    	func analysis
ResultType.swift:34
		return analysis(ifSuccess: { $0 }, ifFailure: { _ in nil })
ResultType.swift:39
		return analysis(ifSuccess: { _ in nil }, ifFailure: { $0 })
ResultType.swift:49
		return analysis(
ResultType.swift:61
		return analysis(
<U>(@noescape ifSuccess ifSuccess: Value -> U, @noescape ifFailure: Error -> U) -> U
0018    
0019    	/// Returns the value if self represents a success, `nil` otherwise.
0020    	///
0021    	/// A default implementation is provided by a protocol extension. Conforming types may specialize it.
0022    	var value: Value? { get }
0023    
0024    	/// Returns the error if self represents a failure, `nil` otherwise.
0025    	///
0026    	/// A default implementation is provided by a protocol extension. Conforming types may specialize it.
0027    	var error: Error? { get }
0028    }
0029    
0030    public extension ResultType {
0031    	
0032    	/// Returns the value if self represents a success, `nil` otherwise.
0033    	public var value
Result.swift:68
		return self.value ?? value()
Result.swift:133
	if let left = left.value, right = right.value {
Result.swift:133
	if let left = left.value, right = right.value {
: Value? {
0034    		return analysis(ifSuccess: { $0 }, ifFailure: { _ in nil })
0035    	}
0036    	
0037    	/// Returns the error if self represents a failure, `nil` otherwise.
0038    	public var error
Result.swift:135
	} else if let left = left.error, right = right.error {
Result.swift:135
	} else if let left = left.error, right = right.error {
: Error? {
0039    		return analysis(ifSuccess: { _ in nil }, ifFailure: { $0 })
0040    	}
0041    
0042    	/// Returns a new Result by mapping `Success`es’ values using `transform`, or re-wrapping `Failure`s’ errors.
0043    	public func map
ResultType.swift:102
	return left.flatMap { left in right().map { right in (left, right) } }
<U>(@noescape transform: Value -> U) -> Result<U, Error> {
0044    		return flatMap { .Success(transform($0)) }
0045    	}
0046    
0047    	/// Returns the result of applying `transform` to `Success`es’ values, or re-wrapping `Failure`’s errors.
0048    	public func flatMap
Result.swift:213
	return result.flatMap(transform)
ResultType.swift:44
		return flatMap { .Success(transform($0)) }
ResultType.swift:77
		return flatMap { value in
ResultType.swift:102
	return left.flatMap { left in right().map { right in (left, right) } }
<U>(@noescape transform: Value -> Result<U, Error>) -> Result<U, Error> {
0049    		return analysis(
0050    			ifSuccess: transform,
0051    			ifFailure: Result<U, Error>.Failure)
0052    	}
0053    	
0054    	/// Returns a new Result by mapping `Failure`'s values using `transform`, or re-wrapping `Success`es’ values.
0055    	public func mapError<Error2>(@noescape transform: Error -> Error2) -> Result<Value, Error2> {
0056    		return flatMapError { .Failure(transform($0)) }
0057    	}
0058    	
0059    	/// Returns the result of applying `transform` to `Failure`’s errors, or re-wrapping `Success`es’ values.
0060    	public func flatMapError
ResultType.swift:56
		return flatMapError { .Failure(transform($0)) }
<Error2>(@noescape transform: Error -> Result<Value, Error2>) -> Result<Value, Error2> {
0061    		return analysis(
0062    			ifSuccess: Result<Value, Error2>.Success,
0063    			ifFailure: transform)
0064    	}
0065    }
0066    
0067    /// Protocol used to constrain `tryMap` to `Result`s with compatible `Error`s.
0068    public protocol ErrorTypeConvertible
Result.swift:222
extension NSError: ErrorTypeConvertible {
: ErrorType {
0069    	typealias ConvertibleType
ResultType.swift:70
	static func errorFromErrorType(error: ErrorType) -> ConvertibleType
 = Self
0070    	static func errorFromErrorType
ResultType.swift:82
				let convertedError = Error.errorFromErrorType(error) as! Error
(error: ErrorType) -> ConvertibleType
0071    }
0072    
0073    public extension ResultType where Error: ErrorTypeConvertible {
0074    
0075    	/// Returns the result of applying `transform` to `Success`es’ values, or wrapping thrown errors.
0076    	public func tryMap<U>(@noescape transform: Value throws -> U) -> Result<U, Error> {
0077    		return flatMap { value in
0078    			do {
0079    				return .Success(try transform(value))
0080    			}
0081    			catch {
0082    				let convertedError = Error.errorFromErrorType(error) as! Error
0083    				// Revisit this in a future version of Swift. https://twitter.com/jckarter/status/672931114944696321
0084    				return .Failure(convertedError)
0085    			}
0086    		}
0087    	}
0088    }
0089    
0090    // MARK: - Operators
0091    
0092    infix operator &&& {
0093    	/// Same associativity as &&.
0094    	associativity left
0095    
0096    	/// Same precedence as &&.
0097    	precedence 120
0098    }
0099    
0100    /// Returns a Result with a tuple of `left` and `right` values if both are `Success`es, or re-wrapping the error of the earlier `Failure`.
0101    public func &&& <L: ResultType, R: ResultType where L.Error == R.Error> (left: L, @autoclosure right: () -> R) -> Result<(L.Value, R.Value), L.Error> {
0102    	return left.flatMap { left in right().map { right in (left, right) } }
0103    }
0104