Enum générique Swift 4 avec type associé Void

Question

en résumé

Est-il possible d'instancier un membre générique d'enum Swift 4 avec une valeur associée de type Void ?

Contexte

J'utilise un simple Résultat enum (similaire à Résultat antitypique ) :

enum Result<T> {
  case success(T)
  case error(Error?)
}

Maintenant, j'aimerais utiliser cet enum pour représenter le résultat d'une opération qui ne produit pas de valeur de résultat réelle ; l'opération est soit a réussi ou échoué . Pour cela, je définirais le type comme Result<Void> mais je ne parviens pas à créer l'instance de résultat, ni l'un ni l'autre. let res: Result<Void> = .success ni let res: Result<Void> = .success() travaux.

Answer 1

En Swift 3, vous pouvez omettre la valeur associée de type Void :

let res: Result<Void> = .success()

En Swift 4, vous devez passer une valeur associée de type Void :

let res: Result<Void> = .success(())
// Or just:
let res = Result.success(())

Answer 2

Dans Swift 4, un cas d'enum avec un élément de type Void n'est plus équivalent à un cas d'énumération avec une liste vide de valeurs associées.

Je crois que c'est ça, comme le dit Martin à la suite de SE-0029 où il n'est plus possible de passer un n-uplet d'arguments à une fonction et de les faire "éclater" parmi les paramètres (bien que cette proposition ait été marquée dans Swift 3, je crois que ce cas particulier a été repris plus tard dans l'implémentation de la fonction SE-0110 pour Swift 4).

En conséquence, cela signifie que vous ne pouvez plus appeler une (Void) -> T en tant que () -> T dans Swift 4. Vous devez maintenant passer Void de manière explicite :

let result = Result.success(())

Cependant, je trouve cela assez laid, donc j'implémente généralement une extension comme celle-ci :

extension Result where Success == Void {
    static var success: Result {
        return .success(())
    }
}

Ce qui vous permet de dire des choses comme ça :

var result = Result.success
result = .success

Il convient de noter que cette solution de contournement n'est pas seulement limitée aux cas d'enum, elle peut également être utilisée avec les méthodes en général. Par exemple :

struct Foo<T> {
  func bar(_ a: T) {}
}

extension Foo where T == Void {
  func bar() { bar(()) }
}

let f = Foo<Void>()

// without extension:
f.bar(())

// with extension:
f.bar()

Answer 3

Void est un simple typealias pour le tuple vide : () donc vous pouvez l'utiliser comme l'un des suivants :

let res1: Result<Void> = .success(())
let res2 = Result<Void>.success(())
let res3 = Result.success(() as Void)
let res4 = Result.success(())

Answer 4

Swift 5 a mis à jour Resultat pour exiger le paramètre Failure, mais exige toujours la valeur associée :

let res: Result<Void, Error> = .success(())

Answer 5

I trouver .success(Void()) est plus descriptif et plus simple.