Pads

Pads are bit-strings encoded as non-zero natural numbers. Pads are not data-jetted, since the direct nat works perfectly. Pads are encoded least-significant-bit-first, with the high bit used to indicate the end of the bit-array.

p#{}          == 0b1 ; 1
p#{00}        == 0b100 ; 4
p#{01}        == 0b110 ; 6
p#{111000}    == 0b1000111 ; %G

All of the pad operations coerce their inputs into pads, and always return pads.

The REPL will print pads as their natural number representation by default. Use padShowLit to coerce the output into the bit-string format used here.

emptyPad

Represents an empty pad.

emptyPad    == 1

toPad

Coerces a value into a non-zero natural number (pad).

toPad 0     == 1
toPad 1     == 1
toPad 3     == 3

padNat

Converts a pad to a natural number, dropping all trailing zeros.

padNat p#0      == 0
padNat p#1      == 1
padNat p#100    == 1

natPad

Converts a natural number into a pad with a specific minimum bit-width.

natPad 1 3    == p#100
natPad 2 4    == p#0100
natPad 3 2    == p#11

padLen

Returns the length of a pad (number of bits).

padLen p#0       == 1
padLen p#1       == 1
padLen p#1010    == 4

padWeld

Concatenates two pads.

padWeld p#10 p#11      == p#1011
padWeld p#0 p#1        == p#01
padWeld p#111 p#000    == p#111000

padCat

Concatenates a row of pads.

padCat [p#1 p#0 p#11]    == p#1011
padCat [p#10 p#01]       == p#1001
padCat []                == p#{}

padFlat

Flattens and concatenates a nested structure of pads.

padFlat [[p#1 p#0] [p#1 p#1]]    == p#1011
padFlat [p#10 p#11]              == p#1011
padFlat [[[]] []]                == p#{}

padSplitAt

Splits a pad at a given index.

padSplitAt 2 p#1111    == [p#11 p#11]
padSplitAt 1 p#1010    == [p#1 p#010]
padSplitAt 3 p#1001    == [p#100 p#1]

padIdx

Returns the nth bit from a pad.

padIdx 0 p#1010    == 1
padIdx 1 p#1010    == 0
padIdx 3 p#1010    == 0

padGet

Alias for padIdx, but with arguments flipped.

padGet p#1010 0    == 1
padGet p#1010 1    == 0
padGet p#1010 3    == 0

padSet

Sets the nth bit in a pad using a Bit.

padSet p#0000 2 1    == p#0010
padSet p#1111 1 0    == p#1011
padSet p#1010 3 1    == p#1011

padMapWithKey

Maps a function over the bits in a pad, providing both the index and the bit value.

padMapWithKey (k b & if even-k b not-b) p#0000    == p#0101
padMapWithKey (k b & if even-k b not-b) p#1111    == p#1010
padMapWithKey (k b & add k b) p#1010              == p#1111

padMap

Maps a function over the bits in a pad, coercing outputs to bits.

padMap not p#1010          == p#0101
padMap (add 1) p#1010      == p#1111
padMap (const 0) p#1111    == p#0000

padComplement

Complements all bits in a pad.

padComplement p#1010    == p#0101
padComplement p#1111    == p#0000
padComplement p#0000    == p#1111

showPadStr

Converts a pad to its string representation.

showPadStr p#1010    == {0101}
showPadStr p#1000    == {0001}
showPadStr p#{}      == 0

showPadLit

Converts a pad to its Rex literal representation.

showPadLit p#1010    == p#0101
showPadLit p#1000    == p#0001
showPadLit p#{}      == p#{}