Union of generic variants

It would be great if unionize could support union of generic variants

I’m using a generic interface in one of my projects to represent generic fetch status

export interface Fetch<T> {
  results: T[]
  finished: boolean
}

and I want it to become

export interface FetchLoading {
  type: 'loading'
}

export interface FetchSuccess<T> {
  type: 'success'
  results: T[]
  finished: boolean
}

export interface FetchSuccessWithErrors<T> {
  type: 'successWithErrors'
  results: T[]
  finished: boolean
  errors: string[]
}

export interface FetchError {
  type: 'error'
  reason: string
}

And I would create an union type which could be consumed by a UI component showing the fetch status according to its type.

How could we achieve that with unionize?

[twop]

Hey, I was thinking on that problem a lot and finally shipped a version that Im comfortable with: https://github.com/twop/ts-union

const Maybe = Union(val => ({
  Nothing: of<void>(),
  Just: of(val)
}));

const {Nothing, Just} = Maybe;

Just(1); // MaybeVal<number>
Just('str'); // MaybeVal<string>
Nothing<boolean>(); // MaybeVal<boolean>

Conceptually I have a special token type Generic and I replace it with an actual type like string at the moment of construction.

type CreatorFuncG<K, Rec> = K extends Of<infer A>
   ...
    ? A extends [Generic] 
    ? <P>(val: P) => UnionValG<P, Rec> : never
   ...
: never;

Might be applicable to unionize as well 😃

[pelotom]

  Just: ofType(a) //   'Just: a' might be more ergonomic

Yeah, I don’t see any reason to make it more verbose than it has to be.

{value: "val"}); // this is probably required because not every 'a' could be spread

Hmm, yeah, I wonder if we want to enforce that they pass a value property or just treat it as implied.