structc | Lightweight C structure base library | 3D Printing library

Remember that for any pointer or array p and index i, the expresspion *(p + i) is exactly equal to p[i]. From that follows that p + i is equal to &p[i].

This means that in your example bigChunk+iter will be the same as &bigChunk[iter]. And since bigChunk is an int *, the compiler will treat bigChunk as an array of int, not as an array of bytes.

For the second structure, you will copy it to bigChunk[8] (assuming no padding) which is at a byte-offset of 32 (assuming a size of 4 for int) from the beginning of the memory. This is far beyond the offset to the second structure (it's byte-offset should be 8).

Use char * as the type for bigChunk instead, to make it an "array of bytes".

The key is to use itertools.product to generate all possible combinations of a set of ranges and substitute them as array indices of an appropriately constructed string template.

Doing this would require the arrays listA and listB to be allocated on the stack, which is currently not possible, as arrays don't have a fixed size and are therefore allocated on the heap.

To solve this, you could use tuples instead of arrays or declare your struct in C code. You could even share the struct declaration with your metal code by putting them in a C header file.

This answer may help you.

This is the intended working, as defined by the language spec.

There are 2 types of switch statement, Expression switches and Type switches, and this behavior is documented at the Expression switches:

In an expression switch, the switch expression is evaluated and the case expressions, which need not be constants, are evaluated left-to-right and top-to-bottom; the first one that equals the switch expression triggers execution of the statements of the associated case; the other cases are skipped. If no case matches and there is a "default" case, its statements are executed. There can be at most one default case and it may appear anywhere in the "switch" statement.

[...]

A type switch compares types rather than values. It is otherwise similar to an expression switch.

In Go a type implicitly implements an interface if its method set is a superset of the interface. There is no declaration of the intent. So in Go it doesn't matter which interface defines the methods, only thing that matters is the method signatures: if a type has all the methods an interface "prescribes", then that type implicitly implements the said interface.

The problem is that you want to use the Type switch to something it was not designed for. You want to find the "widest" type (with the most methods) that is still implemented by the value. It will only do this if you enumerate the cases (the different types) in this intended order.

That being said, in your case there's no such thing that a value is only InterfaceC implementation. Your code doesn't lie: all values that implement InterfaceC will also implement InterfaceA and InterfaceB too, because the method sets of both InterfaceA and InterfaceB are subsets of the method set of InterfaceC.

If you want to be able to "differentiate" InterfaceC implementations, you have to "alter" the method sets so that the above mentioned relation will not hold (method set of InterfaceC will not be a superset of the method set of InterfaceA and InterfaceB). If you want StructC to not be an InterfaceA implementation, you must change the method signature of ActionA() (either in InterfaceA or in InterfaceC), and similarly ActionB() to not be an InterfaceB implementation.

You could also add a method to InterfaceA (and to InterfaceB) which is missing from InterfaceC: