I'm attempting to create a "loose" nominal type that allows assignment from its base type, but not from other nominal types that have that base type.
There excellent Nominal type here:
declare const nominalSymbol: unique symbol;
export type Nominal<T extends string, U> = U & { [nominalSymbol]: T };
but is there a way to expand on this to functionally do
export type LooseNominal<T extends string, U> = Nominal<T, U> | U; // but prohibit direct assignment of nominal types derived from U
Example of desired behavior:
type Address = LooseNominal<'Address', string>;
type FirstName = LooseNominal<'FirstName', string>;
let address: Address = "123 Some St";
let firstName: FirstName = "John";
address = "456 Another St"; // no problem
address = firstName; // Type Error!
As far as I know, there's no way to do a constraint like U !extends Nominal<any, any>. I tried U extends Nominal<T, any> ? never : U, but apparently you can't use a ternary clause there, and trying to put it on the other side of the = ends up in type simplification that prevents it from working as a nominal type at all.
If you need assignability but not cross-assignability, use optional branding:
declare const brand: unique sympol
type Brand<T, F> = T & {[brand]?: F}
// ^