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

### Declarations

Returns the result of shifting a value's binary representation the specified number of digits to the left, 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 used 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 == 120 // 0b01111000
```

However, if you pass `19`

as `rhs`

, the method 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 == 240 // 0b11110000
```

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

to the left. 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`

Returns the result of shifting a value's binary representation the specified number of digits to the left, 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 used 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 == 120 // 0b01111000
```

However, if you pass `19`

as `rhs`

, the method 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 == 240 // 0b11110000
```

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

to the left. 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 used 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 == 120 // 0b01111000
```

`19`

as `rhs`

, the method 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 == 240 // 0b11110000
```

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

to the left. 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 used 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 == 120 // 0b01111000
```

`19`

as `rhs`

, the method 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 == 240 // 0b11110000
```

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

to the left. 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 used 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 == 120 // 0b01111000
```

`19`

as `rhs`

, the method 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 == 240 // 0b11110000
```

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

to the left. 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 used 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 == 120 // 0b01111000
```

`19`

as `rhs`

, the method 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 == 240 // 0b11110000
```

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

to the left. 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 used 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 == 120 // 0b01111000
```

`19`

as `rhs`

, the method 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 == 240 // 0b11110000
```

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

to the left. 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 used 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 == 120 // 0b01111000
```

`19`

as `rhs`

, the method 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 == 240 // 0b11110000
```

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

to the left. 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 used 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 == 120 // 0b01111000
```

`19`

as `rhs`

, the method 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 == 240 // 0b11110000
```

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

to the left. 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`

Returns the result of shifting a value's binary representation the specified number of digits to the left, 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 used 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 pass

`19`

as`rhs`

, the method 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 left. 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`