However I am confused if the enum's are structural or nominal. It seems necessary to state which enum a variant comes from, like `Direction of South` (for that matter it seems the same is true when constructing structs?). Can you cast enum values to a wider enum type? Or combine different enum values (e.g. through branching - the return of `match`) to construct a value of a wider enum?
``` enum Option<T> {Some(T), Nothing}
// Create a value with an inline type that doesn't use the nominal `Option`
let opt1 = enum {Some(Int), Nothing} of Some(5);
// Define a second option value, which is assigned with the first
let opt2: Option<Int> = opt1;
// Print the result
println(opt2); ```
You can create a variant of an inline `enum` type, and then typecheck it against another structurally equal type if you so choose!
I hope this example properly illustrates how powerful the structural type-checking is with enums!
I'm imagining you're going to want a kick-ass IDE/linter/VSCode plugin to handle the case when you create a new variable that matches an existing pattern, and automatically making existing references more precise.
Though it might be easier to go the other way - at the presentation layer, automatically shorten variables to the least specific yet unique suffix or something.
``` enum Option<T> {Some(T), Nothing};
let opt1 = enum {Some(Int)} of Some(5);
let opt2: Option<Int> = opt1; ```