如何在Swift中专门化泛型枚举

Question

I'm using the antitypical/result package to provide a generic Result type. This package defines Result as follows:

public enum Result<T, Error> {
     ...
}

Now, I only wish to return errors of type NSError in my code, so it would be nice if I didn't have to keep doing things this:

func myFunc() -> Result<String, NSError> { ... }

Instead, I want to create a derived StdResult type so that I can do this instead:

func myFunc() -> StdResult<String> { ... }

I've tried various things but I can't find a solution. This, for example, doesn't work:

typealias StdResult<T> = Result<T, NSError>

Is there a solution which will work?

Answer 1

Unfortunately we're pretty limited here. Swift doesn't support generic typealias, so we can do this as a sort of hack with struct:

struct StdResult<T> {
    typealias Type = Test<T, NSError>
}

func myFunc() -> StdResult<String>.Type {

}

Does that fit what you were looking for closely enough?

Answer 2

At the moment, there's no generic typealias support nor enumeration inheritance, but you could use RawRepresentable protocol. It's not as easy as if a generic typealias exists, but it may fit your needs.

RawRepresentable

From Apple's documentation :

A type that can be converted to an associated "raw" type, then converted back to produce an instance equivalent to the original.

public protocol RawRepresentable {
  typealias RawValue
  public init?(rawValue: Self.RawValue)
  public var rawValue: Self.RawValue { get }
}

---

That said, your raw value must be Result<T, NSError> :

enum StdResult<T>: RawRepresentable {

  var rawValue: Result<T, NSError> {
    switch self {
    case .Success(let value):
      return Result.Success(value)
    case .Failure(let error):
      return Result.Failure(error)
    }
  }

  init?(rawValue: Result<T, NSError>) {
    switch rawValue {
    case .Success(let value):
      self = .Success(value)
    case .Failure(let error):
      self = .Failure(error)
    }
  }

  case Success(T)
  case Failure(NSError)
}

func myFunc() -> StdResult<String> { }

Note : Properties and methods of original Result enumeration are only accessible from rawValue property, so, for example, if you want to compare your new StdResult with another, you must use rawValue property or reimplement these protocols yourself.

Answer 3

You could alias the specific Result type so you don't have to constantly do func myThing() -> Result<String, NSError>

eg

typealias StringResult = Result<String, NSError>

func myOtherThing() -> StringResult

It's more difficult for me to come up with a generic solution like

MyResult<String>

without understanding exactly what Result is doing. I could take another crack at it if you post some of the internals.