bitty - v1.1.0

bitty/num

Numeric parsers for fixed-width integers, floats, and variable-length encodings. Includes single-byte (u8, i8) and multi-byte types with endianness control.

Types

Endian

</>

Byte order for multi-byte numeric parsers.

pub type Endian {
  BigEndian
  LittleEndian
}

Constructors 

  • BigEndian
  • LittleEndian

Values

f32

</> 
pub fn f32(endian: Endian) -> bitty.Parser(Float)

Parse a 32-bit IEEE 754 float with the given endianness.

f64

</> 
pub fn f64(endian: Endian) -> bitty.Parser(Float)

Parse a 64-bit IEEE 754 double with the given endianness.

i16

</> 
pub fn i16(endian: Endian) -> bitty.Parser(Int)

Parse a 16-bit signed integer (two’s complement) with the given endianness.

i32

</> 
pub fn i32(endian: Endian) -> bitty.Parser(Int)

Parse a 32-bit signed integer (two’s complement) with the given endianness.

i64

</> 
pub fn i64(endian: Endian) -> bitty.Parser(Int)

Parse a 64-bit signed integer (two’s complement) with the given endianness. On the JavaScript target, values outside the safe integer range (-2^53 + 1 to 2^53 - 1) may lose precision.

i8

</> 
pub fn i8() -> bitty.Parser(Int)

Parse a single byte as a signed integer (-128–127).

int_bytes_twos_complement

</> 
pub fn int_bytes_twos_complement(
  bytes count: Int,
) -> bitty.Parser(BitArray)

Read count bytes as a two’s complement signed integer BitArray, stripping redundant leading zero bytes while preserving the sign bit. Returns the normalized raw bytes, not a decoded Int. Useful for ASN.1 DER integer encoding.

u16

</> 
pub fn u16(endian: Endian) -> bitty.Parser(Int)

Parse a 16-bit unsigned integer with the given endianness.

let assert Ok(val) =
  bitty.run(num.u16(num.BigEndian), on: <<0x01, 0x00>>)
assert val == 256

u32

</> 
pub fn u32(endian: Endian) -> bitty.Parser(Int)

Parse a 32-bit unsigned integer with the given endianness.

u64

</> 
pub fn u64(endian: Endian) -> bitty.Parser(Int)

Parse a 64-bit unsigned integer with the given endianness. On the JavaScript target, values above 2^53 - 1 (9,007,199,254,740,991) may lose precision due to IEEE 754 double-precision limitations.

u8

</> 
pub fn u8() -> bitty.Parser(Int)

Parse a single byte as an unsigned integer (0–255).

uint_bytes

</> 
pub fn uint_bytes(bytes count: Int) -> bitty.Parser(BitArray)

Read count bytes as a raw BitArray representing an unsigned integer. Unlike bytes.take, this is intended for numeric byte sequences (e.g. ASN.1 DER integer encodings) where the bytes represent a single big-endian value.

var_u32

</> 
pub fn var_u32() -> bitty.Parser(Int)

Parse an LEB128-encoded unsigned 32-bit variable-length integer. Consumes at most 5 bytes.

let assert Ok(val) = bitty.run(num.var_u32(), on: <<0xAC, 0x02>>)
assert val == 300

var_u64

</> 
pub fn var_u64() -> bitty.Parser(Int)

Parse an LEB128-encoded unsigned 64-bit variable-length integer. Consumes at most 10 bytes. On the JavaScript target, values above 2^53 - 1 (9,007,199,254,740,991) may lose precision due to IEEE 754 double-precision limitations.

✨ Search Document