Protocol Requirements

// PROTOCOL REQUIREMENTS
// Different types of requirements protocols can define

// PROPERTY REQUIREMENTS
protocol FullyNamed {
    var fullName: String { get }  // Read-only requirement
}

protocol Configurable {
    var isEnabled: Bool { get set }  // Read-write requirement
}

struct Person: FullyNamed {
    var firstName: String
    var lastName: String

    var fullName: String {  // Computed property satisfies get
        return "\(firstName) \(lastName)"
    }
}

class Device: Configurable {
    var isEnabled: Bool = false  // Stored property satisfies get set
}

// STATIC PROPERTY REQUIREMENTS
protocol Countable {
    static var count: Int { get set }
}

struct Item: Countable {
    static var count: Int = 0

    init() {
        Item.count += 1
    }
}

// METHOD REQUIREMENTS
protocol Toggleable {
    mutating func toggle()
}

struct Switch: Toggleable {
    var isOn: Bool = false

    mutating func toggle() {
        isOn = !isOn
    }
}

// Note: Classes don't need 'mutating'
class Light: Toggleable {
    var isOn: Bool = false

    func toggle() {  // No mutating keyword needed
        isOn = !isOn
    }
}

// STATIC METHOD REQUIREMENTS
protocol Creatable {
    static func create() -> Self
}

class Document: Creatable {
    required init() { }

    static func create() -> Self {
        return self.init()
    }
}

// INITIALIZER REQUIREMENTS
protocol Initializable {
    init(value: Int)
}

// Classes must use 'required' keyword
class Counter: Initializable {
    var value: Int

    required init(value: Int) {
        self.value = value
    }
}

// Structs don't need 'required'
struct Score: Initializable {
    var value: Int

    init(value: Int) {
        self.value = value
    }
}

// FAILABLE INITIALIZER REQUIREMENTS
protocol StringInitializable {
    init?(from string: String)
}

struct Age: StringInitializable {
    var value: Int

    init?(from string: String) {
        guard let age = Int(string), age >= 0 else {
            return nil
        }
        self.value = age
    }
}

// SUBSCRIPT REQUIREMENTS
protocol Indexable {
    subscript(index: Int) -> String { get }
}

struct StringList: Indexable {
    var items: [String]

    subscript(index: Int) -> String {
        return items[index]
    }
}

// ASSOCIATED TYPE REQUIREMENTS (Preview)
protocol Container {
    associatedtype Item
    var items: [Item] { get set }
    mutating func append(_ item: Item)
}

struct IntContainer: Container {
    var items: [Int] = []

    mutating func append(_ item: Int) {
        items.append(item)
    }
}