Inferring generic types

Hi, I'm new to ArkType and have little knowledge about TypeScript generic. I wish I had something like below:

import { type } from "arktype"

const boxOf = type("<t>", { box: "t" })

type BoxOf<t> = typeof boxOf.infer<t> // not working for Generic

import { type } from "arktype"

const boxOf = type("<t>", { box: "t" })

type BoxOf<t> = typeof boxOf.infer<t> // not working for Generic

Currently I've manually define the type to match the schema. What am I missing, or is there any workaround? Thanks in advance.

18 Replies

Dimava•3w ago

RTFM HKT Generics https://arktype.io/docs/generics#hkt Its advanced TS stuff so if you have any more questions you are welcome to ask

ArkType Docs

TypeScript's 1:1 validator, optimized from editor to runtime

Dimava•3w ago

Hmm wait you need the types Lemme think

LukeAbby•3w ago

So this isn't so hard if your input to BoxOf<t> is an arktype input itself:

const boxOf = type("<t>", { box: "t" });

type BoxOf<t> = ReturnType<typeof boxOf<t>>;

type Test = BoxOf<"123">;
//   ^ Type<{ box: 123 }, {}>

const boxOf = type("<t>", { box: "t" });

type BoxOf<t> = ReturnType<typeof boxOf<t>>;

type Test = BoxOf<"123">;
//   ^ Type<{ box: 123 }, {}>

but if you want BoxOf<123> to return Type<{ box: 123 }, {} or { box: 123 } this is trickier This works:

type BoxOf<t> = type.instantiate<
    typeof boxOf["bodyDef"],
    { t: t }
>;

type Test = BoxOf<123>;
//   ^ Type<{ box: 123 }, {}>;

type BoxOf<t> = type.instantiate<
    typeof boxOf["bodyDef"],
    { t: t }
>;

type Test = BoxOf<123>;
//   ^ Type<{ box: 123 }, {}>;

If you want the basic type (i.e. not wrapped in Type) then this'd be the way:

type BoxOf<t> = type.instantiate<
    typeof boxOf["bodyDef"],
    { t: t }
>["t"];

type BoxOf<t> = type.instantiate<
    typeof boxOf["bodyDef"],
    { t: t }
>["t"];

@guersam

guersamOP•3w ago

It's exactly what I want. Thank you very much! Is there any change to put this trick into Generic 's interface to match type(...).infer?

LukeAbby•3w ago

You could declaration merge it in yourself But maybe @ssalbdivad would be amenable to a PR to add it to core. The design I would recommend would be Generic<...>.instantiate<T>. e.g. use as typeof boxOf.instantiate<123>

guersamOP•3w ago

It must be fun to learn some TS generics at this chance, thanks! At first I thought it should be .infer, but your recommendation sounds better as TS doesn't seem to have support for point free HKT.

LukeAbby•3w ago

Do you mean point free as in .s or https://wiki.haskell.org/Pointfree

Pointfree

guersamOP•3w ago

I mean the latter.

LukeAbby•3w ago

Yeah the deeper problem in this case is that (typeof boxOf)["instantiate"] means a fundamentally different thing than typeof boxOf.instantiate (typeof boxOf)["instantiate"] means "get the instantiate property of typeof boxOf (Generic)" typeof boxOf.instantiate means "get the typeof boxOf.instantiate" you can't write (typeof boxOf)["instantiate"]<...> because you're working with a type you can write typeof boxOf.instantiate<...> because the parens actually look like typeof (boxOf.instantiate<...>) point-free HKTs would help in a way but then you'd have to overload the meaning of .infer which tbf is perhaps viable

guersamOP•3w ago

Thanks for the explanation. I'm still struggling and decided to stick to your first solution for now.

declare module 'arktype' {
  interface Generic<params, bodyDef, $ = {}> {
    instantiate<T>(): type.instantiate<bodyDef, { [K in params[0][0]]: T }>["t"]
    get instantiate<T>(): type.instantiate<bodyDef, { [K in params[0][0]]: T }>["t"] // ERROR: An accessor cannot have type parameters.
  }
}

type BoxOf<t> = typeof boxOf.instantiate<t>; 

// BoxOf<number> == () => { box: number }
// BoxOf<number> != { box: number }

type BoxOf<t> = typeof boxOf.instantiate<t>(); // cannot use parens here

declare module 'arktype' {
  interface Generic<params, bodyDef, $ = {}> {
    instantiate<T>(): type.instantiate<bodyDef, { [K in params[0][0]]: T }>["t"]
    get instantiate<T>(): type.instantiate<bodyDef, { [K in params[0][0]]: T }>["t"] // ERROR: An accessor cannot have type parameters.
  }
}

type BoxOf<t> = typeof boxOf.instantiate<t>; 

// BoxOf<number> == () => { box: number }
// BoxOf<number> != { box: number }

type BoxOf<t> = typeof boxOf.instantiate<t>(); // cannot use parens here

And I just realized the exact name t matters

LukeAbby•3w ago

well it matters because that's the name of the param

guersamOP•3w ago

I misunderstood. It emitted type error when I changed <t> with something else, but that was irrelevant. Arbitrary names work

LukeAbby•3w ago

ah I thought you meant <T> elsewhere; like ["t"] or such Anyways ReturnType<typeof boxOf.instantiate<t>> is admittedly a bit ugly and it'd probably be what'd be necessary

guersamOP•3w ago

Oh yes, ["t"] matters

LukeAbby•3w ago

so maybe a type.blah<generic, args> would be better I say blah because instantiate is already taken (though I guess it could be retrofitted here)

guersamOP•3w ago

ReturnType works, thanks! TS generic seems like just another language 😅 The definition of ReturnType is interesting

LukeAbby•3w ago

Type level TS may as well be another language

Dimava•2w ago

It is a language enough to run Doom in it

Gaming

Programming

Inferring generic types

Did you find this page helpful?