Reusing function parameter in TypeScript

Question

This will take a bit to explain.

I have a class called Dependency, which holds a value of generic type T and provides some helper methods (not really relevant here):

class Dependency<T> {
    value: T
    ...
}

I'm trying to write another class, Derivative, that takes a list of dependencies and a derive function to generate some other value:

type DependencyArray = Array<Dependency<any>>
type DeriveFunc<T, D extends DependencyArray = DependencyArray> = (...deps: D) => Promise<T>

class Derivative<T, D extends DependencyArray = DependencyArray> {
    value: T
    constructor(
        dependencies: D,
        derive: DeriveFunc<T, D>,
    ) { ... }
}

Here's the catch – I want to restrict derive to only accept dependencies provided by first argument to Derivative constructor. For example:

const depA = new Dependency<string>()
const depB = new Dependency<boolean>()

// Good: this one compiles
const new Derivative<string>([depA, depB], async ([a, b]) => `${a}-${b}`)

// Good: these two fail to compile, since arrays aren't the same length
// TS2345: Source has 2 element(s) but target allows only 1.
const new Derivative<string>([depA, depB], async ([a]) => `${a}`)
const new Derivative<string>([depA], async ([a, b]) => `${a}`)

// Bad: in this one, `derive` function doesn't understand which types are in dependency array, so it merges it to Dependency<string | boolean>[]
// TS2339: Property 'length' does not exist on type 'boolean | string'.
//     Property 'length' does not exist on type 'false'.
const new Derivative<string>([depA, depB], async ([a, b]) => `${a.length}-${b}`)

Is there a way to reference exactly the dependencies that were passed to Derivative constructor?

TopchetoEU · Accepted Answer · 2023-02-06 18:06:20Z

1

Currently, TypeScript doesn't support what you're trying to do, since the types of array literals ([1, 5, true, null]) aren't imlied to tuples ([ number, number, boolean, null]), but instead to an array type ((number | boolean | null)[]). Unfortunately, there's nothing you can do about it. There's an issue you can take a look at, it describes exactly what you're trying to do.

Regardless, you can use the spread syntax instead:

class Derivative<T, D extends DependencyArray = DependencyArray> {
    value: T
    constructor(
        derive: DeriveFunc<T, D>,
        ...dependencies: D
    ) { ... }
}

In this way, argument types will get implied correctly. Unfortunately, there are no other workarounds, and if you want to use an array, you don't have a particular choice.

answered Feb 6, 2023 at 18:06

TopchetoEU

6875 silver badges12 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

roboslone · Accepted Answer · 2023-02-06 18:11:38Z

0

It turns out using objects instead of arrays works just fine. I had to switch to something like that:

type DependencyMap = { [key: string]: Dependency<any> }
type DeriveFunc<T, D> = (deps: D) => Promise<T>

const new Derivative<string>({ depA, depB }, async ({ depA, depB }) => `${depA.length}-${depB}`)

answered Feb 6, 2023 at 18:11

roboslone

3,2034 gold badges23 silver badges29 bronze badges

Collectives™ on Stack Overflow

Reusing function parameter in TypeScript

2 Answers 2

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related