`func ==(t0:t1:)(t0: Any.Type?, t1: Any.Type?) -> Bool`

`func ==(lhs:rhs:)(lhs: T, rhs: T) -> Bool`

Returns a Boolean value indicating whether the two arguments are equal.

`func ==(lhs:rhs:)(lhs: (), rhs: ()) -> Bool`

Returns a Boolean value indicating whether the corresponding components of two tuples are equal.

All arity zero tuples are equal.

`func ==(lhs:rhs:)(lhs: (A, B), rhs: (A, B)) -> Bool`

Returns a Boolean value indicating whether the corresponding components of two tuples are equal.

For two tuples to compare as equal, each corresponding pair of components must be equal. The following example compares tuples made up of 2 components:

```
let a = ("a", 1)
let b = ("a", 1)
print(a == b)
// Prints "true"
let c = ("a", 2)
print(a == c)
// Prints "false"
```

`func ==(lhs:rhs:)(lhs: (A, B, C), rhs: (A, B, C)) -> Bool`

Returns a Boolean value indicating whether the corresponding components of two tuples are equal.

For two tuples to compare as equal, each corresponding pair of components must be equal. The following example compares tuples made up of 3 components:

```
let a = ("a", 1, 2)
let b = ("a", 1, 2)
print(a == b)
// Prints "true"
let c = ("a", 1, 3)
print(a == c)
// Prints "false"
```

`func ==(lhs:rhs:)(lhs: (A, B, C, D), rhs: (A, B, C, D)) -> Bool`

Returns a Boolean value indicating whether the corresponding components of two tuples are equal.

For two tuples to compare as equal, each corresponding pair of components must be equal. The following example compares tuples made up of 4 components:

```
let a = ("a", 1, 2, 3)
let b = ("a", 1, 2, 3)
print(a == b)
// Prints "true"
let c = ("a", 1, 2, 4)
print(a == c)
// Prints "false"
```

`func ==(lhs:rhs:)(lhs: (A, B, C, D, E), rhs: (A, B, C, D, E)) -> Bool`

Returns a Boolean value indicating whether the corresponding components of two tuples are equal.

For two tuples to compare as equal, each corresponding pair of components must be equal. The following example compares tuples made up of 5 components:

```
let a = ("a", 1, 2, 3, 4)
let b = ("a", 1, 2, 3, 4)
print(a == b)
// Prints "true"
let c = ("a", 1, 2, 3, 5)
print(a == c)
// Prints "false"
```

`func ==(lhs:rhs:)(lhs: (A, B, C, D, E, F), rhs: (A, B, C, D, E, F)) -> Bool`

Returns a Boolean value indicating whether the corresponding components of two tuples are equal.

For two tuples to compare as equal, each corresponding pair of components must be equal. The following example compares tuples made up of 6 components:

```
let a = ("a", 1, 2, 3, 4, 5)
let b = ("a", 1, 2, 3, 4, 5)
print(a == b)
// Prints "true"
let c = ("a", 1, 2, 3, 4, 6)
print(a == c)
// Prints "false"
```

`func ==(t0:t1:)(t0: Any.Type?, t1: Any.Type?) -> Bool`

Returns a Boolean value indicating whether two types are identical.

`func ==(lhs:rhs:)(lhs: T, rhs: T) -> Bool`

Returns a Boolean value indicating whether the two arguments are equal.

`func ==(lhs:rhs:)(lhs: (), rhs: ()) -> Bool`

Returns a Boolean value indicating whether the corresponding components of two tuples are equal.

All arity zero tuples are equal.

`func ==(lhs:rhs:)(lhs: (A, B), rhs: (A, B)) -> Bool`

Returns a Boolean value indicating whether the corresponding components of two tuples are equal.

For two tuples to compare as equal, each corresponding pair of components must be equal. The following example compares tuples made up of 2 components:

```
let a = ("a", 1)
let b = ("a", 1)
print(a == b)
// Prints "true"
let c = ("a", 2)
print(a == c)
// Prints "false"
```

`func ==(lhs:rhs:)(lhs: (A, B, C), rhs: (A, B, C)) -> Bool`

Returns a Boolean value indicating whether the corresponding components of two tuples are equal.

For two tuples to compare as equal, each corresponding pair of components must be equal. The following example compares tuples made up of 3 components:

```
let a = ("a", 1, 2)
let b = ("a", 1, 2)
print(a == b)
// Prints "true"
let c = ("a", 1, 3)
print(a == c)
// Prints "false"
```

`func ==(lhs:rhs:)(lhs: (A, B, C, D), rhs: (A, B, C, D)) -> Bool`

Returns a Boolean value indicating whether the corresponding components of two tuples are equal.

For two tuples to compare as equal, each corresponding pair of components must be equal. The following example compares tuples made up of 4 components:

```
let a = ("a", 1, 2, 3)
let b = ("a", 1, 2, 3)
print(a == b)
// Prints "true"
let c = ("a", 1, 2, 4)
print(a == c)
// Prints "false"
```

`func ==(lhs:rhs:)(lhs: (A, B, C, D, E), rhs: (A, B, C, D, E)) -> Bool`

Returns a Boolean value indicating whether the corresponding components of two tuples are equal.

For two tuples to compare as equal, each corresponding pair of components must be equal. The following example compares tuples made up of 5 components:

```
let a = ("a", 1, 2, 3, 4)
let b = ("a", 1, 2, 3, 4)
print(a == b)
// Prints "true"
let c = ("a", 1, 2, 3, 5)
print(a == c)
// Prints "false"
```

`func ==(lhs:rhs:)(lhs: (A, B, C, D, E, F), rhs: (A, B, C, D, E, F)) -> Bool`

Returns a Boolean value indicating whether the corresponding components of two tuples are equal.

For two tuples to compare as equal, each corresponding pair of components must be equal. The following example compares tuples made up of 6 components:

```
let a = ("a", 1, 2, 3, 4, 5)
let b = ("a", 1, 2, 3, 4, 5)
print(a == b)
// Prints "true"
let c = ("a", 1, 2, 3, 4, 6)
print(a == c)
// Prints "false"
```

`func ==(a:b:)(a: AnyKeyPath, b: AnyKeyPath) -> Bool`

Returns a Boolean value indicating whether two values are equal.

Equality is the inverse of inequality. For any values `a`

and `b`

,
`a == b`

implies that `a != b`

is `false`

.

`func ==(lhs:rhs:)(lhs: CodingUserInfoKey, rhs: CodingUserInfoKey) -> Bool`

Returns a Boolean value indicating whether the given keys are equal.

- parameter lhs: The key to compare against.

- parameter rhs: The key to compare with.

`func ==(a:b:)(a: FloatingPointSign, b: FloatingPointSign) -> Bool`

Returns a Boolean value indicating whether two values are equal.

Equality is the inverse of inequality. For any values `a`

and `b`

,
`a == b`

implies that `a != b`

is `false`

.

`func ==(lhs:rhs:)(lhs: Int, rhs: Int) -> Bool`

Returns a Boolean value indicating whether two values are equal.

Equality is the inverse of inequality. For any values `a`

and `b`

,
`a == b`

implies that `a != b`

is `false`

.

`func ==(lhs:rhs:)(lhs: Int16, rhs: Int16) -> Bool`

Returns a Boolean value indicating whether two values are equal.

`a`

and `b`

,
`a == b`

implies that `a != b`

is `false`

.

`func ==(lhs:rhs:)(lhs: Int32, rhs: Int32) -> Bool`

Returns a Boolean value indicating whether two values are equal.

`a`

and `b`

,
`a == b`

implies that `a != b`

is `false`

.

`func ==(lhs:rhs:)(lhs: Int64, rhs: Int64) -> Bool`

Returns a Boolean value indicating whether two values are equal.

`a`

and `b`

,
`a == b`

implies that `a != b`

is `false`

.

`func ==(lhs:rhs:)(lhs: Int8, rhs: Int8) -> Bool`

Returns a Boolean value indicating whether two values are equal.

`a`

and `b`

,
`a == b`

implies that `a != b`

is `false`

.

`func ==(lhs:rhs:)(lhs: UInt, rhs: UInt) -> Bool`

Returns a Boolean value indicating whether two values are equal.

`a`

and `b`

,
`a == b`

implies that `a != b`

is `false`

.

`func ==(lhs:rhs:)(lhs: UInt16, rhs: UInt16) -> Bool`

Returns a Boolean value indicating whether two values are equal.

`a`

and `b`

,
`a == b`

implies that `a != b`

is `false`

.

`func ==(lhs:rhs:)(lhs: UInt32, rhs: UInt32) -> Bool`

Returns a Boolean value indicating whether two values are equal.

`a`

and `b`

,
`a == b`

implies that `a != b`

is `false`

.

`func ==(lhs:rhs:)(lhs: UInt64, rhs: UInt64) -> Bool`

Returns a Boolean value indicating whether two values are equal.

`a`

and `b`

,
`a == b`

implies that `a != b`

is `false`

.

`func ==(lhs:rhs:)(lhs: UInt8, rhs: UInt8) -> Bool`

Returns a Boolean value indicating whether two values are equal.

`a`

and `b`

,
`a == b`

implies that `a != b`

is `false`

.

`func ==(lhs:rhs:)(lhs: UnicodeDecodingResult, rhs: UnicodeDecodingResult) -> Bool`

Returns a Boolean value indicating whether two values are equal.

`a`

and `b`

,
`a == b`

implies that `a != b`

is `false`

.

Returns a Boolean value indicating whether two types are identical.