Typescript union with dependent types

Question

If I have the following union which wraps a function and its argument, how can I call it?

type Wrapper = {
  fn: (a: string) => void
  arg: string
} | {
  fn: (a: number) => void
  arg: number
}

let foo!: Wrapper
foo.fn(foo.arg) // Error Type 'string' is not assignable to type 'never'.

I can't figure out how to call it. Everything that I've tried essentially boils down to a cast, (e.g. casting to (a:any) => void) which I can do if I have to, but I feel that I shouldn't have to do that.

Can this function be called without casting?

Edit: To clarify, I'm asking if there exist solutions which don't involve changing definition of Wrapper.

The problem is that, given type F = (x: A) => T and type G = (x: B) => U, the union type H = F | G is (x: A & B) => T | U. To call a function of type H, we would need supply an argument that is a subtype of both A and B. — Aluan Haddad
– Aluan Haddad, Commented Sep 21, 2020 at 16:44
@AluanHaddad Yes, that seems to be typescript's logic, but it clearly loses type information. I want to know if there is a way not to lose the information about the relationship between fn and arg. — ccarton
– ccarton, Commented Sep 21, 2020 at 16:53
The language doesn't consider arg to be a discriminant. You would have to introduce a discriminant i.e. Playground Link — Aluan Haddad
– Aluan Haddad, Commented Sep 21, 2020 at 17:45

wantok · Accepted Answer · 2021-08-15 23:31:30Z

1

You can use a conditional type to disambiguate the types. Unfortunately it requires you basically duplicate your wrapper union types again and if you have more things you need to check, your conditional type will get pretty ugly. But it does let you avoid a cast (sort of).

type Wrapper = {
  fn: (a: string) => void
  arg: string
} | {
  fn: (a: number) => void
  arg: number
}

type Disambiguate<W extends Wrapper> = W['arg'] extends string
  ? { fn: (a : string) => void, arg: string }
  : { fn: (a: number) => void, arg: number };

let foo!: Disambiguate<Wrapper>

// The compiler is satisfied. No error here.
// foo can only be one of the branches in the conditional type.
foo.fn(foo.arg);

answered Aug 15, 2021 at 23:31

wantok

9955 silver badges16 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Pritam Kadam · Accepted Answer · 2020-09-21 15:03:04Z

0

Not exactly sure about your use case, but above can be achieved by using this:


type ArgType = number | string

type Wrapper<T extends ArgType> = {
  fn: (a: T) => void
  arg: T
}

let foo!: Wrapper<number>
foo.fn(foo.arg)

let foo1!: Wrapper<string>
foo1.fn(foo1.arg)

answered Sep 21, 2020 at 15:03

Pritam Kadam

2,54710 silver badges17 bronze badges

1 Comment

ccarton Over a year ago

Thanks for the attempt. My example was simplified. I'm looking for an answer to the general case when we can't move the union out in this way.

Collectives™ on Stack Overflow

Typescript union with dependent types

2 Answers 2

Comments

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related