Failable initializers

In Swift, a failable initializer is a special type of initializer that returns an optional instance of the class, struct or enum. It can be used to create an instance of the class, struct or enum if the initialization is successful, or to return nil if the initialization fails.

The failable initializer is defined using the keyword “init?” instead of “init” for normal initializers. The failable initializer can be used when there are conditions that could cause the initialization to fail, such as invalid input or missing data.

Ways to use:

Failable initializers can be classified into two types: those that return an optional value and those that throw an error.

1. Failable Initializer that returns nil:

A failable initializer that returns nil is a special type of initializer that can return an optional value (i.e., nil) when it fails to initialize an object. To create a failable initializer that returns nil, you use the init? keyword followed by the normal initialization code.

struct Person {
  let name: String
  let age: Int
  
  init?(name: String, age: Int) {
    if name.isEmpty || age < 0 {
      return nil
    }
    self.name = name
    self.age = age
  }
}

// Usage
let john = Person(name: "John", age: 30) // returns a valid Person object
let emptyName = Person(name: "", age: 30) // returns nil
let negativeAge = Person(name: "John", age: -1) // returns nil

In the above example, the failable initializer returns nil when the name parameter is empty or the age parameter is negative.

2. Failable Initializer that throws error:

A failable initializer that throws an error is another type of failable initializer that allows you to handle initialization failures using error handling. To create a failable initializer that throws an error, you use the init() keyword followed by the normal initialization code, and then add a “throws” keyword to the initializer signature.

enum MyError: Error {
  case invalidName
  case invalidAge
}

struct Person {
  let name: String
  let age: Int
  
  init(name: String, age: Int) throws {
    guard !name.isEmpty else {
      throw MyError.invalidName
    }
    guard age > 0 else {
      throw MyError.invalidAge
    }
    self.name = name
    self.age = age
  }
}

// Usage
do {
  let john = try Person(name: "John", age: 30) // returns a valid Person object
} catch MyError.invalidName {
  // handle invalid name error
} catch MyError.invalidAge {
  // handle invalid age error
} catch {
  // handle other errors
}

In the above example, the failable initializer throws an error when the name parameter is empty or the age parameter is negative.

In conclusion, failable initializers in Swift allow you to handle initialization failures in a flexible manner. You can create failable initializers that return nil or throw an error, depending on your needs.