Type Annotations in Swift

Type annotations are used to specify the type of a value or variable in Swift. Type annotations are written immediately after the variable or value name, followed by a colon (:) and the name of the type.

Type annotations are optional in Swift, but they can be useful for providing additional information about the types of values in your code. This can make your code easier to read and understand, and it can also help the Swift compiler catch and diagnose errors in your code.

Here is an example of how you could use type annotations to specify the types of two variables in Swift:

var firstName: String = "Saif" 
var age: Int = 30

In this example, the firstName variable is annotated with the String type, and the age variable is annotated with the Int type. This tells the Swift compiler that firstName is a string of text and age is an integer, and it allows the compiler to check for type mismatches and other errors in your code.

Type annotations are also commonly used when declaring the types of function parameters and return values. Here is an example of a function that uses type annotations to specify the types of its parameters and return value:

func addTwoNumbers(firstNumber: Int, secondNumber: Int) -> Int { 
  return firstNumber + secondNumber 
}

In this example, the addTwoNumbers function takes two Int parameters and returns an Int value. The type annotations make it clear to the reader of the code what types of values are expected as inputs to the function and what type of value will be returned by the function.

Overall, type annotations are a useful tool for adding clarity and precision to your Swift code. While they are optional, they can help make your code easier to read and understand, and they can help the Swift compiler catch and diagnose errors in your code.