Pourquoi ne les énumérations ont calculé les propriétés, mais pas stockées les propriétés de Swift?

Les énumérations ne permettant pas stockées les propriétés de l'occurrence est un choix de conception. Ayant enum avec stockées les propriétés de l'occurrence le rend comme un struct (avec le protocole enum superpuissances), mais seulement de type point de vue maintenant enums agira comme type de multiplicateurs. Fondamentalement envisager

enum Set1 {
    case a
    case b
    case c
}

enum Times {
    case x
    case y

    var k: Set1
}

Ce que cela signifie réellement que enum Times nous permet d'avoir n'importe quelle combinaison d'éléments de Set1 et Set2 résultant dans 6 cas distincts, mais attendez, nous savons que c'est en réalité un but d'un tuple de type comme (Set1, Set2), où Times peuvent être déclarées comme

typealias Times = (Set1, Set2)

J'espère que cela constitue un motif raisonnable de ne pas permettre que le premier cas.

Cela étant dit, swift énumérations permettent d'associer l'arbitraire d'un n-tuple avec chaque cas, ce qui nous permet de déclarer ce qui est connu comme une discrimination de l'union dans la programmation fonctionnelle. Appeler un stockées propriété attachée à l'affaire si vous le souhaitez. À partir de types de points de vue, il agit maintenant à titre de type de basilic.

enum Add {
    case lhs(Set1)
    case rhs(Set2)
}

Nous avons maintenant 5 cas différents. Si nous avons maintenant un magasin de 2-tuples:

enum AddTimes {
    case lhs(Set1, Set2)
    case rhs(Set3, Set4)
}

nous maintenant ont essentiellement une somme de multiplication (Set1 * Set2 + Set3 * Set4).
C'est un outil très puissant quand il s'agit de la correspondance de motif.

CEPENDANT, il existe de réelles cas où vous avez réellement envie de les imiter la forme d'stockées à l'intérieur de la propriété enum. Considérez ceci:

public enum Service {
    case registerNewUser(username: String, password: String, language: String)
    case login(username: String, password: String, deviceTokenº: String?)
    case logout(sessionToken: String)
    case sendForgotPassword(email: String)
}

est déclaratif façon de définir le RESTE des points de terminaison (dans le cadre, comme Moya)
Lorsque vous voulez le feu à une demande que vous feriez quelque chose comme

MoyaProvider<Service>.request(.sendForgotPassword(email: "[email protected]"))

Mais maintenant, imaginez que vous voulez différencier entre production et d'serveur de test. Si vous ajoutez un serveur comme un autre élément tuple dans chaque cas:

case forgotPassword(sessionToken: String, serverBaseURLString: String)

ce sera une mauvaise sémantique, depuis que vous avez l'intention de chaque tuple de stocker les paramètres de la demande, mais maintenant il stocke un serveur de base de l'adresse.

Pour éviter ce genre de choses nous pouvons paramétrer notre type de la manière suivante. Au lieu d'avoir le Serveur étant défini comme dire:

enum Server: String {
    case production = "https://service.info"
    case test = "http://test.service.info"
}

on peut la définir avec type distinct pour chaque cas comme:

public struct ProductionServer: ServerType {
    public static var baseURLString: String { return "https://service.info" }
}
public struct TestServer: ServerType {
    public static var baseURLString: String { return  "http://test.service.info" }
}
public protocol ServerType {
    static var baseURLString: String { get }
}

et enfin paramétrer notre ServiceType comme

public enum Service<T> where T: ServerType {
    case registerNewUser(username: String, password: String, language: String)
    case login(username: String, password: String, deviceTokenº: String?)
    case logout(sessionToken: String)
    case sendForgotPassword(email: String)

    var serverURL: URL {
        return T.baseURL
    }
}

public typealias ProdutionService = Service<ProductionServer>
public typealias TestService = Service<TestServer>

Un enum est considéré comme une structure du type de données qui peuvent être modifiées, sans avoir à modifier le dire un String ou Int plusieurs fois dans votre code et avec un enum nous ne pourrons jamais avoir à vous soucier de changer la même chose plus d'une fois. Par exemple menu déroulant:

enum DropDownMenuOptions: String {
  case MenuOptionOne
  case MenuOptionTwo
  case MenuOptionThree
}

Avec stockées les propriétés de u peut précalculer les informations nécessaires et de réduire le code dans votre fonction principale. Le meilleur exemple est le calcul de la taille de rect par exemple:

struct Point {
    var x = 0.0, y = 0.0
}
struct Size {
    var width = 0.0, height = 0.0
}
struct Rect {
    var origin = Point()
    var size = Size()
    var center: Point {
        get {
            let centerX = origin.x + (size.width / 2)
            let centerY = origin.y + (size.height / 2)
            return Point(x: centerX, y: centerY)
        }
        set(newCenter) {
            origin.x = newCenter.x - (size.width / 2)
            origin.y = newCenter.y - (size.height / 2)
        }
    }
}

var square = Rect(origin: Point(x: 0.0, y: 0.0),
    size: Size(width: 10.0, height: 10.0))