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

### Declarations

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

The masking multiplication operator (`&*`

) silently discards any overflow
that occurs during the operation. In the following example, the product
of `10`

and `50`

is greater than the maximum representable `Int8`

value,
so the result is the overflowed value:

```
let x: Int8 = 10 &* 5
// x == 50
let y: Int8 = 10 &* 50
// y == -12 (after overflow)
```

**Parameters:**
**lhs:** The first value to multiply.
**rhs:** The second value to multiply.

#### Declaration

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

#### Declared In

`FixedWidthInteger`

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

The masking multiplication operator (`&*`

) silently discards any overflow
that occurs during the operation. In the following example, the product
of `10`

and `50`

is greater than the maximum representable `Int8`

value,
so the result is the overflowed value:

```
let x: Int8 = 10 &* 5
// x == 50
let y: Int8 = 10 &* 50
// y == -12 (after overflow)
```

**Parameters:**
**lhs:** The first value to multiply.
**rhs:** The second value to multiply.

#### Declaration

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

#### Declared In

`FixedWidthInteger`

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

`&*`

) silently discards any overflow
that occurs during the operation. In the following example, the product
of `10`

and `50`

is greater than the maximum representable `Int8`

value,
so the result is the overflowed value:

```
let x: Int8 = 10 &* 5
// x == 50
let y: Int8 = 10 &* 50
// y == -12 (after overflow)
```

**Parameters:**
**lhs:** The first value to multiply.
**rhs:** The second value to multiply.

#### Declaration

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

#### Declared In

`FixedWidthInteger`

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

`&*`

) silently discards any overflow
that occurs during the operation. In the following example, the product
of `10`

and `50`

is greater than the maximum representable `Int8`

value,
so the result is the overflowed value:

```
let x: Int8 = 10 &* 5
// x == 50
let y: Int8 = 10 &* 50
// y == -12 (after overflow)
```

**Parameters:**
**lhs:** The first value to multiply.
**rhs:** The second value to multiply.

#### Declaration

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

#### Declared In

`FixedWidthInteger`

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

`&*`

) silently discards any overflow
that occurs during the operation. In the following example, the product
of `10`

and `50`

is greater than the maximum representable `Int8`

value,
so the result is the overflowed value:

```
let x: Int8 = 10 &* 5
// x == 50
let y: Int8 = 10 &* 50
// y == -12 (after overflow)
```

**Parameters:**
**lhs:** The first value to multiply.
**rhs:** The second value to multiply.

#### Declaration

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

#### Declared In

`FixedWidthInteger`

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

`&*`

) silently discards any overflow
that occurs during the operation. In the following example, the product
of `10`

and `50`

is greater than the maximum representable `Int8`

value,
so the result is the overflowed value:

```
let x: Int8 = 10 &* 5
// x == 50
let y: Int8 = 10 &* 50
// y == -12 (after overflow)
```

**Parameters:**
**lhs:** The first value to multiply.
**rhs:** The second value to multiply.

#### Declaration

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

#### Declared In

`FixedWidthInteger`

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

`&*`

) silently discards any overflow
that occurs during the operation. In the following example, the product
of `10`

and `50`

is greater than the maximum representable `Int8`

value,
so the result is the overflowed value:

```
let x: Int8 = 10 &* 5
// x == 50
let y: Int8 = 10 &* 50
// y == -12 (after overflow)
```

**Parameters:**
**lhs:** The first value to multiply.
**rhs:** The second value to multiply.

#### Declaration

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

#### Declared In

`FixedWidthInteger`

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

`&*`

) silently discards any overflow
that occurs during the operation. In the following example, the product
of `10`

and `50`

is greater than the maximum representable `Int8`

value,
so the result is the overflowed value:

```
let x: Int8 = 10 &* 5
// x == 50
let y: Int8 = 10 &* 50
// y == -12 (after overflow)
```

**Parameters:**
**lhs:** The first value to multiply.
**rhs:** The second value to multiply.

#### Declaration

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

#### Declared In

`FixedWidthInteger`

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

`&*`

) silently discards any overflow
that occurs during the operation. In the following example, the product
of `10`

and `50`

is greater than the maximum representable `Int8`

value,
so the result is the overflowed value:

```
let x: Int8 = 10 &* 5
// x == 50
let y: Int8 = 10 &* 50
// y == -12 (after overflow)
```

**Parameters:**
**lhs:** The first value to multiply.
**rhs:** The second value to multiply.

#### Declaration

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

#### Declared In

`FixedWidthInteger`

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

The masking multiplication operator (

`&*`

) silently discards any overflow that occurs during the operation. In the following example, the product of`10`

and`50`

is greater than the maximum representable`Int8`

value, so the result is the overflowed value:Parameters:lhs:The first value to multiply.rhs:The second value to multiply.## Declaration

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

## Declared In

`FixedWidthInteger`