## Operator: <<

``` operator << { associativity precedence }```

### Declarations

func << <Other>(_: Self, rhs: Other)

Returns the result of shifting a value's binary representation the specified number of digits to the left.

The `<<` operator performs a smart shift, which defines a result for a shift of any value.

• Using a negative value for `rhs` performs a right shift using `abs(rhs)`.
• Using a value for `rhs` that is greater than or equal to the bit width of `lhs` is an overshift, resulting in zero.
• Using any other value for `rhs` performs a left shift on `lhs` by that amount.

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 value is shifted left by two bits.

``````let x: UInt8 = 30                 // 0b00011110
let y = x << 2
// y == 120                       // 0b01111000``````

If you use `11` as `rhs`, `x` is overshifted such that all of its bits are set to zero.

``````let z = x << 11
// z == 0                         // 0b00000000``````

Using a negative value as `rhs` is the same as performing a right shift with `abs(rhs)`.

``````let a = x << -3
// a == 3                         // 0b00000011
let b = x >> 3
// b == 3                         // 0b00000011``````

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

#### Declaration

`func <<<Other>(lhs: Self, rhs: Other) -> Self where Other : BinaryInteger`

#### Declared In

`FixedWidthInteger`
func << <Other>(_: Self, rhs: Other)

Returns the result of shifting a value's binary representation the specified number of digits to the left.

The `<<` operator performs a smart shift, which defines a result for a shift of any value.

• Using a negative value for `rhs` performs a right shift using `abs(rhs)`.
• Using a value for `rhs` that is greater than or equal to the bit width of `lhs` is an overshift, resulting in zero.
• Using any other value for `rhs` performs a left shift on `lhs` by that amount.

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 value is shifted left by two bits.

``````let x: UInt8 = 30                 // 0b00011110
let y = x << 2
// y == 120                       // 0b01111000``````

If you use `11` as `rhs`, `x` is overshifted such that all of its bits are set to zero.

``````let z = x << 11
// z == 0                         // 0b00000000``````

Using a negative value as `rhs` is the same as performing a right shift with `abs(rhs)`.

``````let a = x << -3
// a == 3                         // 0b00000011
let b = x >> 3
// b == 3                         // 0b00000011``````

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

#### Declaration

`func <<<Other>(lhs: Self, rhs: Other) -> Self where Other : BinaryInteger`

#### Declared In

`FixedWidthInteger`
func << <Other>(_: Self, rhs: Other)

Returns the result of shifting a value's binary representation the specified number of digits to the left.

The `<<` operator performs a smart shift, which defines a result for a shift of any value.

• Using a negative value for `rhs` performs a right shift using `abs(rhs)`.
• Using a value for `rhs` that is greater than or equal to the bit width of `lhs` is an overshift, resulting in zero.
• Using any other value for `rhs` performs a left shift on `lhs` by that amount.

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 value is shifted left by two bits.

``````let x: UInt8 = 30                 // 0b00011110
let y = x << 2
// y == 120                       // 0b01111000``````

If you use `11` as `rhs`, `x` is overshifted such that all of its bits are set to zero.

``````let z = x << 11
// z == 0                         // 0b00000000``````

Using a negative value as `rhs` is the same as performing a right shift with `abs(rhs)`.

``````let a = x << -3
// a == 3                         // 0b00000011
let b = x >> 3
// b == 3                         // 0b00000011``````

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

#### Declaration

`func <<<Other>(lhs: Self, rhs: Other) -> Self where Other : BinaryInteger`

#### Declared In

`FixedWidthInteger`
func << <Other>(_: Self, rhs: Other)

Returns the result of shifting a value's binary representation the specified number of digits to the left.

The `<<` operator performs a smart shift, which defines a result for a shift of any value.

• Using a negative value for `rhs` performs a right shift using `abs(rhs)`.
• Using a value for `rhs` that is greater than or equal to the bit width of `lhs` is an overshift, resulting in zero.
• Using any other value for `rhs` performs a left shift on `lhs` by that amount.

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 value is shifted left by two bits.

``````let x: UInt8 = 30                 // 0b00011110
let y = x << 2
// y == 120                       // 0b01111000``````

If you use `11` as `rhs`, `x` is overshifted such that all of its bits are set to zero.

``````let z = x << 11
// z == 0                         // 0b00000000``````

Using a negative value as `rhs` is the same as performing a right shift with `abs(rhs)`.

``````let a = x << -3
// a == 3                         // 0b00000011
let b = x >> 3
// b == 3                         // 0b00000011``````

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

#### Declaration

`func <<<Other>(lhs: Self, rhs: Other) -> Self where Other : BinaryInteger`

#### Declared In

`FixedWidthInteger`
func << <Other>(_: Self, rhs: Other)

Returns the result of shifting a value's binary representation the specified number of digits to the left.

The `<<` operator performs a smart shift, which defines a result for a shift of any value.

• Using a negative value for `rhs` performs a right shift using `abs(rhs)`.
• Using a value for `rhs` that is greater than or equal to the bit width of `lhs` is an overshift, resulting in zero.
• Using any other value for `rhs` performs a left shift on `lhs` by that amount.

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 value is shifted left by two bits.

``````let x: UInt8 = 30                 // 0b00011110
let y = x << 2
// y == 120                       // 0b01111000``````

If you use `11` as `rhs`, `x` is overshifted such that all of its bits are set to zero.

``````let z = x << 11
// z == 0                         // 0b00000000``````

Using a negative value as `rhs` is the same as performing a right shift with `abs(rhs)`.

``````let a = x << -3
// a == 3                         // 0b00000011
let b = x >> 3
// b == 3                         // 0b00000011``````

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

#### Declaration

`func <<<Other>(lhs: Self, rhs: Other) -> Self where Other : BinaryInteger`

#### Declared In

`FixedWidthInteger`
func << <Other>(_: Self, rhs: Other)

Returns the result of shifting a value's binary representation the specified number of digits to the left.

The `<<` operator performs a smart shift, which defines a result for a shift of any value.

• Using a negative value for `rhs` performs a right shift using `abs(rhs)`.
• Using a value for `rhs` that is greater than or equal to the bit width of `lhs` is an overshift, resulting in zero.
• Using any other value for `rhs` performs a left shift on `lhs` by that amount.

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 value is shifted left by two bits.

``````let x: UInt8 = 30                 // 0b00011110
let y = x << 2
// y == 120                       // 0b01111000``````

If you use `11` as `rhs`, `x` is overshifted such that all of its bits are set to zero.

``````let z = x << 11
// z == 0                         // 0b00000000``````

Using a negative value as `rhs` is the same as performing a right shift with `abs(rhs)`.

``````let a = x << -3
// a == 3                         // 0b00000011
let b = x >> 3
// b == 3                         // 0b00000011``````

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

#### Declaration

`func <<<Other>(lhs: Self, rhs: Other) -> Self where Other : BinaryInteger`

#### Declared In

`FixedWidthInteger`
func << <Other>(_: Self, rhs: Other)

Returns the result of shifting a value's binary representation the specified number of digits to the left.

The `<<` operator performs a smart shift, which defines a result for a shift of any value.

• Using a negative value for `rhs` performs a right shift using `abs(rhs)`.
• Using a value for `rhs` that is greater than or equal to the bit width of `lhs` is an overshift, resulting in zero.
• Using any other value for `rhs` performs a left shift on `lhs` by that amount.

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 value is shifted left by two bits.

``````let x: UInt8 = 30                 // 0b00011110
let y = x << 2
// y == 120                       // 0b01111000``````

If you use `11` as `rhs`, `x` is overshifted such that all of its bits are set to zero.

``````let z = x << 11
// z == 0                         // 0b00000000``````

Using a negative value as `rhs` is the same as performing a right shift with `abs(rhs)`.

``````let a = x << -3
// a == 3                         // 0b00000011
let b = x >> 3
// b == 3                         // 0b00000011``````

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

#### Declaration

`func <<<Other>(lhs: Self, rhs: Other) -> Self where Other : BinaryInteger`

#### Declared In

`FixedWidthInteger`
func << <Other>(_: Self, rhs: Other)

Returns the result of shifting a value's binary representation the specified number of digits to the left.

The `<<` operator performs a smart shift, which defines a result for a shift of any value.

• Using a negative value for `rhs` performs a right shift using `abs(rhs)`.
• Using a value for `rhs` that is greater than or equal to the bit width of `lhs` is an overshift, resulting in zero.
• Using any other value for `rhs` performs a left shift on `lhs` by that amount.

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 value is shifted left by two bits.

``````let x: UInt8 = 30                 // 0b00011110
let y = x << 2
// y == 120                       // 0b01111000``````

If you use `11` as `rhs`, `x` is overshifted such that all of its bits are set to zero.

``````let z = x << 11
// z == 0                         // 0b00000000``````

Using a negative value as `rhs` is the same as performing a right shift with `abs(rhs)`.

``````let a = x << -3
// a == 3                         // 0b00000011
let b = x >> 3
// b == 3                         // 0b00000011``````

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

#### Declaration

`func <<<Other>(lhs: Self, rhs: Other) -> Self where Other : BinaryInteger`

#### Declared In

`FixedWidthInteger`
func << <Other>(_: Self, rhs: Other)

Returns the result of shifting a value's binary representation the specified number of digits to the left.

The `<<` operator performs a smart shift, which defines a result for a shift of any value.

• Using a negative value for `rhs` performs a right shift using `abs(rhs)`.
• Using a value for `rhs` that is greater than or equal to the bit width of `lhs` is an overshift, resulting in zero.
• Using any other value for `rhs` performs a left shift on `lhs` by that amount.

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 value is shifted left by two bits.

``````let x: UInt8 = 30                 // 0b00011110
let y = x << 2
// y == 120                       // 0b01111000``````

If you use `11` as `rhs`, `x` is overshifted such that all of its bits are set to zero.

``````let z = x << 11
// z == 0                         // 0b00000000``````

Using a negative value as `rhs` is the same as performing a right shift with `abs(rhs)`.

``````let a = x << -3
// a == 3                         // 0b00000011
let b = x >> 3
// b == 3                         // 0b00000011``````

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

#### Declaration

`func <<<Other>(lhs: Self, rhs: Other) -> Self where Other : BinaryInteger`

#### Declared In

`FixedWidthInteger`
func << <Other>(_: Self, rhs: Other)

Returns the result of shifting a value's binary representation the specified number of digits to the left.

The `<<` operator performs a smart shift, which defines a result for a shift of any value.

• Using a negative value for `rhs` performs a right shift using `abs(rhs)`.
• Using a value for `rhs` that is greater than or equal to the bit width of `lhs` is an overshift, resulting in zero.
• Using any other value for `rhs` performs a left shift on `lhs` by that amount.

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 value is shifted left by two bits.

``````let x: UInt8 = 30                 // 0b00011110
let y = x << 2
// y == 120                       // 0b01111000``````

If you use `11` as `rhs`, `x` is overshifted such that all of its bits are set to zero.

``````let z = x << 11
// z == 0                         // 0b00000000``````

Using a negative value as `rhs` is the same as performing a right shift with `abs(rhs)`.

``````let a = x << -3
// a == 3                         // 0b00000011
let b = x >> 3
// b == 3                         // 0b00000011``````

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

#### Declaration

`func <<<Other>(lhs: Self, rhs: Other) -> Self where Other : BinaryInteger`

#### Declared In

`FixedWidthInteger`