Question: Interface with _at least one_ defined member?

[benlesh]

In RxJS, we have a need for an interface that is basically this:

interface Observer<T> {
  next?: (value: T) => void;
  error?: (err: any) => void;
  complete?: () => void;
}

but you'll notice that it matches {} in that case, which isn't what we want. What we really want is at least one of those members.

It seems like I'd be able to do something with PartialObserver<T> = NextObserver<T>|ErrorObserver|CompleteObserver, but I'm honestly not sure how to accomplish this.

[weswigham]

interface NextObserver<T> {
  next: (value: T) => void;
}
interface ErrorObserver {
  error: (err: any) => void;
}
interface CompleteObserver {
  complete: () => void;
}
type Observer<T> = NextObserver<T> | ErrorObserver | CompleteObserver | (NextObserver<T> & ErrorObserver & CompleteObserver) | (ErrorObserver & CompleteObserver) | (NextObserver<T> & ErrorObserver) | (NextObserver<T> & CompleteObserver);

You can enumerate the power set of interface combinations by hand, though I'll admit the definition is a little dense (and possibly more verbose than need be).

[ahejlsberg]

Perhaps this?

interface NextObserver<T> {
  next: (value: T) => void;
  error?: (err: any) => void;
  complete?: () => void;
}
interface ErrorObserver<T> {
  next?: (value: T) => void;
  error: (err: any) => void;
  complete?: () => void;
}
interface CompleteObserver<T> {
  next?: (value: T) => void;
  error?: (err: any) => void;
  complete: () => void;
}
type Observer<T> = NextObserver<T> | ErrorObserver<T> | CompleteObserver<T>;

[benlesh]

@ahejlsberg ... that did it. Thank you!

[benlesh]

Also, @weswigham I tried the same thing you recommended, and (just for informational purposes) it caused compilation errors on the consumption side. observer.next() would say "next" does not exist on NextObserver<T> | ErrorObserver | CompleteObserver | (NextObserver<T> & ErrorObserver & CompleteObserver) | (ErrorObserver & CompleteObserver) | (NextObserver<T> & ErrorObserver) | (NextObserver<T> & CompleteObserver); unless I cast it first.

[weswigham]

Just realized I never came back to this - the intention of my definitions would be for a strongly typed observer which requires checks for members before calls are allowed. Pair the definitions in my prior post with type guards like so:

function hasNext<T, U extends Observer<T>>(o: U): o is NextObserver<T> {
  return !!(o as NextObserver<T>).next;
}

function hasComplete<T, U extends Observer<T>>(o: U): o is CompleteObserver<T> {
  return !!(o as any).complete;
}

function hasError<T, U extends Observer<T>>(o: U): o is ErrorObserver<T> {
  return !!(o as any).error;
}

And use like so:

const obs: Observer<Observee> = fetchObs();
for (i=1, i<3, i++) {
  if (hasNext(obs)) {
    try {
      thing = doThing()
    }
    catch (e) {
      if (hasError(obs)) {
        return obs.error(e);
      }
    }
    obs.next(thing);
  }
}
if (hasComplete(obs)) {
  obs.complete()
}

I think I've got the types right for that, but I can't claim to have tested it, as it makes use of TS 1.8's F-Bounded Polymorphism, so I can't just drop it into the playground to test it yet (and I'm away from my PC at the moment).