Defining type constraints for function var args | TypeScript Community | Page 1

somber rivet May 9, 2024, 2:32 PM

#

Hi everyone, I'm trying to define types for a function I have defined a couple of months ago in javascript. The function itself accepts a series of arguments whose rule generally goes by:

no. arguments must be even
for every args[i] where i % 2 == 0 with type T there must be an args[i+1] having type (x: T) => any

This is what I've came up in a couple of hours. Even tho it makes sense to me logically, typescript does not seem to want it. The compiler complains: "Expected 0 arguments, but got 2.ts(2554)", seemingly not matching any type at all

type FunctionTaking<T> = (x: T) => unknown
type ValidPatternType = Record<string, any> | Record<string, never> | Array<unknown> | null | number | string
type FlattenPairs<T> = T extends [infer U, infer F, ...infer Rest]
  ? U extends ValidPatternType
    ? F extends FunctionTaking<U>
      ? Rest extends Array<unknown>
        ? [U, F, ...FlattenPairs<Rest>]
        : [U, F]
      : []
    : []
  : []

function matchArgs<T extends Array<unknown>>(...args: FlattenPairs<T>): void {
  console.log(args)
}

matchArgs(5, (test: number) => test) // Error: Expected 0 arguments, but got 2.ts(2554)

wet bridge May 9, 2024, 2:38 PM

#

i suspect you're going to need to write out a bunch of cases up to some limit. does the real version of this function return a type that depends at all on the parameters?

somber rivet May 9, 2024, 2:40 PM

#

Yes it does but i'ill take care of it after i get something to work on the parameters as it is what i care about the most

wet bridge May 9, 2024, 2:41 PM

#

i ask because it's relevant to what strategy i suggest. you'll probably want to use overload signatures if the answer is "yes", otherwise you could just use a union type for the args

#

is having a fixed limit acceptable? how many args do you actually apply in reality?

somber rivet May 9, 2024, 2:45 PM

#

wet bridge i suspect you're going to need to write out a bunch of cases up to some limit. d...

Well, I don't really know this is a function that implements a sort of pattern matching construct. It's up to the user how many patterns he puts in there, could be dozens

#

const testObject = {
  firstName: 'foo',
  lastName: 'baz',
  points: [
    { x: 10, y: 12 },
    { x: 0, y: 1 }
  ],
  timeMetrics: {
    range: { from: 0, to: 100 },
    units: 'seconds',
    target: 12
  }
} 

const result = match(
  {
    firstName: String,
    lastName: 'baz',
    points: [{ x: 10, y: match.any }]
  },
  ({ firstName, points: [{ y }] }) => `${firstName} is at y: ${y}`,

  {
    firstName: String,
    lastName: match.any
  },
  ({ firstName, lastName }) => `${firstName} has last name: ${lastName}`,

  null, _ => 'default case'
)(testObject)

#

This is an example of the js library

wet bridge May 9, 2024, 2:47 PM

#

if it's like a dozen then having separate cases might be reasonable. more than that it'll probably be too unwieldy

#

do you have the ability/desire to change the JS API at all? i think this could be done more easily via method chaining or even just by wrapping each pair into its own tuple

runic vortex May 9, 2024, 2:49 PM

#

Here's a solution:

thorn harborBOT May 9, 2024, 2:49 PM

#

nonspicyburrito#0

Playground Link

Preview:```ts
type ValidateArgs<T> = T extends [infer A, ...infer R]
? R extends [unknown, ...infer R]
? [A, (arg: A) => unknown, ...ValidateArgs<R>]
: []
: T

declare const fn: <const T extends unknown[]>(...args: ValidateArgs<T>) => {}

// should pass
...```

wet bridge May 9, 2024, 2:49 PM

#

ah, i was assuming they wanted inferred function arg types

somber rivet May 9, 2024, 2:49 PM

#

Yes, but that would be the easy way. I'd like to leave the syntax as it is, cause it looks familiar with other languages

runic vortex May 9, 2024, 2:50 PM

#

Oh, do you want inferring the function type too?

somber rivet May 9, 2024, 2:50 PM

#

Yep

#

Looks clean tho

wet bridge May 9, 2024, 2:51 PM

#

you could mix my suggestion with @runic vortex's. have nice typing via overloads up to some limit, but support an arbitrary amount as long as they're annotated

runic vortex May 9, 2024, 2:51 PM

#

Yeah I'm not sure if it's doable to infer function argument type (other than writing out a bunch of overloads), with explicit type though the solution I gave should work.

wet bridge May 9, 2024, 2:55 PM

#

here's an example of the overload solution, in case it's not obvious:

thorn harborBOT May 9, 2024, 2:55 PM

#

mkantor#0

Playground Link

Preview:```ts
function matchArgs<A, B extends (a: A) => unknown>(
a: A,
b: B
): void
function matchArgs<
A,
B extends (a: A) => unknown,
C,
D extends (a: C) => unknown

(a: A, b: B, c: C, d: D): void
function matchArgs<
A,
B extends (x: A) => unknown,
C,
D extends (x: C) => unknown
...```

wet bridge May 9, 2024, 2:56 PM

#

wet bridge you could mix my suggestion with <@451999506918277131>'s. have nice typing via o...

you could add a final overload signature that looks like what Burrito shared to pull this off

somber rivet May 9, 2024, 2:58 PM

#

Looks good

#

But I don't understand how @runic vortex 's one would NOT infer functions input params

runic vortex May 9, 2024, 2:59 PM

#

If you are willing to change your API design, you can do this:

thorn harborBOT May 9, 2024, 2:59 PM

#

nonspicyburrito#0

Playground Link

Preview:```ts
declare const fn: <A extends unknown[]>(
...args: {
[K in keyof A]: {
case: A[K]
then: (arg: A[K]) => unknown
}
}
) => void

fn(
{case: 42, then: arg => {}},
// ^?
{case: "hello", then
...```

wet bridge May 9, 2024, 2:59 PM

#

yeah, that's similar to what i was thinking when i suggested wrapping the pairs in tuples

wet bridge May 9, 2024, 3:00 PM

#

somber rivet But I don't understand how <@451999506918277131> 's one would NOT infer function...

the validator type is checking whether the array elements conform to the expected types, and to do that the types have to already be known. i don't think TS can go back and run inference again when it's partway through checking an array like this

runic vortex May 9, 2024, 3:00 PM

#

Oh yeah tuple is a good idea, also works and looks cleaner.

thorn harborBOT May 9, 2024, 3:00 PM

#

nonspicyburrito#0

Playground Link

Preview:```ts
declare const fn: <A extends unknown[]>(
...args: {
[K in keyof A]: [A[K], (arg: A[K]) => unknown]
}
) => void

fn(
[42, arg => {}],
// ^?
["hello", arg => {}],
// ^?
[{foo: 42, bar: "hello"}, arg => {
...```

wet bridge May 9, 2024, 3:02 PM

#

wet bridge the validator type is checking whether the array elements conform to the expecte...

although writing this makes me realize i can probably cut the number of type parameters needed for the overload version in half 🤔

wet bridge May 9, 2024, 3:04 PM

#

wet bridge although writing this makes me realize i can probably cut the number of type par...

yeah, this works and is less verbose:

thorn harborBOT May 9, 2024, 3:04 PM

#

mkantor#0

Playground Link

Preview:```ts
type CaseFn<A> = (a: A) => unknown

function matchArgs<A>(a: A, af: CaseFn<A>): void
function matchArgs<A, B>(
a: A,
af: CaseFn<A>,
b: B,
bf: CaseFn<B>
): void
function matchArgs<A, B, C>(
a: A,
af: CaseFn<A>,
b: B,
bf: CaseFn<B>,
c: C,
cf: CaseFn<C>
...```

somber rivet May 9, 2024, 3:20 PM

#

wet bridge the validator type is checking whether the array elements conform to the expecte...

Ok ok, this makes sense. I noticed that if you type in a () in place of the function the lsp is able to give you a type hint with : __type(arg: number): unkown

somber rivet May 9, 2024, 3:21 PM

#

thorn harbor

But it does that only after typing in some valid expression, which I don't like too much. For the sake of simplicity I might go down this path even tho the predefined overloads idea is great too!

somber rivet May 9, 2024, 4:24 PM

#

function match<A extends unknown[], R>(
  ...args: {
    [K in keyof A]: {
      when: A[K]
      then: (arg: A[K]) => R
    }
  }
): (arg: unknown) => R {
  return (arg: unknown) => args[0].then(undefined)
}

match(
  { when: 5, then: test => test.toString() },
  { when: 'string', then: v => v },
  { when: { name: 'a', surname: 'b' }, then: ({ name, ...other }) => name + `${JSON.stringify(other)}` },
  { when: [{ v: 'hello' }], then: ([{ v }]) => v },
  { when: 5, then: v => v }
)({})

#

i'd like { when: 5, then: v => v }to give a compilation error because it is not consisent with the return type of the other then functions

#Defining type constraints for function var args