Enumeration Sub Set Type

[gingerBill]

Is your feature request related to a problem? Please describe.
The ability to create an enumerator sub set type.

This is to allow a specific degenerate case of enumeration types for specific procedures.

A good use case would be a general error code type for a package, but different procedures explicit state what they could return.

Describe the solution you'd like
NOT FINALIZED SYNTAX:

Foo :: enum {A, B, C, D, E, F, G};

Foo_Subset :: type_set[Foo]{.A, .B, .E}; // underlying type is still `Foo`

#assert(size_of(Foo_Subset) == size_of(Foo));

x: Foo_Subset;
y: Foo;

x = .A; // valid
y = x;  // valid
x = y;  // error

switch x {
case .A: 
case .B:
case .E:
case: // invalid case
}

[Tetralux]

I would suggest adding the abilty to create a set by merging other sets.

i.e: Something along these lines:

Err :: enum {Ok, A, B, C, D};

First_Err :: type_set[Err]{.Ok, .A, .B}
Sec_Err   :: type_set[Err]{.Ok, .C, .D}

First_Or_Sec_Err :: First_Err || Sec_Err;

f :: proc() -> First_Or_Sec_Err {
  first_err := get_first(); // returns a `First_Err`
  if first_err != .Ok {
    return first_err; // fine
  }

  sec_err := get_second(); // returns a `Sec_Err`
  if sec_err != .Ok {
    return sec_err; // also okay.
  }

  return .Ok;
}

This would mean that a procedure that does a read and a write, could return Read_Or_Write_Error instead of literally any error, thus preserving more information, and being more self-documenting, a.la named-returns.