BitCount of IBinaryInteger (and type conversion interface)

[YT-GameMaker]

I'm trying to write a high-performance inline collection, but I'm encountering some problems.

    struct InlineCollection<TItem, TMask> where TMask : IBinaryInteger<TMask>
    {
        TMask _availableMask = TMask.AllBitsSet;
        TItem[] _buffer = new TItem[Capacity]; // todo: use inline array

        public static int Capacity => TMask.BitCount;

        public bool IsFull => _availableMask == ~TMask.AllBitsSet;
        public bool IsEmpty => _availableMask == TMask.AllBitsSet;
        public int Count => (int)(Capacity - TMask.PopCount(_availableMask));
    }

I didn't find any property that can represent the bit count of IBinaryInteger. If there isn't, I think one should be added, or it can be provided through another interface.
Also, the return value of PopCount is a generic type rather than int, which seems unreasonable? If it must return a generic type, then you might consider providing an explicit or implicit type conversion interface.

[CyrusNajmabadi]

Not a language question. Moving up runtime. @tannergooding

[YT-GameMaker]

In fact, this example shows the value of 'abstract const.' It is only possible to create an inline array if BitCount is a constant.

[tannergooding]

I didn't find any property that can represent the bit count of IBinaryInteger. If there isn't, I think one should be added, or it can be provided through another interface.

This isn't relevant information. A type can opt to use many different underlying storage mechanisms, and so the number of bits available may not be well-defined (BigInteger) or may not correspond to the actual number of usable bits, etc.

Instead, there exists explicit APIs for reading/writing raw byte sequences given a well-defined two's complement format. These are the ReadBigEndian, ReadLittleEndian, and corresponding TryRead*, Write*, and TryWrite* APIs. They likewise have a GetByteCount() and GetShortestBitLength() properties that can be used by a concrete type to help implement a fallback conversion operation.

Also, the return value of PopCount is a generic type rather than int, which seems unreasonable?

In general, generic methods are expected to follow T-in, T-out. This avoids users needing to do repeated conversions for common scenarios, such as using the output as part of a further expression chain. This also avoids issues caused by domain changes, potential precision differences where a given type (such as int) may not be sufficient, etc.

If it must return a generic type, then you might consider providing an explicit or implicit type conversion interface.

Generic conversion operators are not possible to define, nor are they sufficient for covering the various intricacies of converting an arbitrary T to an arbitrary U. Instead, we provide CreateChecked, CreateTruncating, and CreateSaturating APIs that allow you to do the conversion with the appropriate semantics.

[YT-GameMaker]

Perhaps an interface like IFixedSizeNumber could be provided to better support binary operations? For example, in my case, Capacity is a static property, and now it seems that I have to obtain it by constructing an instance and then calling GetByteCount(), which is not an ideal approach. In fact, in many cases, bitwise operations are often targeted at fixed-length integer types.

[tannergooding]

Binary operations are supported just fine regardless of whether the types are fixed size or not.

There is nothing about the scenario you've given above that would limit it to only types where the size is "fixed".

[YT-GameMaker]

Other than creating an instance of the TMask type to access GetByteCount() (but this instance is not needed for the collection because its capacity is fixed by the TMask type and won't change), I don't know if there's any other way. I can only do something like this:
static int Capacity => TMask.Zero.GetByteCount() * 8;
It looks very strange.
Furthermore, due to the variable size, it's not possible to create an inline array based on its size. However, this would require language support for abstract const to achieve, so that you can obtain const int Size instead of static int Size.

[CyrusNajmabadi]

I don't understand the concept of abstract const. The point of const is that it is known at compile time. Which is the opposite of what abstract gives you.

[tannergooding]

Other than creating an instance of the TMask type to access GetByteCount()

GetByteCount() doesn't return the size of any instance, it returns the size of the particular instance. This might be fixed across all possible values and it might be variable.

Furthermore, due to the variable size, it's not possible to create an inline array based on its size.

There is nothing in .NET that would allow this and it's not really something you'd want to arbitrarily support due to the potential risks and complexities involved, particularly for larger sizes.