Module

pooka/bit_array

src/pooka/bit_array.pooka

A bit array is a parcel whose wrapping need not end on a byte boundary.

Build bitstrings, concatenate parts and convert UTF-8 text. Size operations distinguish bits from bytes. Byte slicing and text decoding report their public error variants for the supported invalid-input cases.

import pooka/bit_array

assert bit_array.bit_size(<<1:size(3)>>) == 3

enum

BitArrayError

src/pooka/bit_array.pooka:17

enum BitArrayError

variant

OutOfRange

src/pooka/bit_array.pooka:18

BitArrayError.OutOfRange

variant

InvalidUtf8

src/pooka/bit_array.pooka:19

BitArrayError.InvalidUtf8

function

byte_size

src/pooka/bit_array.pooka:42

byte_size(bits: BitArray) -> Int

INFERREDfn(BitArray) -> Int

Return the runtime byte size; a partial final byte still occupies a byte of size.

import pooka/bit_array

assert bit_array.byte_size(<<1:size(3)>>) == 1

function

bit_size

src/pooka/bit_array.pooka:53

bit_size(bits: BitArray) -> Int

INFERREDfn(BitArray) -> Int

Count every bit, including a non-byte-aligned suffix.

import pooka/bit_array

assert bit_array.bit_size(<<1:size(3)>>) == 3

function

is_empty

src/pooka/bit_array.pooka:64

is_empty(bits: BitArray) -> Bool

INFERREDfn(BitArray) -> Bool

Ask whether there are no bits.

import pooka/bit_array

assert bit_array.is_empty(<<>>)

function

append

src/pooka/bit_array.pooka:75

append(first: BitArray, second: BitArray) -> BitArray

INFERREDfn(BitArray, BitArray) -> BitArray

Concatenate two bit arrays, preserving all bits in order.

import pooka/bit_array

assert bit_array.append(<<1>>, <<2>>) == <<1, 2>>

function

concat

src/pooka/bit_array.pooka:86

concat(parts: List(BitArray)) -> BitArray

INFERREDfn(List(BitArray)) -> BitArray

Concatenate all parts, including non-byte-aligned pieces.

import pooka/bit_array

assert bit_array.concat([<<1>>, <<2>>]) == <<1, 2>>

function

slice

src/pooka/bit_array.pooka:98

slice(bits: BitArray, start: Int, length: Int) -> Result(
  BitArray,
  BitArrayError
)

INFERREDfn(BitArray, Int, Int) -> Result(BitArray, pooka/bit_array.BitArrayError)

Select a byte range from a whole-byte array. Invalid bounds return OutOfRange.

import pooka/bit_array

assert bit_array.slice(<<1, 2, 3>>, 1, 1) == Ok(<<2>>)

function

from_string

src/pooka/bit_array.pooka:115

from_string(text: String) -> BitArray

INFERREDfn(String) -> BitArray

Keep the UTF-8 bytes of a Pooka string.

import pooka/bit_array

assert bit_array.from_string("A") == <<65>>

function

to_string

src/pooka/bit_array.pooka:126

to_string(bits: BitArray) -> Result(String, BitArrayError)

INFERREDfn(BitArray) -> Result(String, pooka/bit_array.BitArrayError)

Decode UTF-8 bytes, returning InvalidUtf8 when decoding fails.

import pooka/bit_array

assert bit_array.to_string(<<65>>) == Ok("A")