Enums In Swift

Introduction

 

Enum consists of zero or more cases, with each case having an optional tuple style list of associated values. A case contains many associated values, but is considered as a single tuple. Enum has similar syntax as class syntax. The syntax of enum is shown below,

enum Text
{
 case l1
 case c1
 case r1
}

The result type to represent the success or failure of an operation adds a second associated value for the failure cases and enables it to capture detailed error information.

 

The full type annotation needs to be provided including the generic parameters. Enum is special data type and it enables a variable to be a set of predefined constants. It is used when the possible values are known.

• Enums have methods and subscripts.
• Methods can be declared mutating or non mutating.
• Extension are used in enums and it conforms to the protocol.

Value types

 

Enums are value types and cannot have stored properties. Enum state is represented by its case associated value. Associated values are stored properties for the particular case. The enums are mutated by assigning a new value directly to the self. The initialization of enum is to assign it a case. It is possible to add additional initializers in type definition or extension. The initializer is added to our text alignment enum that sets a defaut text alignment for locale as shown below,

extension Text {
    init(defaultFor locale: Locale) {
        guard
        let language = locale.languageCode
        else {
            self = .left
            return
        }
        switch Locate.characterDirection(forLanguage: language) {
            case.rightToLeft: self = .right
            case.leftToRight, .topToBottom, .bottomToTop, .unknown: self = .left
            @unknown
            default: self = .left
        }
    }
}
let english = Locate(identifier: "en_AU")
Text(defaultFor: english)
let arabic = Locale(identifier: "arEG")
Text(defaultFor: arabic)

Pattern matching

 

Switch statement is to inspect an enum and and it has a convenient syntax for comparing a value against a particular case and extracting the associated values. Pattern matching is the most prominent use case and it is used to decompose a data structure by its shape. Pure matching is able to combine with value binding. The case begins with one or more patterns and the input value is matched to it. 

 

Wildcard pattern

 

It is used for ignoring part of an associated value while matching another. In switch statement case is equivalent to the default key word.

 

Tuple pattern

 

It matches tuples with a common separated list of zeros and it matches a tuple with three elements where the second element is 0 and binds with the first element.

 

Enum case pattern

 

It matches the specified enum case and the pattern includes the subpattern for the associated values. To ignore the associated value the underscore is used.

 

Value binding pattern

 

It binds the matched value to new content and the scope of the new variable is the case block as it appears.

 

The pattern .failure matches the failure case and binds with associated value to the local error:

let result : Result < (Int, String), Error>=

switch result
{
 case.success (42, _):
 print (" The number is found ")
 case.success (_):
 print (" Another number is found ")
 case.failure (let error):
 print("Error:\(error)")
}

Type Casting Pattern

 

If the value runtime type is the same as the specified type, the pattern of some type matches. Some type perfoms the same check and additionally casts the matched value to the specified type.

let input : Any =
switch input
{
 case let integer as int :
 case let string as String:
 default : fatalError (" Error occured")
}

Designing with Enums

 

Enums have different design patterns since true sum types are uncommon and work with traditional object oriented approaches. The main use of enum is to make illegal states impossible and use enums for modelling state and recusrsive data structures.