[Im]PerfectRadixUIntRoot

[oscbyspro]

I have some awkward signatures, backed by some awkward assertions. Look at these two:

func _encodeBigEndianTextWhereRadixIsUIntRoot(_ value: inout ANKSigned<Self>, radix: RadixUIntRoot, uppercase: Bool) -> String {
    assert(radix.power.isZero)
    ...
}

func _encodeBigEndianTextWhereRadixIsNotUIntRoot(_ value: inout ANKSigned<Self>, radix: RadixUIntRoot, uppercase: Bool) -> String {
    assert(!radix.power.isZero)
    ...
}

But wouldn't a compile-time check be neat? With two new wrapper types, I can reduce it to:

func _encodeBigEndianText(_ value: inout ANKSigned<Self>, radix: RadixUIntRoot.Perfect, uppercase: Bool) -> String {
    ...
}

func _encodeBigEndianText(_ value: inout ANKSigned<Self>, radix: RadixUIntRoot.Imperfect, uppercase: Bool) -> String {
    ...
}

[oscbyspro]

I imagine switching on it with the following method:

func asPerfect<T>(_ asPerfect: (Perfect) throws -> T, asImperfect: (Imperfect) throws -> T) rethrows -> T {
    try self.power.isZero
    ?   asPerfect(.init(unchecked: self)) 
    : asImperfect(.init(unchecked: self))
}

It would appear at the call site in this form:

radix.asPerfect { ... } asImperfect: { ... }

I suppose it would look a bit tidier if I could label the first closure, oh well:

radix.switch 
  perfect: { ... }
imperfect: { ... }

[oscbyspro]

I used @dynamicMemberLookup to skip the boilerplate. It seems fine.

[oscbyspro]

I found a neat trick. I can make Perfect/power unavailable:

@available(*, unavailable) var power: UInt { self.root.power }

[oscbyspro]

On a bit of a tangent, I wish it were possible to nest types without nesting code:

struct Foo     { ... }
struct Foo.Bar { ... }
struct Foo.Baz { ... }

[oscbyspro]

I replaced @dynamicMemberLookup with a protocol:

1. @dynamicMemberLookup is arcane
2. I can use the protocol as a generic constraint

[oscbyspro]

I added dividing(_:) to the RadixUIntRoot protocol. The PerfectRadixUIntRoot now also stores a special value and performs division using the following method. This makes makes encoding values in perfect bases (2, 4, 16) faster.

func dividing(_ dividend: UInt) -> QR<UInt, UInt> {
    QR(dividend &>> self.special.quotient, dividend & self.special.remainder)
}

And, for what it’s worth, it does not introduce more specializations because the chunk sequences were already different.