simple match function on rune

[nythrox]

If you have a param that's a or Rune<T | Uint8Array | undefined> or any other typescript union, and you'd like to treat each case separately, you'd have to do some combination of .unhandle(isUint8Array) and .rehandle(isUint8Array, $encoder.encode) for each separate type.

Would be nice to have a simple match that does the same thing, but with a more understandable control flow:

const value: Rune<T | undefined> =
  param.match(isUint8Array, $encoder.encode)

related to #624 , but for general conditional control flows based on any arbitrary value

[tjjfvi]

Yes, a .handle method is planned to do exactly that. Since Uint8Array is a class, you could simply write .handle(Uint8Array, $encoder.encode). We'll probably also add a simple not around the same time, to enable .handle(not(undefined), $encoder.encode)

[harrysolovay]

Good point, especially since handle will accept guards too. Shall we close #624 in favor of this issue (and rename this issue to rune.handle)?

[harrysolovay]

In addition to a not util, we might want a simple curried isTagged for easier creation of guards to handle tagged unions.

const isType = isTagged("type")

rune
  .handle(isType("Id"), () => {})
  .handle(isType("Address20"), () => {})

[tjjfvi]

Shall we close #624 in favor of this issue

No, #624 is also important, because repeated calls to .handle could flow into each other.

[nythrox]

I'm playing with this on my branch to see if it improves my control flow. Impl was surprisingly simple, but it'll be better typed when it's its own handle function

  match<T2 extends T, T3, U3>(
    fn: Guard<T, T2>,
    alt: (rune: ValueRune<T2, never>) => Rune<T3, U3>,
  ): ValueRune<T | T3, U | U3> {
    return this.unhandle(fn).rehandle(fn as Guard<T2 | U, T2>, alt)
  }

[tjjfvi]

The issue with that implementation is that it may unintentionally rehandle values; part of the reason to have a .handle at all is to make that pattern less common.