## Operator: &-

``` operator &- { associativity left precedence }```

### Declarations

func &-(_: Self, rhs: Self)

Returns the difference of the two given values, discarding any overflow.

The masking subtraction operator (`&-`) silently discards any overflow that occurs during the operation. In the following example, the difference of `10` and `21` is less than zero, the minimum representable `UInt` value, so the result is the overflowed value:

``````let x: UInt8 = 21 &- 10
// x == 11
let y: UInt8 = 10 &- 21
// y == 245 (after overflow)``````

Parameters: lhs: A numeric value. rhs: The value to subtract from `lhs`.

#### Declaration

`func &-(lhs: Self, rhs: Self) -> Self`

#### Declared In

`FixedWidthInteger`, `SignedInteger`
func &-(_: Self, rhs: Self)

Returns the difference of the two given values, discarding any overflow.

The masking subtraction operator (`&-`) silently discards any overflow that occurs during the operation. In the following example, the difference of `10` and `21` is less than zero, the minimum representable `UInt` value, so the result is the overflowed value:

``````let x: UInt8 = 21 &- 10
// x == 11
let y: UInt8 = 10 &- 21
// y == 245 (after overflow)``````

Parameters: lhs: A numeric value. rhs: The value to subtract from `lhs`.

#### Declaration

`func &-(lhs: Self, rhs: Self) -> Self`

#### Declared In

`FixedWidthInteger`, `SignedInteger`
func &-(_: Self, rhs: Self)

Returns the difference of the two given values, discarding any overflow.

The masking subtraction operator (`&-`) silently discards any overflow that occurs during the operation. In the following example, the difference of `10` and `21` is less than zero, the minimum representable `UInt` value, so the result is the overflowed value:

``````let x: UInt8 = 21 &- 10
// x == 11
let y: UInt8 = 10 &- 21
// y == 245 (after overflow)``````

Parameters: lhs: A numeric value. rhs: The value to subtract from `lhs`.

#### Declaration

`func &-(lhs: Self, rhs: Self) -> Self`

#### Declared In

`FixedWidthInteger`, `SignedInteger`
func &-(_: Self, rhs: Self)

Returns the difference of the two given values, discarding any overflow.

The masking subtraction operator (`&-`) silently discards any overflow that occurs during the operation. In the following example, the difference of `10` and `21` is less than zero, the minimum representable `UInt` value, so the result is the overflowed value:

``````let x: UInt8 = 21 &- 10
// x == 11
let y: UInt8 = 10 &- 21
// y == 245 (after overflow)``````

Parameters: lhs: A numeric value. rhs: The value to subtract from `lhs`.

#### Declaration

`func &-(lhs: Self, rhs: Self) -> Self`

#### Declared In

`FixedWidthInteger`, `SignedInteger`
func &-(_: Self, rhs: Self)

Returns the difference of the two given values, discarding any overflow.

The masking subtraction operator (`&-`) silently discards any overflow that occurs during the operation. In the following example, the difference of `10` and `21` is less than zero, the minimum representable `UInt` value, so the result is the overflowed value:

``````let x: UInt8 = 21 &- 10
// x == 11
let y: UInt8 = 10 &- 21
// y == 245 (after overflow)``````

Parameters: lhs: A numeric value. rhs: The value to subtract from `lhs`.

#### Declaration

`func &-(lhs: Self, rhs: Self) -> Self`

#### Declared In

`FixedWidthInteger`, `SignedInteger`
func &-(_: Self, rhs: Self)

Returns the difference of the two given values, discarding any overflow.

The masking subtraction operator (`&-`) silently discards any overflow that occurs during the operation. In the following example, the difference of `10` and `21` is less than zero, the minimum representable `UInt` value, so the result is the overflowed value:

``````let x: UInt8 = 21 &- 10
// x == 11
let y: UInt8 = 10 &- 21
// y == 245 (after overflow)``````

Parameters: lhs: A numeric value. rhs: The value to subtract from `lhs`.

#### Declaration

`func &-(lhs: Self, rhs: Self) -> Self`

#### Declared In

`FixedWidthInteger`
func &-(_: Self, rhs: Self)

Returns the difference of the two given values, discarding any overflow.

The masking subtraction operator (`&-`) silently discards any overflow that occurs during the operation. In the following example, the difference of `10` and `21` is less than zero, the minimum representable `UInt` value, so the result is the overflowed value:

``````let x: UInt8 = 21 &- 10
// x == 11
let y: UInt8 = 10 &- 21
// y == 245 (after overflow)``````

Parameters: lhs: A numeric value. rhs: The value to subtract from `lhs`.

#### Declaration

`func &-(lhs: Self, rhs: Self) -> Self`

#### Declared In

`FixedWidthInteger`
func &-(_: Self, rhs: Self)

Returns the difference of the two given values, discarding any overflow.

The masking subtraction operator (`&-`) silently discards any overflow that occurs during the operation. In the following example, the difference of `10` and `21` is less than zero, the minimum representable `UInt` value, so the result is the overflowed value:

``````let x: UInt8 = 21 &- 10
// x == 11
let y: UInt8 = 10 &- 21
// y == 245 (after overflow)``````

Parameters: lhs: A numeric value. rhs: The value to subtract from `lhs`.

#### Declaration

`func &-(lhs: Self, rhs: Self) -> Self`

#### Declared In

`FixedWidthInteger`
func &-(_: Self, rhs: Self)

Returns the difference of the two given values, discarding any overflow.

The masking subtraction operator (`&-`) silently discards any overflow that occurs during the operation. In the following example, the difference of `10` and `21` is less than zero, the minimum representable `UInt` value, so the result is the overflowed value:

``````let x: UInt8 = 21 &- 10
// x == 11
let y: UInt8 = 10 &- 21
// y == 245 (after overflow)``````

Parameters: lhs: A numeric value. rhs: The value to subtract from `lhs`.

#### Declaration

`func &-(lhs: Self, rhs: Self) -> Self`

#### Declared In

`FixedWidthInteger`
func &-(_: Self, rhs: Self)

Returns the difference of the two given values, discarding any overflow.

The masking subtraction operator (`&-`) silently discards any overflow that occurs during the operation. In the following example, the difference of `10` and `21` is less than zero, the minimum representable `UInt` value, so the result is the overflowed value:

``````let x: UInt8 = 21 &- 10
// x == 11
let y: UInt8 = 10 &- 21
// y == 245 (after overflow)``````

Parameters: lhs: A numeric value. rhs: The value to subtract from `lhs`.

#### Declaration

`func &-(lhs: Self, rhs: Self) -> Self`

#### Declared In

`FixedWidthInteger`