#why infer this need decomposition ?

4 messages · Page 1 of 1 (latest)

clever acorn
#

why the case 1 not work ?
it a bug ?

export type This1<S extends System=System> = S extends infer SS
    ? SS extends System< infer RU >
        ? RU extends [infer M, infer R, infer A ]
            ? [M, R, A, 100]
            : never
        : never
    : never;
export type This2<S extends System=System> = S extends System< infer RU >
    ? RU extends [infer M, infer R, infer A ]
        ? [[M, R, A, 100]]
        : never
    : never
export abstract class System<T extends number[] = number[]> {
    abstract rules: T;
}

export class SystemA {
    declare rules:[1, 2, 3];
    test1( o: This1<this> ): void {
        isTest( o );
        isTest2( o ); //🟥 why this not work !? 
    }

    test2([o]: This2<this> ): void {
        isTest( o );
        isTest2( o ); //🟢 ok here !
    }
}

function isTest<T extends [1, 2, 3, 100]>( t: T ): T {
    return t;
}
function isTest2<T extends [1, 2, 3]>( t: T ): T {
    return t;
}
olive basinBOT
#
jonlepage#0
Playground Link

Preview:ts export type This1<S extends System = System> = S extends infer SS ? SS extends System<infer RU> ? RU extends [infer M, infer R, infer A] ? [M, R, A, 100] : never : never : never export type This2<S extends System = System> = S extends System<infer RU> ? RU ext ...

You can choose specific lines to embed by selecting them before copying the link.
cyan wolf
#

Yea, ummm, one useful thing to remember is that typescript is not doing a really good job at correctly mapping function arguments when used in a complex situation with generics. As I see it, and guessing a bit, I think that it is evaluating the type only when accessed (like: o[3] = 100 ), but don't quote me on that. A way to fix that is to make it an object and destructure it, forcing the checker to accurately map the type like this: ```typescript
export type This1<S extends System=System> = S extends infer SS
? SS extends System< infer RU >
? RU extends [infer M, infer R, infer A ]
? { o: [M, R, A, 100] }
: never
: never
: never;
export type This2<S extends System=System> = S extends System< infer RU >
? RU extends [infer M, infer R, infer A ]
? [[M, R, A, 100]]
: never
: never
export abstract class System<T extends number[] = number[]> {
abstract rules: T;
}

export class SystemA {
declare rules:[1, 2, 3];
test1( { o }: This1<this> ): void {
isTest( o );
isTest2( o ); //🟢 This should now work
}

test2([o]: This2<this> ): void {
    isTest( o );
    isTest2( o ); //🟢 ok here !
}

}

function isTest<T extends [1, 2, 3, 100]>( t: T ): T {
return t;
}
function isTest2<T extends [1, 2, 3]>( t: T ): T {
return t;
}```

#

That's why the test2 function, worked in the first place. It destructured the array and narrowed down the inner array