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:
8 | b | 7 | 6 | 5 | f |
|---|---|---|---|---|---|
1000 | 1011 | 0111 | 0110 | 0101 | 1111 |
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"