aiken/bytearray

Functions

compare(left: ByteArray, right: ByteArray) -> Ordering

Compare two bytearrays lexicographically.

bytearray.compare(#"00", #"FF") == Less
bytearray.compare(#"42", #"42") == Equal
bytearray.compare(#"FF", #"00") == Greater

concat(left: ByteArray, right: ByteArray) -> ByteArray

Combine two ByteArray together.

bytearray.concat(left: #[1, 2, 3], right: #[4, 5, 6]) == #[1, 2, 3, 4, 5, 6]

drop(self: ByteArray, n: Int) -> ByteArray

Returns the suffix of a ByteArray after n elements.

bytearray.drop(#[1, 2, 3], n: 2) == #[3]

foldl(self: ByteArray, zero: result, with: fn(Int, result) -> result) -> result

Left-fold over bytes of a ByteArray. Note that every byte given to the callback function is comprised between 0 and 255.

bytearray.foldl(#"acab", 0, fn(byte, acc) { acc * 256 + byte }) == 44203
bytearray.foldl(#[1, 2, 3], #"", flip(bytearray.push)) == #[3, 2, 1]

foldr(self: ByteArray, zero: result, with: fn(Int, result) -> result) -> result

Right-fold over bytes of a ByteArray. Note that every byte given to the callback function is comprised between 0 and 255.

bytearray.foldr(#"acab", 0, fn(byte, acc) { acc * 256 + byte }) == 43948
bytearray.foldl(#[1, 2, 3], #"", flip(bytearray.push)) == #[1, 2, 3]

from_string(str: String) -> ByteArray

Convert a String into a ByteArray.

bytearray.from_string(@"ABC") == #"414243"

index_of(self: ByteArray, bytes: ByteArray) -> Option<(Int, Int)>

Search the start and end positions of a sub-array in a ByteArray.

bytearray.index_of("Hello, World!", "World") == Some((7, 11))
bytearray.index_of("Hello, World!", "foo") == None
bytearray.index_of("Hello, World!", "!") == Some((12, 12))
bytearray.index_of("Hello, World!", "o") == Some((4, 4))
bytearray.index_of("Hello, World!", "Hello, World!") == Some((0, 12))

is_empty(self: ByteArray) -> Bool

Returns True when the given ByteArray is empty.

bytearray.is_empty(#"") == True
bytearray.is_empty(#"00ff") == False

length(self: ByteArray) -> Int

Returns the number of bytes in a ByteArray.

bytearray.length(#[1, 2, 3]) == 3

push(self: ByteArray, byte: Int) -> ByteArray

Add a byte element in front of a ByteArray. When the given byte is greater than 255, it wraps-around. So 256 is mapped to 0, 257 to 1, and so forth.

bytearray.push(#"", 0) == #"00"
bytearray.push(#"0203", 1) == #"010203"
bytearray.push(#"0203", 257) == #"010203"

reduce(self: ByteArray, zero: result, with: fn(result, Int) -> result) -> result

Reduce bytes in a ByteArray from left to right using the accumulator as left operand. Said differently, this is foldl with callback arguments swapped.

bytearray.reduce(#[1,2,3], #[], bytearray.push) == #[3, 2, 1]

slice(self: ByteArray, start: Int, end: Int) -> ByteArray

Extract a ByteArray as a slice of another ByteArray.

Indexes are 0-based and inclusive.

bytearray.slice(#[0, 1, 2, 3, 4, 5, 6], start: 1, end: 3) == #[1, 2, 3]

take(self: ByteArray, n: Int) -> ByteArray

Returns the n-length prefix of a ByteArray.

bytearray.take(#[1, 2, 3], n: 2) == #[1, 2]

test_bit(self: ByteArray, ix: Int) -> Bool

Checks whether a bit (Most-Significant-Bit first) is set in the given ‘ByteArray’.

For example, consider the following bytearray: #"8b765f". It can also be written as the following bits sequence:

8b765f
100010110111011001011111

And thus, we have:

test_bit(#"8b765f", 0) == True
test_bit(#"8b765f", 1) == False
test_bit(#"8b765f", 2) == False
test_bit(#"8b765f", 3) == False
test_bit(#"8b765f", 7) == True
test_bit(#"8b765f", 8) == False
test_bit(#"8b765f", 20) == True
test_bit(#"8b765f", 21) == True
test_bit(#"8b765f", 22) == True
test_bit(#"8b765f", 23) == True

to_hex(self: ByteArray) -> String

Encode a ByteArray as a hexidecimal String.

use aiken/bytearray

bytearray.to_hex("Hello world!") == @"48656c6c6f20776f726c6421"

to_string(self: ByteArray) -> String

Convert a ByteArray into a String.

bytearray.to_string(#"414243") == "ABC"
Search Document