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

### Declarations

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`

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`

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

`&-`

) 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`

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

`&-`

) 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`

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

`&-`

) 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`

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

`&-`

) 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`

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

`&-`

) 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`

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

`&-`

) 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`

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

`&-`

) 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`

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:Parameters:lhs:A numeric value.rhs:The value to subtract from`lhs`

.## Declaration

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

## Declared In

`FixedWidthInteger`

,`SignedInteger`