why is compile-time error occurring in the code

[remoteTest]

The code comes from the website(http://www.typescriptlang.org/docs/handbook/advanced-types.html) :

function extend<T, U>(first: T, second: U): T & U {
    let result = <T & U>{};
    for (let id in first) {
        (<any>result)[id] = (<any>first)[id];
    }
    for (let id in second) {
        if (!result.hasOwnProperty(id)) {
            result)[id] = second[id];
        }
    }
    return result;
}

modify the code slightly：

function extend<T, U>(first: T, second: U): T & U {
    let result = <T & U>{};
    for (let id in first) {
        result[id] = first[id];
    }
    for (let id in second) {
        if (!result.hasOwnProperty(id)) {
            (<any>result)[id] = (<any>second)[id];
        }
    }
    return result;
}

Just remove the type assertion for result and first in the fourth line。
I thought that the code above will be correct，because result is defined as T & U which is considered a type containing both properties from T and U, so that accessing result[keyof T] is valid, since keyof T is assignable to keyof (T & U)。

[porglezomp]

Hey, please change your code blocks to be

```typescript
code
```

instead of `code` to make your code blocks readable. It's very hard to tell what the problem is with the current form.

[remoteTest]

@porglezomp thank you very much
I have changed the formate

[ikatyang]

any is assignable to everything, so that result[id] = (<any>first)[id] is valid.

first //=> T
<any>first //=> any
(<any>first)[id] //=> any

---

The reason there is an <any> before the result is that TS inferred id as string instead of keyof T in the past, the docs needs update.

EDIT: fix typo

[ikatyang]

result is defined as T & U, that is, it is considered a type contains both properties from T and U, so that access result[keyof T] is valid, since keyof T is assignable to keyof (T & U), for example:

type First = {a: number, b: string};
type Result = First & {c: boolean};

type Id = keyof First; //=> 'a' | 'b'
type ResultId = keyof Result; //=> 'a' | 'b' | 'c'

declare const result: Result;
declare const id: Id;
declare const resultId: ResultId;

result[id] //=> string | number
result[resultId] //=> string | number | boolean

[ikatyang]

Ah, I'm just explaining the type-level operation, see #12936 and #12936 (comment) for those needs exact types.

[remoteTest]

@ikatyang
thank you very much
because of your answer ，I think of some other questions.
so ,i modefied the question

[remoteTest]

@ikatyang
您好，如果有时间，用汉语帮我解释一下吧，我又修改了一下问题，如果按照您的思路，result[id] = first[id]这样就是正确的，但是实际上会报错

[ikatyang]

@softwhygo T 和 U 的交集有可能会导致某一属性冲突，就像下面的例子：

(T & U)[key] might be conflict with T[key], consider the following case:

interface T1 {
    a: boolean;
    b: string;
}

interface T2 {
    a: boolean;
    b: number;
}

type T = T1 & T2;

type Ta = T['a']; //=> boolean
type Tb = T['b']; //=> string & number

declare const t: T;
declare const t1: T1;

    t['b'] = t1['b'];
//  ^^^^^^ [ts]
//         Type 'string' is not assignable to type 'string & number'.
//           Type 'string' is not assignable to type 'number'.

[remoteTest]

@ikatyang 非常感谢台湾的朋友，我来自山东青岛，欢迎来玩