arktype•2mo ago

Inference issues while trying to be generic over a type

I am trying to create a form state helper function that takes a schema and an initial value. I am not getting any ts errors but the type of form infers to "anyOrNever" & Record<string, unknown> this is the relevant function

import { type } from 'arktype'
import { createStore } from 'solid-js/store'

import { throwOnParseError } from './arktype'

function createForm<T extends Record<string, unknown>, TSchema extends type<T>>(
  schema: TSchema,
  initial: NoInfer<TSchema['inferIn']>,
) {
  const initialFormState = () => structuredClone(initial)
  const [form, setForm] = createStore(
    throwOnParseError(schema(initialFormState())),
  )
  const [formErrors, setFormErrors] = createStore<
    Partial<Record<'form' | keyof typeof schema.infer, string[]>>
  >({})
  function resetForm() {
    setForm(throwOnParseError(schema(initialFormState())))
    setFormErrors({})
  }

  return [
    { form, formErrors },
    { setForm, setFormErrors, resetForm },
  ] as const
}

import { type } from 'arktype'
import { createStore } from 'solid-js/store'

import { throwOnParseError } from './arktype'

function createForm<T extends Record<string, unknown>, TSchema extends type<T>>(
  schema: TSchema,
  initial: NoInfer<TSchema['inferIn']>,
) {
  const initialFormState = () => structuredClone(initial)
  const [form, setForm] = createStore(
    throwOnParseError(schema(initialFormState())),
  )
  const [formErrors, setFormErrors] = createStore<
    Partial<Record<'form' | keyof typeof schema.infer, string[]>>
  >({})
  function resetForm() {
    setForm(throwOnParseError(schema(initialFormState())))
    setFormErrors({})
  }

  return [
    { form, formErrors },
    { setForm, setFormErrors, resetForm },
  ] as const
}

this is example usage with the inference issue

const formSchema = type({
  appId: 'string',
  nodePath: 'string.trim',
  id: type('string | undefined').pipe((v) => v ?? nanoid()),
  title: type('string.trim'),
})
const [{ form, formErrors }, { resetForm, setForm, setFormErrors }] =
  createForm(formSchema, {
    title: '',
    appId: appContext.id,
    nodePath: appContext.path,
    id: nanoid(),
  })

const formSchema = type({
  appId: 'string',
  nodePath: 'string.trim',
  id: type('string | undefined').pipe((v) => v ?? nanoid()),
  title: type('string.trim'),
})
const [{ form, formErrors }, { resetForm, setForm, setFormErrors }] =
  createForm(formSchema, {
    title: '',
    appId: appContext.id,
    nodePath: appContext.path,
    id: nanoid(),
  })

would appreciate any help 🙂

14 Replies

ssalbdivad•2mo ago

Are you using 2.1+? Some inference changes might help here. Would also recommend using type.Any as your base type instead of just type (or type.Any<T>)

Raqueebuddin AzizOP•2mo ago

using just type.Any fixes it but now it's inferred as any which is not helpful and using type.Any<T> gives the following error

Argument of type 'Exclude<finalizeDistillation<T, _distill<T, "out", never>>, ArkErrors>' is not assignable to parameter of type 'object | undefined'.

Argument of type 'Exclude<finalizeDistillation<T, _distill<T, "out", never>>, ArkErrors>' is not assignable to parameter of type 'object | undefined'.

ssalbdivad•2mo ago

In what context?

Raqueebuddin AzizOP•2mo ago

basically createStore expects object | undefined the exclude comes from throwOnParseError removing the throw wrapper

Argument of type 'ArkErrors | finalizeDistillation<T, _distill<T, "out", never>>' is not assignable to parameter of type 'object | undefined'.

Argument of type 'ArkErrors | finalizeDistillation<T, _distill<T, "out", never>>' is not assignable to parameter of type 'object | undefined'.

ssalbdivad•2mo ago

So your problem is within the implementation itself Just use an overload TS cannot infer generic parameters well within a function like this

Raqueebuddin AzizOP•2mo ago

function createForm<T extends Record<string, unknown>, TSchema extends type.Any<T>>(
    schema: TSchema,
    initial: NoInfer<TSchema['inferIn']>
) {

function createForm<T extends Record<string, unknown>, TSchema extends type.Any<T>>(
    schema: TSchema,
    initial: NoInfer<TSchema['inferIn']>
) {

ssalbdivad•2mo ago

The point for something like this is that the signature is safe and inferred correctly, the implementation of that generic itself TS does a terrible job with You almost always have to cast any non-trivial generic function implementation

Raqueebuddin AzizOP•2mo ago

can I cast to TSchema['infer'] is that what you mean? or T directly

ssalbdivad•2mo ago

Yeah cast to what the correct external result is or just cast to never or something so it allows however you type the signature Whenever you implement generics like that in TS you don't get safety within the implementation but you get safety and precision externally that's the important part

Raqueebuddin AzizOP•2mo ago

got it, thanks

ssalbdivad•2mo ago

Another way to do it is overloads like this: https://discord.com/channels/957797212103016458/1289555141355241573/1290384921772167168 But it's just another form of casting

Raqueebuddin AzizOP•2mo ago

thanks I'll look into it this worked in the end, greatly appreciate the help was stuck for hours on this

function createForm<TSchema extends type.Any>(
    schema: TSchema,
    initial: NoInfer<TSchema['inferIn']>
) {
    const initialFormState = () => structuredClone(initial);
    const [form, setForm] = createStore(throwOnParseError(schema(initialFormState())) as TSchema['infer']);
    const [formErrors, setFormErrors] = createStore<
        Partial<Record<'form' | keyof typeof schema.infer, string[]>>
    >({});
    function resetForm() {
        setForm(throwOnParseError(schema(initialFormState())));
        setFormErrors({});
    }

    return [
        { form, formErrors },
        { setForm, setFormErrors, resetForm }
    ] as const;
}

function createForm<TSchema extends type.Any>(
    schema: TSchema,
    initial: NoInfer<TSchema['inferIn']>
) {
    const initialFormState = () => structuredClone(initial);
    const [form, setForm] = createStore(throwOnParseError(schema(initialFormState())) as TSchema['infer']);
    const [formErrors, setFormErrors] = createStore<
        Partial<Record<'form' | keyof typeof schema.infer, string[]>>
    >({});
    function resetForm() {
        setForm(throwOnParseError(schema(initialFormState())));
        setFormErrors({});
    }

    return [
        { form, formErrors },
        { setForm, setFormErrors, resetForm }
    ] as const;
}

is there a way to make sure somebody can only pass a schema that is object like basically Record<string, unknown>

ssalbdivad•2mo ago

I usually tend to prefer object over Record<string, unknown> unless I really am just trying to allow index access on a value. You should be able to use extends type.Any<object> ideally

Raqueebuddin AzizOP•2mo ago

Thanks again

Gaming

Programming

Inference issues while trying to be generic over a type

Did you find this page helpful?