Type nesting

Type nesting allows you to define types within the context of other types, thereby making your code more organized and expressive. By nesting types, you encapsulate related functionalities and make the outer type's namespace cleaner. You can nest enumerations, structures, and classes within enumerations, structures, and classes.

Here's an example of type nesting in Swift:

struct ChessBoard {
   enum Piece {
       case pawn, knight, bishop, rook, queen, king
   }
   
   enum Player {
       case white, black
   }
   
   class Square {
       let piece: Piece
       let player: Player
       
       init(piece: Piece, player: Player) {
           self.piece = piece
           self.player = player
       }
   }
   
   var board: [[Square?]] = Array(repeating: Array(repeating: nil, count: 8), count: 8)
   
   func placePiece(_ piece: Piece, by player: Player, at x: Int, y: Int) {
       board[x][y] = Square(piece: piece, player: player)
   }
}

In this example, the ChessBoard structure contains a nested enumeration Piece, another nested enumeration Player, and a nested class Square. These nested types make it clear that they are only intended to be used in the context of a ChessBoard.

Accessing Nested Types

You can reference nested types outside of the nesting type by using the nesting type's name as a prefix:

let myPiece: ChessBoard.Piece = .queen

Why Nest Types?

Encapsulation: Nested types encapsulate utility classes, structures, or enumerations that are only relevant in the context of the outer type, thus not polluting the global scope.

Readability: Grouping tightly-coupled types together improves code readability and understandability.

Namespacing: You can use the same names for nested types in different classes without conflict. For example, you could also have a Player enumeration in a CardGame struct without it clashing with the Player enumeration nested inside ChessBoard.

Extendability: You can extend the nested types outside of the nesting type using extensions. However, you must use the fully qualified name:

extension ChessBoard.Square {
   func description() -> String {
       return "This is a \(player) \(piece)"
   }
}

By understanding and using type nesting appropriately, you can write cleaner, more maintainable, and more organized Swift code.