enumer | A Go tool to auto generate methods for your enums | SDK library

After some research I found the answer. You can use the static method: cases().

You can print out the sql for that migration to see specifically whats wrong, but defining db_type to return "enum" is definitely not the right way to approach it.

Looks like a bug to me. Modifying case A to case nullptr gives the following error message (on the template definition):

Yes, as of now, the One Definition Rule in the C++ standard doesn't include enumerators.

However, the "the second a is a redeclaration of the first a" explanation doesn't work too.
From [dcl.enum#nt:enumerator-list] we can know that an enumerator-list is a list of enumerator-definition, so they're all definitions.

From the C18 standard in 6.7.2.2:

Each enumerated type shall be compatible with char, a signed integer type, or an unsigned integer type. The choice of type is implementation-defined, but shall be capable of representing the values of all the members of the enumeration.

So yes enum { a } e = 1; is valid. e is a 'integer' type so it can take the value 1. The fact that 1 is not present as an enumeration value is no issue. The enumeration members only give handy identifiers for some of possible values.

The "member interpretation" refers to begin_expr and end_expr using members of the iterated type in contrast to using plain offsets for arrays or begin and end free functions.

The array interpretation is off the table, because it is only used for arrays. Next consider that there is std::begin and std::end:

Custom overloads of begin may be provided for classes and enumerations that do not expose a suitable begin() member function, yet can be iterated.

Now consider this example:

First you need to create blob file in case of active storage.

I think part of the confusion stems from this assumption:

I thought arrays and tuples have the same memory layout, and that is why you can convert arrays to tuples using withUnsafeBytes and then binding the memory...

Arrays and tuples don't have the same memory layout:

• Array is a fixed-size struct with a pointer to a buffer which holds the array elements contiguously* in memory
  • Contiguity is promised only in the case of native Swift arrays [not bridged from Objective-C]. NSArray instances do not guarantee that their underlying storage is contiguous, but in the end this does not have an effect on the code below.
• Tuples are fixed-size buffers of elements held contiguously in memory

The key thing is that the size of an Array does not change with the number of elements held (its size is simply the size of a pointer to the buffer), while a tuple does. The tuple is more equivalent to the buffer the array holds, and not the array itself.

Array.withUnsafeBytes calls Array.withUnsafeBufferPointer, which returns the pointer to the buffer, not to the array itself. *(In the case of a non-contiguous bridged NSArray, _ArrayBuffer.withUnsafeBufferPointer has to create a temporary contiguous copy of its contents in order to return a valid buffer pointer to you.)

When laying out memory for types, the compiler needs to know how large the type is. Given the above, an Array is statically known to be fixed in size: the size of one pointer (to a buffer elsewhere in memory).

Given

I don't see any common trait shared by all enum companion objects.

You still can invoke the values reflectively, though: