property circularly references on destructing objects but working properly without destructing

[tianzhich]

TypeScript Version: v4.1.0-dev.20200826 (Nightly)

Search Terms: Type of property x circularly references itself in mapped type xx.

Code

type Extract<Root extends Record<string, any>> = {
    [key in keyof Root]: Root[key]
}

type Effects<T> = (p: Extract<T>) => void

export const create: <Root extends Record<string, any>>() => <
    E extends Effects<Root>,
    S extends Record<string, any>
    >(mo: {
        state?: S;
        effects?: E
    }) => {
        state: S;
        effects: E
    } = () => (p): any => p

interface Root {
    foo: typeof foo
}

const foo = create<Root>()({
    state: {
        bar: 1
    },
    // effects: (dispatch) => {
    //     // worked without destructing dispatch
    //     console.log(dispatch.foo.state.bar);
    // },
    effects: ({ foo }) => {
        // failed with destructing
        console.log(foo.state.bar);
    },
})

Expected behavior:
no errors with dispatch destructed.

Actual behavior:
errors occurred when destructing dispatch, but no errors while using it directly.

Playground Link:
https://www.typescriptlang.org/play?ts=4.1.0-dev.20200826&ssl=33&ssc=7&pln=30&pc=5#code/C4TwDgpgBAogHsATgQwMbADwCUD2PhQQIQB2AJgM5RYSo6JkYVICWJA5gDRTIkgB8-KAF4oAbwBQUaVADaAawggobKIpA4AZtTzAAugC4d+BUr0SAvhImhIsTZtrAKGACpDRACjBH4SNJjuAJQiQgBuOCxk1kRg9AR0JMxQqIgQyMAQRti6hMTkVDR0DEysHNy8AvyeIcJCGFIyMHmZBfaO6C64+PycjdIAyi2klNS09IzMiGxcPHz8-VDVALY4RpIym1DMGRAA-EYDANyLmxAOThQHsIsWtUIbW9I7mYcnT9LnHc6+tyJQNVCALAQSMlSBYGsbEyiE0aGg3QIj2kmjwRlsEC0UFROEs1kSyRx-1S6UyOR6NU8yO2wF261OMgARshEEYAIy3PqbAD03MIF06Rk8ZBYFDAGVQAAt7uJFrytvKAO70RRkKCKljASU4ACuBDIECmOvQMygIrFEslcr5mwJOAANhAAHT2nDsYWi8XAKVOnFOl7O5mIILvGTyixcmRfS5CsTYvBQO5A6k8vlwliOtUarVmw1IY3AGYM6R2x0ut2eP0Bp1BkOcyxBIA

Related Issues:
#37597
#35546

[tianzhich]

When using foo directly, not from param. This error trigged in v3.8.3 and its previous versions. But after this like v3.9.2, it was fixed.

So I think there should no cycle reference errors when referencing the foo inside its initializer no matter from itself or function params.

[tianzhich]

BTW, destructing inside the function also works. Are there any differences? In my opinion, they are the same thing.

const foo = create<Root>()({
    state: {
        bar: 1
    },
    // effects: (dispatch) => {
    //     // worked without destructing dispatch
    //     console.log(dispatch.foo.state.bar);
    // },
    // effects: ({ foo }) => {
    //     // failed with destructing
    //     console.log(foo.state.bar);
    // },
    effects: (dispatch) => {
        // it also worked while destructing inside the function, any difference here?
        const { foo } = dispatch;
        console.log(foo.state.bar);
    },
})

[RyanCavanaugh]

These are different constructs and have different implications on type inference; in the destructuring case a circularity is in fact occurring

[semoal]

These are different constructs and have different implications on type inference; in the destructuring case a circularity is in fact occurring

So, isnt there any "workaround" to handle this?

[tianzhich]

These are different constructs and have different implications on type inference; in the destructuring case a circularity is in fact occurring

I do not understand well. But destructing param immediately or inside the function both worked with pure js. Is any workaround here?

[typescript-bot]

This issue has been marked 'Working as Intended' and has seen no recent activity. It has been automatically closed for house-keeping purposes.