如何通过UInt64数组构造BitVector？是否存在对应逆函数？

Great question! Let's unpack this step by step.

First, the key thing to understand here is that a BitVector isn't just its underlying UInt64 chunks array—it also tracks the number of valid bits it contains. The chunks array might have a final element that's only partially used (e.g., if your BitVector has 65 bits, you'll have two UInt64 chunks: the first full, the second with only 1 valid bit). Without knowing that valid bit count, you can't reconstruct the original BitVector accurately.

When such a function foo exists #

If your original BitVector x has a length that's exactly x.chunks.length * 64 (meaning every bit in every chunk is valid), then yes—you can absolutely write foo.

For example, if you're using Scala's standard BitVector (from scala.collection.immutable), you could implement it like this:

import scala.collection.immutable.BitVector

def foo(chunks: Array[UInt64]): BitVector = {
  val fullLength = chunks.length * 64
  BitVector.fromChunks(chunks.toIndexedSeq, fullLength)
}

In this case, foo(x.chunks) will be identical to x, since we're explicitly setting the length to match the full size of the chunks array.

When such a function foo CANNOT exist #

If your original BitVector x has a length that's not a multiple of 64, then you can't reconstruct x using only its chunks array. The chunks alone don't tell you how many bits in the final chunk are actually part of the original BitVector.

For example: suppose x is a 70-bit BitVector. Its chunks array will have two UInt64 elements, but only the first 6 bits of the second chunk are valid. If you create a new BitVector just from those chunks without specifying the 70-bit length, you'll end up with a 128-bit BitVector (using all bits in both chunks)—which is not equal to x.

In this scenario, you'd need to modify foo to accept both the chunks array and the original length of x to get an exact match.

Edge case: If your BitVector encodes length in chunks #

Some custom BitVector implementations might encode the length directly into one of the chunks (though this is rare). If that's the case for your BitVector, you could parse the length from the chunks array itself and use that to construct the original BitVector. But this is highly dependent on the specific implementation you're working with.

内容的提问来源于stack exchange，提问作者Koz Ross