Type guard for union types

[zolomatok]

It would be great if we could use is or as something similar to disambiguate between types in a union type, especially if they are not primitives (so when typeof doesn't help). Eg:

interface Something
    someVar: string

interface SomeOtherThing
    someOtherVar: string

function test(s: Something | SomeOtherThing)
     if s is Something
          console.log s.someVar
     else if s is SomeOtherThing
          console.log s.someOtherVar

[zolomatok]

As far as I know this kind of thing is only possible with user-defined type predicates, which are a chore.

[edemaine]

If I understand it correctly, I think DeepKit offers one approach to doing this.

[zolomatok]

Thanks for the suggestion @edamaine!
DeepKit seems like a huge framework though, I wouldn't use anything that sprawling.

[edemaine]

Related, I'm really looking forward to when I can use this in pattern matching:

interface point
  x: number
  y: string
switch v
  <? point
    ...
---
interface point {
  x: number
  y: string
}
if (typeof v === "object" && v != null && typeof(v.x) === "number" && typeof(v.y) === "string") {
  ...
}

Before we understand type references though (looking up point is tricky), we could aim for something like this (based on one of the #126 proposals):

switch v
  {x:: number, y:: string}

(originally posted #296 (comment))

[zolomatok]

switch v
  {x:: number, y:: string}

Would checking the prototype allow for checking if it conforms to an interface?
Or would this only be for primitives?

Also if we're making instanceof work in pattern matching ...

interface point
  x: number
  y: string
switch v
  <? point
    ...

... I guess then this would make if x <? point valid too?
Though I kinda like if x is point more, if that's possible.

I guess we could also just use discriminated unions for working with interfaces ...

interface Cow
    type: 'cow'
    giveMilk : =>

interface Dog
    type: 'dog'
    bark : =>

function doSomething(animal: Cow | Dog)
    switch animal.type
        when 'cow' then animal.giveMilk()
        when 'dog' then animal.bark()

... but that would be best done with enums for the type field for type safety.