Allow method type guards

TypeScript Version: 2.0.3

Code

Why I can have function type guard:

function hasValue<T>(value: T | undefined): value is T { return value !== undefined; }

but not method type guard:

export class Maybe<T> {
    constructor(public value: T | undefined) {}

    hasValue(): this.value is T { return this.value !== undefined; }
    //              ^ '{' or ';' expected.
}

?

Semi related to a random thought here in that more complicated guards could express codependency of properties:

interface Array<T> {
    length: number;
    pop(): this.length > 0 ? T : undefined;
}

const arr = [ 1, 2, 3 ];

if (arr.length > 0) {
    const val = arr.pop(); // val is number, not number | undefined under strictNullChecks
}

~~This would be interesting... expressing path dependent types.~~
Read the OP backward... too early.

Would this also fix issues with Map?
In the case where you're using map to add memoization to functions there is a similar need to use the ! operator.

const cache = new Map<number, string[]>()
if (cache.has(n)) {
  return cache.get(n)!  // The if statement above should make return type `string[]` instead of `string[] | undefined`
}

Matt Mazzola (@mattmazzola)

What about using this type guards instead?

export class Maybe<T> {
    constructor(public value: T | undefined) {}

    hasValue(): this is this & { value: T } { return this.value !== undefined; }
}

///////

declare var x: Maybe<string>;
if (x.hasValue()) {
    x.value.toLowerCase();
}

Matt Mazzola (@mattmazzola) I've used the above technique to describe a way that Map#has could work similarly, but it can get a bit messy.

Ok, I'll have to learn/explore more about the this type guards. In my Map example this type definition is pre-defined by the lib.d.ts since they're part of ES2016 I believe and I didn't want to re-write my own type which wraps the native one.

Daniel Rosenwasser (@DanielRosenwasser)

Daniel Rosenwasser (@DanielRosenwasser) Any way to make that approach work for private properties?

I wanted to use this for this pattern:

https://www.typescriptlang.org/play/?ssl=14&ssc=1&pln=15&pc=1#code/KYDwDg9gTgLgBAYwDYEMDOa4BEU2ASQDs8oA3FJOAbwCg44woBLcvRCQtGKAVwRmgAKRi1zA4XFLABc2MQBoGzVuOCEAJrJxsAPnEI8kSAJTUAvjTpwmaAPKEA5hCaPBx2TAAWN65i8+AMmo4NU19Q0ozait6KGAYHihCOH80ADpQuABeHPCjKwsrGwAxFyY8Nw9vTB9UuCCqEI0tMTgo2npY+MTk1IyNOABCXIN8+kL6AVLCcuAAZW4XBzdozusAMzhBPpKyiuNTDrW4OISkuAADABIqPslYNIEF5ldjKIBaOBu+0MeIZ6WbjMFxibVBXigEAA7vpgDCAKJQSFQQQAcgAKtU5HgiCRyJQfBwnEtFAgUIRCBB4AgOKRgLAUhA4Os9uIXHiKBJFo5UcYCjQzEA

export class DateInterval {
  private constructor(private start: Date, private end: Date | null) {}

  isOngoing(): this is this & { end: null } {
    return this.end === null
  }

  isFinite(): this is this & { end: Date } {
    return this.end !== null
  }

  toFiniteString() {
    if (this.isFinite()) {
      return `${this.start.toString()} - ${this.end.toString()}`
    }
    throw new Error('This DateInterval is ongoing, cannot convert to finite interval string')
  }
}

But it gives me the following error: "Property 'end' has conflicting declarations and is inaccessible in type 'DateInterval & { end: Date; }'.(2546)"

Daniel Rosenwasser (@DanielRosenwasser)

The problem with the solution by Daniel Rosenwasser (@DanielRosenwasser):

What about using this type guards instead?

export class Maybe<T> {
    constructor(public value: T | undefined) {}

    hasValue(): this is this & { value: T } { return this.value !== undefined; }
}

///////

declare var x: Maybe<string>;
if (x.hasValue()) {
    x.value.toLowerCase();
}

is that "else" doesn't work:

if (x.hasValue()) {
    x.value.toLowerCase();
}
else {
  x.value // x.value is string | undefined instead of undefined
}

Is there any way to negate the hasValue() function and get undefined, in this case?

Is there any way to negate the hasValue() function and get undefined, in this case?

Yep, here's a better version -

type Maybe<T> =
  & ( Just<T>
    | Nothing
    )
  & MaybePrototype<T>

interface Just<T> { value: T }
interface Nothing { value: undefined }
interface MaybePrototype<T> { isJust(this: Just<T> | Nothing): this is Just<T> }

type MaybeConstructor =
  new <T>(value: T | undefined) => Maybe<T>

const Maybe = (class MaybeImpl<T> {
  constructor(public value: T | undefined) {}
  isJust() { return this.value !== undefined }
}) as MaybeConstructor

const x = new Maybe("");
if (x.isJust()) {
  x; // Just<string>
  x.value // string
  x.value.toLowerCase();
} else {
  x; // Nothing
  x.value; // undefined
  let test: undefined = x.value;
}

Sam Grönblom (@sgronblo)

(only for sake of showing some stuff off, don't take it seriously :P)

In a language like TypeScript it's better to write abstractions in something like static-land. If at all one wants to consume it in the class form I wrote a little thing called classFromStaticLand that converts a static land implementation to object-oriented implementation. Here's how you'd use it (taking Sam Grönblom (@sgronblo)'s example)

type DateInterval =
  | { start: Date, end: Date }
  | { start: Date, end: null }
const _DateInterval = {
  of: (start: Date, end: Date | null) =>
    ({ start, end }) as DateInterval,
  isOngoing: (t: DateInterval): t is DateInterval & { end: null } =>
    t.end === null,
  isFinite: (t: DateInterval): t is DateInterval & { end: Date } =>
    !_DateInterval.isOngoing(t),
  toFiniteString: (t: DateInterval) => {
    if (_DateInterval.isFinite(t)) {
      return `${t.start.toString()} - ${t.end.toString()}` // no error
    }
    throw new Error("This DateInterval is ongoing, cannot convert to finite interval string")
  }
}
const DateInterval = classFromStaticLand(_DateInterval, "DateInterval");

let x = new DateInterval(new Date(), new Date());
console.log(x)
  
if (x.isOngoing()) {
  x.end // null;
  x.end.getDay() // expected error
} else {
  x.end // Date;
  console.log(x.end.getDay())
}

Here's what the console would look like...

Here's the playground link to try it out.

And here's the full code for reference

const main = () => {
  type DateInterval =
    | { start: Date, end: Date }
    | { start: Date, end: null }
  const _DateInterval = {
    of: (start: Date, end: Date | null) =>
      ({ start, end }) as DateInterval,
    isOngoing: (t: DateInterval): t is DateInterval & { end: null } =>
      t.end === null,
    isFinite: (t: DateInterval): t is DateInterval & { end: Date } =>
      !_DateInterval.isOngoing(t),
    toFiniteString: (t: DateInterval) => {
      if (_DateInterval.isFinite(t)) {
        return `${t.start.toString()} - ${t.end.toString()}` // no error
      }
      throw new Error("This DateInterval is ongoing, cannot convert to finite interval string")
    }
  }
  const DateInterval = classFromStaticLand(_DateInterval, "DateInterval");

  let x = new DateInterval(new Date(), new Date());
  console.log(x)

  if (x.isOngoing()) {
    x.end // null;
    x.end.getDay() // expected error
  } else {
    x.end // Date;
    console.log(x.end.getDay())
  }
}

const classFromStaticLand =
  ((m: any, name: any) =>
    function (this: any, ...a: any[]) {
      Object.assign(this, m.of(...a))
      Object.setPrototypeOf(
        this,
        Object.fromEntries(
          Object.entries(m)
          .filter(([k]) => k !== "of")
          .map(([k, f]) => [
            k,
            function (this: any, ...a: any[]) {
              return (f as any)(this, ...a);
            }
          ])
        )
      )
      this[Symbol.toStringTag] = name;
    }
  ) as any as FromStaticLand.Class

main();

namespace FromStaticLand {
  export type Class =
    <M extends { of: (...a: any[]) => object }>(m: M, name: string) =>
      new (...a: M["of"] extends (...a: infer A) => any ? A : never) =>
        Instance<M>

  type Instance<M extends { of: () => unknown }, T = ReturnType<M["of"]>> =
    & T
    & { [K in Exclude<keyof M, "of">]:
          IsGuard<M[K]> extends true
            ? Guard<T, M[K]>
            : Method<T, M[K]>
      }

  interface Method<T, F>
    { (this: T, ...a: Parameters<F>): Called<F>
    }

  interface Guard<T, F>
    { (this: T, ...a: Parameters<F>): this is GaurdApplied<F>
    }

  type IsGuard<F> = F extends (t: any) => t is any ? true : false
  type Parameters<F> = F extends (t: any, ...a: infer A) => any ? A : never;
  type Called<F> = F extends (t: any, ...a: any[]) => infer R ? R : never;
  type GaurdApplied<F> = F extends (t: any, ...a: any[]) => t is infer U ? U : never;
}

But more seriously one way to facilitate this is to allow typing this in the constructor like so...

class Maybe<T> {
  constructor(this: Just<T> | Nothing, public value: T | undefined) {}
  isJust(): this is Just<T> { return this.value !== undefined }
}
interface Just<T> { value: T }
interface Nothing { value: undefined }

if (x.isJust()) {
  x; // Just<string>
  x.value // string
} else {
  x; // Nothing
  x.value; // undefined
}

The problem is this...

type Maybe<T> = { value: T | undefined }
type Test1 = Maybe<string>
type Test1IfBranch = Test1 & { value: string } // { value: string }
type Test1ElseBranch = Exclude<Test1, Test1IfBranch> // { value: string | undefined } (no good)

type MaybeWithThisAnnotated<T> = { value: T } | { value: undefined }
type Test2 = MaybeWithThisAnnotated<string>
type Test2IfBranch = Test2 & { value: string } // { value: string }
type Test2ElseBranch = Exclude<Test2, Test2IfBranch> // { value: undefined } (nice)

Navigation Menu

Repository navigation

Allow method type guards #11117

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Allow method type guards #11117

Description

Activity

kitsonk commented on Sep 24, 2016

aluanhaddad commented on Sep 24, 2016

mattmazzola commented on Jul 12, 2017

DanielRosenwasser commented on Jul 12, 2017

mattmazzola commented on Jul 13, 2017

masaeedu commented on Dec 28, 2017

sgronblo commented on Feb 28, 2020

rodrigost23 commented on Sep 5, 2020

devanshj commented on Aug 5, 2021

devanshj commented on Aug 5, 2021

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions