operator &>>= { associativity right precedence assignment } Declarations func &>>=(_: inout Int, rhs: Int) 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 Int, rhs: Int) Declared In Int, FixedWidthInteger func &>>=(_: inout Int8, rhs: Int8) 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 func &>>=(_: inout Int16, rhs: Int16) 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 func &>>=(_: inout Int32, rhs: Int32) 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 Int32, rhs: Int32) Declared In Int32, FixedWidthInteger func &>>=(_: inout Int64, rhs: Int64) 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 Int64, rhs: Int64) Declared In Int64, FixedWidthInteger func &>>=(_: inout UInt, rhs: UInt) 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 UInt, rhs: UInt) Declared In UInt, FixedWidthInteger func &>>=(_: inout UInt8, rhs: UInt8) 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 UInt8, rhs: UInt8) Declared In UInt8, FixedWidthInteger func &>>=(_: inout UInt16, rhs: UInt16) 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 UInt16, rhs: UInt16) Declared In UInt16, FixedWidthInteger func &>>=(_: inout UInt32, rhs: UInt32) 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 UInt32, rhs: UInt32) Declared In UInt32, FixedWidthInteger func &>>=(_: inout UInt64, rhs: UInt64) 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 UInt64, rhs: UInt64) Declared In UInt64, FixedWidthInteger