The smallest value that can be represented by this integer type.

Returns

• [u8] - The smallest u8 value.

Examples

fn foo() {
    let val = u8::min();
    assert(val == 0u8);
}

The largest value that can be represented by this integer type,
28 - 1.

Returns

• [u8] - The largest u8 value.

Examples

fn foo() {
    let val = u8::max();
    assert(val == 255u8);
}

The size of this integer type in bits.

Returns

• [u64] - The number of bits for a u8.

Examples

fn foo() {
    let bits = u8::bits();
    assert(bits == 8);
}

Returns

• [u8] -> The zero value for the u8 type.

Examples

fn foo() {
    let zero_u8 = u8::zero();
    assert(zero_u8 == 0u8);
}

Extends a u8 to a u16.

Returns

• [u16] - The converted u8 value.

Examples

fn foo() {
    let val = 2u8;
    let result = val.as_u16();
    assert(result == 2u16);
}

Extends a u8 to a u32.

Returns

• [u32] - The converted u8 value.

Examples

fn foo() {
    let val = 2u8;
    let result = val.as_u32();
    assert(result == 2u32);
}

Extends a u8 to a u64.

Returns

• [u64] - The converted u8 value.

Examples

fn foo() {
    let val = 2u8;
    let result = val.as_u64();
    assert(result == 2);
}

Extends a u8 to a u256.

Returns

• [u256] - The converted u8 value.

Examples

fn foo() {
    let val = 2u8;
    let result = val.as_u256();
    assert(result == 0x0000000000000000000000000000000000000000000000000000000000000002u256);
}

Evaluates if two values of the same type are not equal.

Additional Information

This function is inherited when eq() is implemented.

Arguments

• other: [Self] - The value of the same type.

Returns

• [bool] - true if the two values are not equal, otherwise false.

Examples

struct MyStruct {
    val: u64,
}

impl Eq for MyStruct {
    fn eq(self, other: Self) -> bool {
         self.val == other.val
    }
}

fn foo() {
    let struct1 = MyStruct { val: 10 };
    let struct2 = MyStruct { val: 2 };
    let result = struct1 != struct2;
    assert(result);
}

Evaluates if one value of the same type is greater or equal to than another.

Additional Information

This trait requires that the Ord and Eq traits are implemented.

Arguments

• other: [Self] - The value of the same type.

Returns

• [bool] - true if self is greater than or equal to other, otherwise false.

Examples

struct MyStruct {
    val: u64,
}

impl Eq for MyStruct {
    fn eq(self, other: Self) -> bool {
        self.val == other.val
    }
}

impl Ord for MyStruct {
    fn gt(self, other: Self) -> bool {
        self.val > other.val
    }
}

impl OrdEq for MyStruct {}

fn foo() {
    let struct1 = MyStruct { val: 10 };
    let struct2 = MyStruct { val: 10 };
    let result = struct1 >= struct2;
    assert(result);
}

Evaluates if one value of the same type is less or equal to than another.

Additional Information

This trait requires that the Ord and Eq traits are implemented.

Arguments

• other: [Self] - The value of the same type.

Returns

• [bool] - true if self is less than or equal to other, otherwise false.

Examples

struct MyStruct {
    val: u64,
}

impl Eq for MyStruct {
    fn eq(self, other: Self) -> bool {
        self.val == other.val
    }
}

impl Ord for MyStruct {
    fn lt(self, other: Self) -> bool {
        self.val < other.val
    }
}

impl OrdEq for MyStruct {}

fn foo() {
    let struct1 = MyStruct { val: 10 };
    let struct2 = MyStruct { val: 10 };
    let result = struct1 <= struct2;
    assert(result);
}