SUGGESTION: Assert return type is not undefined or null

[AdamWillden]

TypeScript Version: 2.3.0-dev.20170407

Code
Paste in the following code and scroll to the final two lines:

export type Subscription = { dispose: () => void };

export type SubscriberCallbacks<Events> = {
  [event in keyof Events]?: Function;
};

export class Subscribers<Events extends SubscriberCallbacks<Events>> {
  private subscribers: Set<Events> = new Set<Events>();

  public add(events: Events): Subscription {
    this.subscribers.add(events);
    return this.createDisposer(events);
  }

  public getNotifier<EventName extends keyof Events>(eventName: EventName): Events[EventName] {
    return (...args: any[]) => this.notify(eventName, ...args);
  }

  private notify<EventName extends keyof Events>(eventName: EventName, ...args: any[]) {
    this.getReleventSubscribers(eventName).forEach((callback: Function) => callback(...args));
  }

  private createDisposer(events: Events) {
    return { dispose: () => this.subscribers.delete(events) };
  }

  private getReleventSubscribers(eventName: keyof Events): Array<Events[keyof Events]> {
    return Array.from(this.subscribers)
      .map(events => events[eventName])
      .filter(callback => typeof callback !== 'undefined');
  }
}

interface TestEvents extends SubscriberCallbacks<TestEvents> {
  foo?: (bar: number) => void,
  baz?: (qux: string) => void,
}

let testEventSubScribers = new Subscribers<TestEvents>();

testEventSubScribers.add({
  foo: (bar: number) => { console.log(bar); },
});
testEventSubScribers.add({
  foo: (bar: number) => { console.log(bar + 'hi'); },
  baz: (qux: string) => { console.log(qux + 'hi'); },
});

testEventSubScribers.getNotifier('foo')(2);
testEventSubScribers.getNotifier('baz')('lala');

To remove the errors I need to assert that the result of the getNotifier call is not undefined.

testEventSubScribers.getNotifier('foo')!(2);
testEventSubScribers.getNotifier('baz')!('lala');

Desired behavior:

It'd be nice if I could declare getNotifier as follows (note the final !):

export class Subscribers<Events extends SubscriberCallbacks<Events>> {
   public getNotifier<EventName extends keyof Events>(eventName: EventName): Events[EventName]! {
    return (...args: any[]) => this.notify(eventName, ...args);
  }
}

[ghost]

So essentially you want a type NonNull<T> such that NonNull<number | null | undefined> = number?

[dardino]

it's like this: #15098 with ?

testEventSubScribers.getNotifier('foo')?(2);
testEventSubScribers.getNotifier('baz')?('lala');

[AdamWillden]

@andy-ms, yes.

@dardino, not quite. My code is already ensuring that it is not undefined I don't want users of the code to have to handle (again) the null/undefined cases.

[DanielRosenwasser]

Sounds like a duplicate of #14366.

[AdamWillden]

@DanielRosenwasser yes, I think it might be. It's not immediately obvious but yes.

---

I might still have a draft on my tablet at home about a more generic suggestion of a 'strip' operator. I was going to suggest that for a more generic solution we could do something like:

type Foo = Date | string | number | null;
type Bar = Foo ^ Date ^ null;  // equivalent to: type Bar = string | number

Although I'm not sure how much scope or requirement there is for such a thing.

[AdamWillden]

Here's what I had written

---

In generic terms, to provoke some thought (if easier to implement), I'm after something that can strip a type from an existing compound type.

Given we have &=and and |=or we could add ^=strip

// This works
type Thing = string | number | Date | null;
type OtherThing = Thing ^ Date;        // type OtherThing = string | number | null;

// This would still work too
type AnotherThing = string | number | null; // no Date
type AlienThing = AnotherThing ^ Date; // type AlienThing = string | number | null;

[gcnew]

Subtraction types have already been proposed several times. See #4183

[AdamWillden]

Right then. Closing and subscribing to those issues. Thanks everyone.