`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 not equal.

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

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

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

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

All arity zero tuples are equal.

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

Returns a Boolean value indicating whether any corresponding components of the two tuples are not 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 "false"
let c = ("a", 2)
print(a != c)
// Prints "true"
```

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

Returns a Boolean value indicating whether any corresponding components of the two tuples are not 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 "false"
let c = ("a", 1, 3)
print(a != c)
// Prints "true"
```

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

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 "false"
let c = ("a", 1, 2, 4)
print(a != c)
// Prints "true"
```

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

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 "false"
let c = ("a", 1, 2, 3, 5)
print(a != c)
// Prints "true"
```

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

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 "false"
let c = ("a", 1, 2, 3, 4, 6)
print(a != c)
// Prints "true"
```

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

Returns a Boolean value indicating whether two types are not identical.

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

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

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

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

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

All arity zero tuples are equal.

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

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 "false"
let c = ("a", 2)
print(a != c)
// Prints "true"
```

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

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 "false"
let c = ("a", 1, 3)
print(a != c)
// Prints "true"
```

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

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 "false"
let c = ("a", 1, 2, 4)
print(a != c)
// Prints "true"
```

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

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 "false"
let c = ("a", 1, 2, 3, 5)
print(a != c)
// Prints "true"
```

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

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 "false"
let c = ("a", 1, 2, 3, 4, 6)
print(a != c)
// Prints "true"
```

Returns a Boolean value indicating whether two types are not identical.