在TypeScript中以类型安全的方式调用函数

Question

I think an example is worth a thousand words, so below is what I am trying to do:

type Message = keyof MessageArguments;

type MessageArguments = {
    'foo': []
    'bar': {}
};

type MsgEvent<T extends Message> = {
  data: {
    type: T
    arguments: MessageArguments[T]
  }
};

type FunctionTypes = {
    [K in Message]: (event: MsgEvent<K>) => void 
}

const functions: FunctionTypes = {
    'bar': (event) => {
        console.log("invoked bar", event);
    },

    'foo': (event) => {
        console.log("invoked foo", event);
    }

};

function is<T extends Message>(e: MsgEvent<T>, type: T): e is MsgEvent<T> {
    return e.data.type === type;
}

function invoke<T extends Message>(e: MsgEvent<T>, type: T): FunctionTypes[T] {
    if (is(e, type)) {
        return functions[e.data.type](e);
    } else {
        throw "failed to find function";
    }
}

invoke({
    data: {
        type: 'foo',
        arguments: []
    }
}, 'foo');

If you input it into TypeScript playground or compiler you'll get an error:

Cannot invoke an expression whose type lacks a call signature. Type '((event: MsgEvent<"foo">) => void) | ((event: MsgEvent<"bar">) => void)' has no compatible call signatures.
(property) type: T extends "foo" | "bar"

But you can clearly tell from the code that only method (or none) can be invoked, and I think the type should be able to represent that, but I don't know how... It's almost like I need to tell the compiler that in function invoke<T extends Message> , T is an exclusive or - it can only be one of the values, not either.

Answer 1

Along the lines of what Titian Cernicova-Dragomir said, the compiler does not know that you aren't calling invoke with T = "foo" | "bar" T = "foo" | "bar" . Thus, it can only reason based on T 's constraint "foo" | "bar" "foo" | "bar" . Edit: I have just updated an existing suggestion of mine to cover constraining type variables singleton; I suggest you vote for it.