union-type | small JavaScript library for defining and using union types | Validation library

one solution for this would be to use strict unions:

The question is, are the arguments passed to my_copy an issue? If this was just to copy a single union my_type, I believe that it would be ok. I don't know if that is valid to copy an array, though.

I'm not sure whether to blame it on the arguments, exactly, but you pass pointers derived from two arrays, and then use them to overrun the bounds of those arrays. Undefined behavior results. That the storage thereby accessed can be considered to stay within the bounds main()'s src and dst arrays does not formally matter.

In practice, the program probably behaves as you expect, though I find the particular calling idiom extremely obscure. Why is sizeof(union mytype) involved? Why is the corresponding parameter named count, when it is actually eight times the number of loop iterations? I think I have figured it out, but I shouldn't have to be uncertain about that.

If you want to copy between two disjoint arrays of union my_type, using the 2x32-bit access pattern of the example, then I would write it like this:

You can use in operator like this:

An intersection between two sets would yield elements that are in both sets.

Types are just descriptions of sets of values.

So for the intersection of primitives string & number, what value is in both the string set and the number set, ie. can be both a string and number at the same time. The answer is there is no such value. So we get never (the empty set)

For object types the result is a bit different. Object types describe sets where the value must have at least the properties described by the type. So values in the set { name: string, onlyA: string[] } could have a property onlyB, but they are not required to have it (ex).

Going back to the intersection ObA & ObB, values in this intersection must satisfy both the description of ObA and ObB. So the values in this set will be the values from ObA that also have an onlyB property, and the values from ObB that also have an onlyA property. Basically values that satisfy both set descriptions, which for object types unlike for primitives we can construct by creating objects with properties from both types.

My tsconf workshop starts with a "Types as sets" section you might find interesting.

I would say that specific ask is impossible, because boolean itself I believe is not a primitive, but a union itself of type true | false.

UPD: by the way, if you can do it, it doesn't mean you should. Maybe the suggestion in comments to reframe the problem and use BaseState & TStates for state is a better one. Although you cannot define your own enum with these properties in such case.

Anyway

First with unions. As you've already understood, you cannot constrain the TStates type argument to extend 'started' | 'finished', because then you won't be able to add extra fields. You can however require that 'started' | 'finished' extend TStates. One way is as such:

It's not a bug, although it has effects you don't like in this situation. When the compiler has to infer a single type from several other types, it will try to synthesize what is called "the best common type". Often this will be a direct union of all the types involved:

The problem is that Typescript weakens the type of your tuple to an array of unions, before it is used to infer T. There are two solutions: either ensure that the type is not weakened by using as const, or have a generic type which is inferred from the callback function's parameters instead of the array.

Solution 1: the upper bound of T is readonly to accommodate the as const assertion, and RawValues removes this modifier. Note that the result is inferred with literal types as ['string', true] instead of [string, boolean].

Is it possible you just need to adjust your types a bit: