Alamofire Result to Antitypical Result conversion

AlamofireExtensions.swift

import Alamofire
import Foundation
import enum Result.Result

extension Alamofire.Result {
    func toStandard() -> Result<Value, Error> {
        switch(self) {
            case Alamofire.Result.Success(let value) : return Result.Success(value)
            case Alamofire.Result.Failure(let error) : return Result.Failure(error)
        }
    }
}

extension Response {
    func standardResult() -> Result<Value, Error> {
        return self.result.toStandard()
    }
}

This is another approach for Result interoperability. It adds Result.ResultType conformance to Alamofire.Result. Appears to work pretty well.

extension Alamofire.Result: ResultType {

    /// Constructs a success wrapping a `value`.
    public init(value: Value) {
        self = .Success(value)
    }

    /// Constructs a failure wrapping an `error`.
    public init(error: Error) {
        self = .Failure(error)
    }

    /// Case analysis for Result.
    ///
    /// Returns the value produced by applying `ifFailure` to `Failure` Results, or `ifSuccess` to `Success` Results.
    public func analysis<Result>(@noescape ifSuccess ifSuccess: Value -> Result, @noescape ifFailure: Error -> Result) -> Result {
        switch self {
        case let .Success(value):
            return ifSuccess(value)
        case let .Failure(value):
            return ifFailure(value)
        }
    }

}