Could Zod provide type guards for narrowing union types?

I am using v3 branch and would like to ask if it is possible for Zod to provide type guards? This will be handy when dealing with union types:

const ASchema = z.object({a: z.string()});
type A = z.infer<typeof ASchema>;

const BSchema = z.object({b: z.string()});
type B = z.infer<typeof BSchema>;

const ABSchema = z.union([ASchema, BSchema])
const AB = z.infer<typeof ABSchema>;  // { a: string } | { b: string}


function f(x: AB) {
   if (ASchema.guard(x)) {
       x.a   // x is A
   } else {
       x.b 
   }
}

[scotttrinh]

No type guards in Zod@3 due to how they interact with the transform feature, however you could definitely do this with parsing:

function f(x: AB) {
  const maybeA = ASchema.safeParse(x);
  if (maybeA.success) {
    maybeA.data.a // maybeA.data is A
  }

  const maybeB = BSchema.safeParse(x);
  if (maybeB.success) {
    maybeB.data.b // maybeB.data is B
  }

  throw new Error("Could not parse with ASchema or BSchema");
}

I’ve found that most unions want (or already have!) some kind of discriminant though, so in that case TypeScript is already smart enough to narrow the type if you check the discriminant.

const ASchema = z.object({ type: z.literal("A"), a: z.string() });
const BSchema = z.object({ type: z.literal("B"), b: z.string() });

const ABSchema = z.union([ASchema, BSchema]);
type AB = z.infer<typeof ABSchema>;

function f(x: AB) {
  switch (x.type) {
    case "A": {
      x.a // x is A
      break;
    }
    case "B": {
      x.b // x is B
      break;
    }
  }
}

[colinhacks]

Thanks Scott 👍

@redbaron I propose using a discriminated union for this. It’s the best way to handle unions like this:

  const ASchema = z.object({ kind: z.literal("a"), a: z.string() });
  const BSchema = z.object({ kind: z.literal("b"), b: z.string() });
  const ABSchema = z.union([ASchema, BSchema]);
  
  const value = ABSchema.parse("asdf");
  if (value.kind === "a") {
    value.a;
  }else{
    value.b;
  }