Add a version of map that converts thrown errors to Failures.

[bwhiteley]

Add a variant of map that handles transforms that throw errors and converts errors to Failures.
This map is constrained to Results with Error types that can be constructed from arbitrary ErrorTypes.

[NachoSoto]

This as! Error is scary.
Can you do instead

do {
  ...
} catch error as Error {
  return .Failure(Error.errorFromErrorType(error)
} catch error {
  // what do we do here? `fatalError` I guess? (which would be equivalent to this implementation)
}

[NachoSoto]

Cool

[bwhiteley]

What's the verdict on this PR?

[robrix]

Since this actually behaves like flatMap (but with a restricted parameter type), calling it map seems a bit confusing 😕

[bwhiteley]

I agree, and would have preferred to call it flatMap. However, that resulted in "ambiguous use..." errors. Do you have a recommendation?

[robrix]

/cc @antitypical/result

[gfontenot]

Spitballing, but: Is there maybe a way to rewrite the current flatMap with rethrows in a way that covers both cases?

[bwhiteley]

I don't think so. The return type of the transform is quite different, and part of the reason for this PR is to be able to pass in functions that are not aware of Result.

[robrix]

Yeah, I don’t think this is precisely map or flatMap.

[bwhiteley]

I originally called it tryMap (PR #114), but tried to roll it into flatMap or map based on feedback in that PR. How are we feeling about tryMap?

[neilpa]

👍 on tryMap

[robrix]

Yeah, that was my bad, my apologies. I’m 👍 on the name tryMap.

[bwhiteley]

I renamed it to tryMap. Any other concerns?

[robrix]

👍 from me. @NachoSoto?

[NachoSoto]

I'm confused about this, if Error conforms to ErrorTypeConvertible, this is always going to be non-nil and of type Error, right?

[bwhiteley]

You would think so, but

ResultType.swift:82:58: error: 'Self.Error.ConvertibleType' is not convertible to 'Self.Error'; did you mean to use 'as!' to force downcast?
                                let convertedError = Error.errorFromErrorType(error) as Error
                                                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~
                                                                                     as!

[NachoSoto]

That seems like a bug.
What if you remove ConvertibleType and change ErrorTypeConvertible:

public protocol ErrorTypeConvertible: ErrorType {
    static func errorFromErrorType(error: ErrorType) -> Self
}

[bwhiteley]

That does permit the use of a plain as in tryMap, but then I can't make NSError conform to ErrorTypeConvertible, presumably because it's not final.

I boiled it down to a sample that you can tinker with in a Playground.

import Foundation

// For types that can be created from an arbitrary ErrorType
public protocol ErrorTypeConvertible: ErrorType {
    typealias ConvertibleType = Self
    static func errorFromErrorType(error: ErrorType) -> ConvertibleType
}

protocol MyType {
    typealias Error: ErrorType
    var error: Error { get }
}

extension MyType where Error: ErrorTypeConvertible {
    func foo() -> Error {
        return Error.errorFromErrorType(error) as! Error // ** Why does this require `!`? **
    }
}

extension NSError: ErrorTypeConvertible {
    public static func errorFromErrorType(error: ErrorType) -> NSError {
        return error as NSError
    }
}

[NachoSoto]

Probably related to https://twitter.com/jckarter/status/672931114944696321.

Given that the cast can never fail I'd just use as! and add a comment to improve this later on.

[NachoSoto]

👍 thanks @bwhiteley! this looks good now :)