Ability to define each variant individually

[sledorze]

Enabling creating several unions from some variants

const success = ofType<AddActionSuccess>()
const failure = ofType<AddActionFailure>()
const error = ofType<AddActionError>()

export const addAction = unionize({
  success,
  failure
})

export const addAction2 = unionize({
  success,
  failure,
  error
})

and also using the predicates and constructor from each variant, individually (while preserving usage from the union too!)

const success = ofType<AddActionSuccess>()
success.is(...) // predicate
success.of(...) // constructor

[pelotom]

The first example should already work, no? I'm not sure how the second could work without passing in the options argument defining the tag and value properties, for each variant:

const options = { tag: 'type', value: 'payload' };
const success = ofType<AddActionSuccess>(options);
const failure = ofType<AddActionFailure>(options);
const error = ofType<AddActionError>(options);

That seems like kind of a pain?

[sledorze]

@pelotom first example is to show that we keep the current behaviour while also supporting the second example (I should have use '..while also using..' instead of '..and also using..'.

I like the solution you're proposing for options.
Also, it does not seems like kind of a pain to me as one can define some shortcut.

const myOfType = <T>() => ofType<T>({ tag: 'type', value: 'payload' })

const success = myOfType<AddActionSuccess>();
const failure = myOfType<AddActionFailure>();
const error = myOfType<AddActionError>();

Would you consider such a feature?

[pelotom]

It doesn't seem to offer much beyond this approach, does it?

const { as, is, success, failure, error } = unionize({
  success: ofType<{ x: number }>(),
  failure: ofType<{ y: number }>(),
  error: ofType<{ z: number }>(),
}, { tag: 'type', value: 'payload' });

const foo = failure({ message: 'whoops' });
if (is.success(foo)) {
  return as.error(foo);
}

[sledorze]

@pelotom
The idea was that variants may below to several unions and using the ctor for a variant from one union over another union will return the type of that union (and that's fine).

But when someone just want to create a simple variant (refined so not tight to a larger union); it has to create a specific union of one variant, which is the boilerplate I would like to remove.

Also it would follow a variant first (and not union first) approach, which (I may be wrong) feel more in line with a 'building from smaller parts' approach to me.

[pelotom]

If you can figure out a way to add this in a backwards-compatible way I'd be open to it.