Macro for creating ASCII bar literals.
# b {hello} == b#hello
# b {} == b#{}
# b {123} == b#123
Macro for creating hexadecimal bar literals.
# x deadbeef == x#deadbeef
# x 00 == x#00
# x {} == b#{}
(padBar p)
> p : Pad a
> Bar a
Converts a pad to a bar, adding zeroes to make it into whole bytes if necessary.
padBar p#11111111 == x#ff
padBar p#111111111 == x#ff01
padBar p#1 == x#01
Checks if a value is a bar (byte array).
isBar b#hello == 1
isBar x#deadbeef == 1
isBar 42 == 0
Returns an empty bar.
emptyBar == b#{}
barLen emptyBar == 0
barIsEmpty emptyBar == 1
Checks if a bar is empty.
barIsEmpty b#{} == 1
barIsEmpty b#a == 0
barIsEmpty x#00 == 0
Returns the number of bytes needed to represent a natural number.
byteWidth 0 == 0
byteWidth 255 == 1
byteWidth 256 == 2
Returns the number of trailing zero bytes in a bar's internal representation.
barTrail 0x1ff == 0
barTrail 0x100ff == 1
barTrail 0x10000ff == 2
Encodes a natural number into a bar representation.
barEnc 0 0 == 1
barEnc 0 1 == 257
barEnc 0 255 == 511
Decodes a bar representation back into a natural number.
barDec 1 == 0
barDec 257 == 1
barDec 511 == 255
Creates a bar from a natural number and a trailing zero count.
mkBar 0 0 == b#{}
mkBar 0 1 == x#01
mkBar 1 255 == x#ff00
Creates a bar from a natural number.
natBar 0 == b#{}
natBar 1 == x#01
natBar 255 == x#ff
Converts a bar to its natural number representation.
barNat b#{} == 0
barNat x#01 == 1
barNat x#ff == 255
Returns the length of a bar in bytes.
barLen b#{} == 0
barLen b#hello == 5
barLen x#deadbeef == 4
Returns the byte at a given index in a bar.
barIdx 0 b#hello == %h
barIdx 1 b#hello == %e
barIdx 4 b#hello == %o
Creates a bar of a specific size from a natural number.
natToSizedBar 4 0x11223344 == x#44332211
natToSizedBar 2 0x1122 == x#2211
natToSizedBar 4 0x11 == x#11000000
Creates a bar containing a single byte.
barSing %a == b#a
barSing 0 == x#00
barSing 255 == x#ff
Creates a bar containing two bytes.
barDuo %a %b == b#ab
barDuo 0 1 == x#0001
barDuo 255 254 == x#fffe
Returns the number of trailing zero bytes in a row.
zEnd [1 2 3 0 0] == 2
zEnd [0 0 0] == 3
zEnd [1 2 3] == 0
Removes trailing zero bytes from a row.
stripZEnd [1 2 3 0 0] == [1 2 3]
stripZEnd [0 0 0] == []
stripZEnd [1 2 3] == [1 2 3]
Converts a number to an 8-bit value (0-255).
w8 255 == 255
w8 256 == 0
w8 257 == 1
Creates a bar from a row of bytes.
bytesBar [104 101 108 108 111] == b#hello
bytesBar [0 255 1] == x#00ff01
bytesBar [] == b#{}
Generates a bar by applying a function to each index.
barGen 3 (mul 2) == x#000204
barGen 4 id == x#00010203
barGen 0 id == b#{}
Creates a bar by repeating a byte value.
barRep 3 %a == b#aaa
barRep 2 0 == x#0000
barRep 0 %x == b#{}
Gets the byte at a specific index in a bar.
barGet b#hello 0 == %h
barGet b#hello 4 == %o
barGet x#deadbeef 2 == 190 ; [222 173 190 239]
Converts a bar to a row of bytes.
barBytes b#hello == [%h %e %l %l %o]
barBytes x#deadbeef == [222 173 190 239]
barBytes b#{} == []
Left-associative fold over a bar.
barFoldl add 0 b#abc == 294
barFoldl add 1 b#{} == 1
barFoldl mul 1 x#010203 == 6
Right-associative fold over a bar.
barFoldr add 0 b#abc == 294
barFoldr (_ acc & inc acc) 0 b#hello == 5
barFoldr mul 1 x#010203 == 6
Checks if any byte in the bar satisfies a predicate.
barAny (eql %a) b#hello == 0
barAny (eql %h) b#hello == 1
barAny (gte 200) x#deadbeef == 1
Checks if all bytes in the bar satisfy a predicate.
barAll (gte %a) b#hello == 0
barAll (eql %a) b#aaaaa == 1
barAll (lte 200) x#deadbeef == 0
Concatenates two bars.
barWeld b#hello b#world == b#helloworld
barWeld x#dead x#beef == x#deadbeef
barWeld b#{} b#abc == b#abc
Concatenates a row of bars.
barCat [b#hello b#world b#{!}] == b#{helloworld!}
barCat [x#de x#ad x#be x#ef] == x#deadbeef
barCat [b#{} b#a b#{} b#b] == b#ab
Concatenates a list of bars.
barCatList (CONS b#hello (CONS b#world NIL)) == b#helloworld
barCatList (CONS x#dead (CONS x#beef NIL)) == x#deadbeef
barCatList NIL == b#{}
Maps a function over a bar and concatenates the results.
barCatMap (x & barRep 2 x) b#abc == b#aabbcc
barCatMap (x & barFromRow [x x]) b#123 == b#112233
barCatMap (const b#{-}) b#abc == b#{---}
Intersperses a separator bar between the elements of a row of bars.
barIntercalate b#_ [b#a b#b b#c] == b#a_b_c
barIntercalate x#00 [x#11 x#22 x#33] == x#110022003300
barIntercalate b#{} [b#hello b#world] == b#helloworld
Intersperses a separator bar between the elements of a list of bars.
barIntercalateList b#_ ~[b#a b#b b#c] == b#a_b_c
barIntercalateList x#00 (CONS x#11 (CONS x#22 (CONS x#33 NIL))) == x#110022003300
barIntercalateList b#{} (CONS b#hello (CONS b#world NIL)) == b#helloworld
Creates a bar from a hexadecimal string.
barFromHex {deadbeef} == x#deadbeef
barFromHex {68656C6C6F} == b#hello
barFromHex {} == b#{}
Returns the internal pad representation of a bar.
barPad b#a == p#10000110
barPad x#deadbeef == p#01111011101101010111110111110111
barPad b#{} == p#{}
Takes the first n bytes from a bar.
barTake 3 b#hello == b#hel
barTake 5 b#hi == b#hi
barTake 0 b#world == b#{}
Drops the first n bytes from a bar.
barDrop 3 b#hello == b#lo
barDrop 5 b#hi == b#{}
barDrop 0 b#world == b#world
Takes a slice of a bar from a starting index with a given length.
barSlice 1 3 b#hello == b#ell
barSlice 0 2 x#deadbeef == x#dead
barSlice 4 1 b#hello == b#o
Converts a slice of a bar to a natural number.
barSliceToNat 0 4 x#deadbeef == 0xdeadbeef
barSliceToNat 1 2 x#deadbeef == 0xadbe
barSliceToNat 3 1 b#hello == 0x6f
Converts a tree-like structure of bars to a flat list of bars.
barTreeToList b#hello == [b#hello 0]
barTreeToList [b#a b#b b#c] == [b#a [b#b [b#c 0]]]
barTreeToList (0 [[b#foo] b#bar b#baz]) == [b#foo [b#bar [b#baz 0]]]
Flattens a tree-like structure of bars into a single bar.
barFlat b#hello == b#hello
barFlat [b#a b#b b#c] == b#abc
barFlat (0 [[b#foo] b#bar b#baz]) == b#foobarbaz
Checks if a bar contains a specific byte.
barHas %h b#hello == 1
barHas %x b#hello == 0
barHas 0xde x#deadbeef == 1
Converts a bar to a row of bytes (alias for barBytes).
barToRow b#hello == [%h %e %l %l %o] ; [104 101 108 108 111]
barToRow x#deadbeef == [222 173 190 239]
barToRow b#{} == []
Converts a bar to a row of bytes (alias for barBytes).
rowFromBar b#hello == [%h %e %l %l %o]
rowFromBar x#deadbeef == [222 173 190 239]
rowFromBar b#{} == []
Converts a bar to a list of bytes.
barToList b#abc == [%a [%b [%c 0]]]
barToList x#1234 == [18 [52 0]] ; [0x12 [0x34 0]]
barToList b#{} == 0
Creates a bar from a row of bytes.
barFromRow [104 101 108 108 111] == b#hello
barFromRow [0xde 0xad 0xbe 0xef] == x#deadbeef
barFromRow [] == b#{}
Creates a bar from a list of bytes.
barFromList [%a [%b [%c 0]]] == b#abc
barFromList [0x12 [0x34 0]] == x#1234
barFromList 0 == b#{}
Creates a bar from a reversed list of bytes.
barFromListRev [%c [%b [%a 0]]] == b#abc
barFromListRev [0x34 [0x12 0]] == x#1234
barFromListRev 0 == b#{}
Creates a bar from a row of bytes (alias for barFromRow).
rowToBar [104 101 108 108 111] == b#hello
rowToBar [0xde 0xad 0xbe 0xef] == x#deadbeef
rowToBar [] == b#{}
Applies a function to each byte in a bar.
barMap (add 1) b#abc == b#bcd
barMap (mul 2) x#0102 == x#0204
barMap (const 0) b#hello == x#0000000000
Keeps only the bytes in a bar that satisfy a predicate.
barFilter (neq %l) b#hello == b#heo
barFilter (gte 0xc0) x#deadbeef == x#adbe
barFilter (const 1) b#abc == b#abc
Finds the index of the first byte satisfying a predicate.
barFindIndex (eql %l) b#hello == (0 2) ; SOME 2
barFindIndex (gte 0xc0) x#deadbeef == (0 1) ; SOME 1
barFindIndex (const 0) b#abc == 0 ; NONE
Finds the index of the first byte satisfying a predicate, starting from an offset.
barFindIndexOff (eql %l) 1 b#hello == 2
barFindIndexOff (gte 0xc0) 1 x#deadbeef == 1
barFindIndexOff (const 0) 0 b#abc == 3
Finds the index of the first occurrence of a byte.
barElemIndex %l b#hello == (0 2) ; SOME 2
barElemIndex 0xde x#deadbeef == (0 0) ; SOME 0
barElemIndex %x b#abc == 0 ; NONE
Finds the index of the first occurrence of a byte, starting from an offset.
barElemIndexOff %l 1 b#hello == 2
barElemIndexOff 0xde 1 x#deadbeef == 4
barElemIndexOff %x 0 b#abc == 3
Finds the index of the last occurrence of a byte.
barElemIndexEnd %l b#hello == (0 3) ; SOME 3
barElemIndexEnd 0xef x#deadbeef == (0 3) ; SOME 3
barElemIndexEnd %x b#abc == (0 0) ; NONE
Splits a bar at a given index.
barSplitAt 2 b#hello == [b#he b#llo]
barSplitAt 4 x#deadbeef == [x#deadbeef b#{}]
barSplitAt 1 b#abc == [b#a b#bc]
Splits a bar at the first occurrence of a byte.
barSplitOne %l b#hello == [b#he b#lo]
barSplitOne 0xad x#deadbeef == [x#de x#beef]
barSplitOne %x b#abc == [b#abc b#{}]
Splits a bar at the first occurrence of a byte satisfying a predicate.
barSplitOneWith (eql %l) b#hello == [b#he b#lo]
barSplitOneWith (gte 0xc0) x#deadbeef == [x#de x#beef]
barSplitOneWith (const 0) b#abc == [b#abc b#{}]
Splits a bar at all occurrences of bytes satisfying a predicate.
barSplitWith (eql %l) b#hello == [b#he [b#{} [b#o 0]]]
barSplitWith (gte 0xc0) x#deadbeef == [x#de [b#{} [x#ef 0]]]
barSplitWith (const 0) b#abc == [b#abc 0]
Splits a bar at all occurrences of a specific byte.
barSplit %l b#hello == [b#he [b#{} [b#o 0]]]
barSplit 0xad x#deadbeef == [x#de [x#beef 0]]
barSplit %x b#abc == [b#abc 0]
Counts the number of leading bytes until a predicate fails.
barCountHeadMatching (eql %h) b#hello == (0 1) ; SOME 1
barCountHeadMatching (neq 0xbe) x#deadbeef == (0 2) ; SOME 2
barCountHeadMatching (neq %d) b#abc == 0 ; NONE
Drops leading bytes from a bar while they satisfy a predicate.
barDropWhile (eql %h) b#hello == b#ello
barDropWhile (lte 0xbe) x#deadbeef == x#adbeef
barDropWhile (const 0) b#abc == b#abc
Takes leading bytes from a bar while they satisfy a predicate.
barTakeWhile (eql %h) b#hello == b#h
barTakeWhile (lte 0xbe) x#deadbeef == x#de
barTakeWhile (const 1) b#abc == b#abc
A bar containing the hexadecimal digits (0-9, a-f).
hexAlphabet == b#0123456789abcdef
barLen hexAlphabet == 16
barIdx 10 hexAlphabet == %a
Converts a number (0-15) to its hexadecimal character representation.
hexChar 0 == 48
hexChar 9 == 57
hexChar 15 == %f
Converts a byte to its two-character hexadecimal representation.
byteToHex 0 == b#00
byteToHex 255 == b#ff
byteToHex 171 == b#ab
Converts a bar to its hexadecimal string representation.
barToHex b#hello == b#68656c6c6f
barToHex x#deadbeef == b#deadbeef
barToHex b#{} == b#{}
Parses a bar literal from a Rex expression.
readBarLit '(b#hello) v2 id == b#hello
readBarLit '(x#deadbeef) v2 id == x#deadbeef
readBarLit '(b#{}) v2 id == b#{}
Converts a bar to its Rex literal representation.
showBarLit b#hello == b#{hello}
showBarLit x#deadbeef == x#{deadbeef}
showBarLit b#{} == b#{}
Parses a bar containing an ascii string as a hexadecimal number, passing the corresponding Nat to a continuation function or returning a fallback value.
getHexBar b#ff 0 natBar == x#ff ; note the difference between b# and x#
getHexBar b#deadbeef 0 dec == 0xdeadbeef
getHexBar b#xyz 42 id == 42
Parses a decimal number from a bar.
barLoadDecimal b#123 == 123
barLoadDecimal b#0 == 0
barLoadDecimal b#9876543210 == 9876543210
Converts a natural number to its decimal string representation as a bar.
barShowDecimal 123 == b#123
barShowDecimal 0 == b#0
barShowDecimal 9876543210 == b#9876543210
Checks if a bar is a prefix of another bar at a given offset.
barIsPrefixOf b#he b#hello 0 == 1
barIsPrefixOf b#el b#hello 1 == 1
barIsPrefixOf b#lo b#hello 1 == 0
Finds all occurrences of a substring in a bar.
barSubstringSearch b#l b#hello == [2 [3 0]]
barSubstringSearch b#o b#hello == [4 0]
barSubstringSearch b#x b#hello == 0
A bar containing a single space character.
barSpace == b#{ }
barLen barSpace == 1
barIdx 0 barSpace == 32