expressing alignment constraint

[Dean Herington]

Alastair Reid wrote:

> Interfaces to other things with alignment constraints (e.g., memory
> allocators) often have one of two generalizations:
>
> 1) (Most likely to be useful):
>
>    --| flushBytes h n aligns the strean to the next 2^n byte (bit?) boundary
>    flushBytes :: BinHandle -> Int -> IO ()
>
> 2) (Less likely to be useful in this context)
>
>    --| flushBytes h m n aligns the stream such that the position p satisfies:
>    --  p `mod` 2^m == n
>    flushBytes :: BinHandle -> Int -> IO ()

Years (decades?) ago it occurred to me that the above two options for expressing
alignment could neatly (at least in terms of the interface) be coalesced, as
follows.  An alignment constraint for allocation in a memory area is expressed as

an unsigned integer of the same size as addresses for that memory area.  An
alignment constraint of zero is not sensible.  (It could be used to indicate a
default value or could evoke an error, depending on the application.)  The
alignment constraint encodes the values `m` and `n` from the second alternative
above as `2^m + n`.  Operationally, the combined alignment constraint is split at

the uppermost "1" bit, with that bit's position indicating the power of two and
the lower bits indicating the desired remainder upon division by that power of
two.  This scheme compactly encodes all meaningful pairs of values of `m` and `n`

and has only a single inherently meaningless combined value--the aforementioned
value zero.

I've never had the opportunity to use or implement such an interface, but I have
occasionally missed the generality it provides when I had to allocate extra space

in order to place a descriptor immediately before a well-aligned bunch of bits.
Has anyone seen such an interface?

 -- Dean