```
operator &>>= {
associativity right
precedence
assignment
}
```

### Declarations

Calculates the result of shifting a value's binary representation the specified number of digits to the right, masking the shift amount to the type's bit width, and stores the result in the left-hand-side variable.

The `&>>=`

operator performs a *masking shift*, where the value passed as
`rhs`

is masked to produce a value in the range `0..<lhs.bitWidth`

. The
shift is performed using this masked value.

The following example defines `x`

as an instance of `UInt8`

, an 8-bit,
unsigned integer type. If you use `2`

as the right-hand-side value in an
operation on `x`

, the shift amount requires no masking.

```
var x: UInt8 = 30 // 0b00011110
x &>>= 2
// x == 7 // 0b00000111
```

However, if you use `19`

as `rhs`

, the operation first bitmasks `rhs`

to
`3`

, and then uses that masked value as the number of bits to shift `lhs`

.

```
var y: UInt8 = 30 // 0b00011110
y &>>= 19
// y == 3 // 0b00000011
```

**Parameters:**
**lhs:** The value to shift.
**rhs:** The number of bits to shift `lhs`

to the right. If `rhs`

is
outside the range `0..<lhs.bitWidth`

, it is masked to produce a
value within that range.

#### Declaration

`func &>>=(lhs: inout Int8, rhs: Int8)`

#### Declared In

`Int8`

, `FixedWidthInteger`

Calculates the result of shifting a value's binary representation the specified number of digits to the right, masking the shift amount to the type's bit width, and stores the result in the left-hand-side variable.

The `&>>=`

operator performs a *masking shift*, where the value passed as
`rhs`

is masked to produce a value in the range `0..<lhs.bitWidth`

. The
shift is performed using this masked value.

The following example defines `x`

as an instance of `UInt8`

, an 8-bit,
unsigned integer type. If you use `2`

as the right-hand-side value in an
operation on `x`

, the shift amount requires no masking.

```
var x: UInt8 = 30 // 0b00011110
x &>>= 2
// x == 7 // 0b00000111
```

However, if you use `19`

as `rhs`

, the operation first bitmasks `rhs`

to
`3`

, and then uses that masked value as the number of bits to shift `lhs`

.

```
var y: UInt8 = 30 // 0b00011110
y &>>= 19
// y == 3 // 0b00000011
```

**Parameters:**
**lhs:** The value to shift.
**rhs:** The number of bits to shift `lhs`

to the right. If `rhs`

is
outside the range `0..<lhs.bitWidth`

, it is masked to produce a
value within that range.

#### Declaration

`func &>>=(lhs: inout Int16, rhs: Int16)`

#### Declared In

`Int16`

, `FixedWidthInteger`

`&>>=`

operator performs a *masking shift*, where the value passed as
`rhs`

is masked to produce a value in the range `0..<lhs.bitWidth`

. The
shift is performed using this masked value.

`x`

as an instance of `UInt8`

, an 8-bit,
unsigned integer type. If you use `2`

as the right-hand-side value in an
operation on `x`

, the shift amount requires no masking.

```
var x: UInt8 = 30 // 0b00011110
x &>>= 2
// x == 7 // 0b00000111
```

`19`

as `rhs`

, the operation first bitmasks `rhs`

to
`3`

, and then uses that masked value as the number of bits to shift `lhs`

.

```
var y: UInt8 = 30 // 0b00011110
y &>>= 19
// y == 3 // 0b00000011
```

**Parameters:**
**lhs:** The value to shift.
**rhs:** The number of bits to shift `lhs`

to the right. If `rhs`

is
outside the range `0..<lhs.bitWidth`

, it is masked to produce a
value within that range.

#### Declaration

`func &>>=(lhs: inout Int32, rhs: Int32)`

#### Declared In

`Int32`

, `FixedWidthInteger`

`&>>=`

operator performs a *masking shift*, where the value passed as
`rhs`

is masked to produce a value in the range `0..<lhs.bitWidth`

. The
shift is performed using this masked value.

`x`

as an instance of `UInt8`

, an 8-bit,
unsigned integer type. If you use `2`

as the right-hand-side value in an
operation on `x`

, the shift amount requires no masking.

```
var x: UInt8 = 30 // 0b00011110
x &>>= 2
// x == 7 // 0b00000111
```

`19`

as `rhs`

, the operation first bitmasks `rhs`

to
`3`

, and then uses that masked value as the number of bits to shift `lhs`

.

```
var y: UInt8 = 30 // 0b00011110
y &>>= 19
// y == 3 // 0b00000011
```

**Parameters:**
**lhs:** The value to shift.
**rhs:** The number of bits to shift `lhs`

to the right. If `rhs`

is
outside the range `0..<lhs.bitWidth`

, it is masked to produce a
value within that range.

#### Declaration

`func &>>=(lhs: inout Int64, rhs: Int64)`

#### Declared In

`Int64`

, `FixedWidthInteger`

`&>>=`

operator performs a *masking shift*, where the value passed as
`rhs`

is masked to produce a value in the range `0..<lhs.bitWidth`

. The
shift is performed using this masked value.

`x`

as an instance of `UInt8`

, an 8-bit,
unsigned integer type. If you use `2`

as the right-hand-side value in an
operation on `x`

, the shift amount requires no masking.

```
var x: UInt8 = 30 // 0b00011110
x &>>= 2
// x == 7 // 0b00000111
```

`19`

as `rhs`

, the operation first bitmasks `rhs`

to
`3`

, and then uses that masked value as the number of bits to shift `lhs`

.

```
var y: UInt8 = 30 // 0b00011110
y &>>= 19
// y == 3 // 0b00000011
```

**Parameters:**
**lhs:** The value to shift.
**rhs:** The number of bits to shift `lhs`

to the right. If `rhs`

is
outside the range `0..<lhs.bitWidth`

, it is masked to produce a
value within that range.

#### Declaration

`func &>>=(lhs: inout UInt, rhs: UInt)`

#### Declared In

`UInt`

, `FixedWidthInteger`

`&>>=`

operator performs a *masking shift*, where the value passed as
`rhs`

is masked to produce a value in the range `0..<lhs.bitWidth`

. The
shift is performed using this masked value.

`x`

as an instance of `UInt8`

, an 8-bit,
unsigned integer type. If you use `2`

as the right-hand-side value in an
operation on `x`

, the shift amount requires no masking.

```
var x: UInt8 = 30 // 0b00011110
x &>>= 2
// x == 7 // 0b00000111
```

`19`

as `rhs`

, the operation first bitmasks `rhs`

to
`3`

, and then uses that masked value as the number of bits to shift `lhs`

.

```
var y: UInt8 = 30 // 0b00011110
y &>>= 19
// y == 3 // 0b00000011
```

**Parameters:**
**lhs:** The value to shift.
**rhs:** The number of bits to shift `lhs`

to the right. If `rhs`

is
outside the range `0..<lhs.bitWidth`

, it is masked to produce a
value within that range.

#### Declaration

`func &>>=(lhs: inout UInt8, rhs: UInt8)`

#### Declared In

`UInt8`

, `FixedWidthInteger`

`&>>=`

operator performs a *masking shift*, where the value passed as
`rhs`

is masked to produce a value in the range `0..<lhs.bitWidth`

. The
shift is performed using this masked value.

`x`

as an instance of `UInt8`

, an 8-bit,
unsigned integer type. If you use `2`

as the right-hand-side value in an
operation on `x`

, the shift amount requires no masking.

```
var x: UInt8 = 30 // 0b00011110
x &>>= 2
// x == 7 // 0b00000111
```

`19`

as `rhs`

, the operation first bitmasks `rhs`

to
`3`

, and then uses that masked value as the number of bits to shift `lhs`

.

```
var y: UInt8 = 30 // 0b00011110
y &>>= 19
// y == 3 // 0b00000011
```

**Parameters:**
**lhs:** The value to shift.
**rhs:** The number of bits to shift `lhs`

to the right. If `rhs`

is
outside the range `0..<lhs.bitWidth`

, it is masked to produce a
value within that range.

#### Declaration

`func &>>=(lhs: inout UInt16, rhs: UInt16)`

#### Declared In

`UInt16`

, `FixedWidthInteger`

`&>>=`

operator performs a *masking shift*, where the value passed as
`rhs`

is masked to produce a value in the range `0..<lhs.bitWidth`

. The
shift is performed using this masked value.

`x`

as an instance of `UInt8`

, an 8-bit,
unsigned integer type. If you use `2`

as the right-hand-side value in an
operation on `x`

, the shift amount requires no masking.

```
var x: UInt8 = 30 // 0b00011110
x &>>= 2
// x == 7 // 0b00000111
```

`19`

as `rhs`

, the operation first bitmasks `rhs`

to
`3`

, and then uses that masked value as the number of bits to shift `lhs`

.

```
var y: UInt8 = 30 // 0b00011110
y &>>= 19
// y == 3 // 0b00000011
```

**Parameters:**
**lhs:** The value to shift.
**rhs:** The number of bits to shift `lhs`

to the right. If `rhs`

is
outside the range `0..<lhs.bitWidth`

, it is masked to produce a
value within that range.

#### Declaration

`func &>>=(lhs: inout UInt32, rhs: UInt32)`

#### Declared In

`UInt32`

, `FixedWidthInteger`

`&>>=`

operator performs a *masking shift*, where the value passed as
`rhs`

is masked to produce a value in the range `0..<lhs.bitWidth`

. The
shift is performed using this masked value.

`x`

as an instance of `UInt8`

, an 8-bit,
unsigned integer type. If you use `2`

as the right-hand-side value in an
operation on `x`

, the shift amount requires no masking.

```
var x: UInt8 = 30 // 0b00011110
x &>>= 2
// x == 7 // 0b00000111
```

`19`

as `rhs`

, the operation first bitmasks `rhs`

to
`3`

, and then uses that masked value as the number of bits to shift `lhs`

.

```
var y: UInt8 = 30 // 0b00011110
y &>>= 19
// y == 3 // 0b00000011
```

**Parameters:**
**lhs:** The value to shift.
**rhs:** The number of bits to shift `lhs`

to the right. If `rhs`

is
outside the range `0..<lhs.bitWidth`

, it is masked to produce a
value within that range.

#### Declaration

`func &>>=(lhs: inout UInt64, rhs: UInt64)`

#### Declared In

`UInt64`

, `FixedWidthInteger`

Calculates the result of shifting a value's binary representation the specified number of digits to the right, masking the shift amount to the type's bit width, and stores the result in the left-hand-side variable.

The

`&>>=`

operator performs amasking shift, where the value passed as`rhs`

is masked to produce a value in the range`0..<lhs.bitWidth`

. The shift is performed using this masked value.The following example defines

`x`

as an instance of`UInt8`

, an 8-bit, unsigned integer type. If you use`2`

as the right-hand-side value in an operation on`x`

, the shift amount requires no masking.However, if you use

`19`

as`rhs`

, the operation first bitmasks`rhs`

to`3`

, and then uses that masked value as the number of bits to shift`lhs`

.Parameters:lhs:The value to shift.rhs:The number of bits to shift`lhs`

to the right. If`rhs`

is outside the range`0..<lhs.bitWidth`

, it is masked to produce a value within that range.## Declaration

`func &>>=(lhs: inout Int, rhs: Int)`

## Declared In

`Int`

,`FixedWidthInteger`