常連

### 実現したいこと

TypeScriptの型推論の話です。
フィールドを判別キーとしたユニオン型を定義したとき、そのキーからもとの型を推論する型を作りたいです。

例えば以下のような `Action` 型と、その判別キーの型 `ActionKey` 型があるとします。

```typescript
type ClickAction = {
 key: 'click';
 x: number;
 y: number;
}
type CopyAction = {
 key: 'copy';
 data: string;
}
type Action = ClickAction | CopyAction;

type ActionKey = Action['key'];
```

このとき、取りうる`ActionKey`によって本来の型を表す型 `ActionType<ActionKey>` を作りたいです。

```typescript
ActionType<'click'> // => ClickAction を表す
ActionType<'copy'> // =>CopyAction を表す
```

### 試したこと

以下のような定義の仕方で一応実現できているかと思います。

```typescript
type ClickAction = {
 key: 'click';
 x: number;
 y: number;
}
type CopyAction = {
 key: 'copy';
 data: string;
}
type ActionMap = {
 click: ClickAction;
 copy: CopyAction;
}
type ActionKey = keyof ActionMap;
type Action = ActionMap[ActionKey];
type ActionType<T extends ActionKey> = ActionMap[T];
```

ただ、このやり方では`Action`の追加時に`Action`の`key`フィールドと`ActionMap`のキーの文字列をあわせて追加しなければならず、少し保守性が悪いように思えます。
本当ならば `ActionMap` の定義など使わず、一撃で`ActionType`を作る方法があればよいのですが、何かアイデアありませんでしょうか。

TypeScriptのユニオン型の判別キーからもとの型を推論する方法

### 実現したいこと

「オブジェクトは 'undefined' である可能性があります。ts(2532)」のエラーが解決できない

### 前提
配列のデータをカテゴリーごとに分割して新しいオブジェクトを生成する

処理自体は完成したがTSのエラーが解消できない

### 発生している問題・エラーメッセージ

![イメージ説明](https://ddjkaamml8q8x.cloudfront.net/questions/2023-12-10/6567c237-1f2c-4263-ba20-659854fe93fe.png)

### 該当のソースコード


```
type BrandData = {
  brand: string
  color: string
  amount: number
}

type TransformedData = {
  [key: string]: {
    [key: string]: number[]
  }
}

  const data: BrandData[] = [
    {
      brand: 'aaa',
      color: 'red',
      amount: 1000,
    },
    {
      brand: 'aaa',
      color: 'red',
      amount: 2000,
    },
    {
      brand: 'bbb',
      color: 'blue',
      amount: 4000,
    },
  ]

  const transformedData = data.reduce((acc, item) => {
    const { brand, color, amount } = item

    if (!acc[brand]) {
      acc[brand] = {}
    }
    if (!acc[brand][color]) {
      acc[brand][color] = []
    }
    if (!acc[brand][color]?.includes(amount)) {
      acc[brand][color].push(amount)
    }

    return acc
  }, {} as TransformedData)

```

### 試したこと

1.anyの型を使用する
2.非nullアサーションを使用する
      if (!acc[brand]![color]) {}

この2つの方法では解消できましたが、lintのエラーに引っかかってしまうため別の解消方法が必要です



TSの型エラーが解消できない


typescript 型エラーを解決したい

Angularの開発を行っています。
typescriptの型エラーに毎日悩まされています。

初歩的な質問で申し訳ございませんが、
ご回答いただけますと幸いです。

以下のエラーメッセージが出ています。
「型 'number' を型 'Date' に割り当てることはできません。」

```typescript
import { Component, OnInit } from '@angular/core';

@Component({
  selector: 'app-hello',
  templateUrl: './hello.component.html',
  styleUrls: ['./hello.component.css']
})

export class HelloComponent implements OnInit {
  title: string = "";
  message: string = "";
  price: number = 1;
  now: Date = 2023/6/19/22/33/00;

  constructor() { }

  ngOnInit() {
    this.title = 'Hello-app';
    this.message = 'This is My First Component!!';
    this.price = 123450;
  }

  // 今日の日付と時間を表示する
  today() {
    return new Date().toLocaleString();
  }
}
```

typescript 型エラー

### 実現したいこと
Aクラスを継承するBクラスがあり、protected _params という同じ名前の内容の違うオブジェクトを持っています。Bでそのオブジェクトをオーバーライドし、型アサーションをしたのですが、Bの _paramsの型がAParamsから変更できません。

### 該当のソースコード
``` typescript
type AParams = {
  name: string,
  age: number,
  fuga: string;
};

class A {
  protected _params: AParams = {
    name: "A",
    age: 12,
    fuga: 'AA'
  };
}

type BParams = AParams & {
  name: string,
  age: number,
  hoge: number;
};

class B extends A {
  constructor() {
    super();

    this._params = {
    ...this._params,
      name: "B",
      age: 12,
      hoge: 1
    } as BParams;
  }
}
``` 
### エラーメッセージ

クラスBの this._params は、AParams のままです。(vscode, typescript 5.2.2)

### 試したこと

PT3.5の提案も以下のものを試しましたがだめでした。
``` typescript
//1.
(this._params as BParams) = {
...this._params,
name: "B",
age: 12,
hoge: 1
}

//2.
this._params = {
...this._params,
name: "B",
age: 12,
hoge: 1
} as Bparams

//3.
this._params = {
super["_params"],
name: "B",
age: 12,
hoge: 1
}
```
よろしくお願いします。

親クラスと同じ名前のプロパティを上書きし、新たな型を与えたいです。

### 前提・実現したいこと
typescriptでオブジェクトをインスタンス化した際に動的に型付けを行いたい。
下記のコードで、obj1をインスタンス化する際に、型を{a:'01';b:'02'}となるように型定義を行いたいのですが、
どうしても、{a:string,b:string}と言った形になってしまいます。
ジェネリクスを用いて、obj1をインスタンス化の際に動的に型付けを行う方法を教えていただきたいです。
よろしくお願いします。


### 該当のソースコード

```typescript
type Obj01 = {
 a: string;
 b: string;
};
type K = keyof { a: string; b: string };

class ObjectWrapper<T extends Obj01> {
 private _obj: T;

 /***
 * 引数のオブジェクトのコピーを this._objに設定
 */
 constructor(_obj: T) {
 this._obj = { ..._obj };
 }

 /**
 * this._objのコピーを返却
 * @return Object
 */
 get obj() {
 return { ...this._obj };
 }

 /**
 * this._obj[key] に valを設定。keyがthis._objに存在しない場合、falseを返却
 * @param key オブジェクトのキー
 * @param val オブジェクトの値
 */
 set(key: K, val: string): boolean {
 if (this._obj[key] !== undefined) {
 console.log(typeof this._obj)
 console.log(typeof key)
 this._obj[key] = val;
 return true;
 }
 return false;
 }
}

const obj1 = { a: '01', b: '02' };
const wrappedObj1 = new ObjectWrapper(obj1);

if (wrappedObj1.obj.a === '01') {
 console.log('OK: get obj()');
} else {
 console.error('NG: get obj()');
}

if (
 wrappedObj1.set('c', '03') === false &&
 wrappedObj1.set('b', '04') === true &&
 wrappedObj1.obj.b === '04'
) {
 console.log('OK: set(key, val)');
} else {
 console.error('NG: set(key, val)');
}

```

Typescriptで動的に型定義をする方法について

下記2つのソースコードについての質問となります。
templateのほうではコンパイルエラーが起きず、
autoではコンパイルエラーが起きます。
自分の認識的にはテンプレートともautoも大きな違いがないと思っておりますが、
なぜautoではコンパイルエラーが発生してしまうのでしょうか？
ここら辺に理解がある方おりましたらよろしくお願いいたします。

```c++
template<class T>
class Delegate
{
	std::function<T(int)> a;
};
```

```c++
class Delegate
{
	std::function<auto(int)> a;
};
```

テンプレートとautoの違い

C言語を学んでから、C++を学んでいるものです。

C++のvectorの再実装をするためにllvmのソースコードリーティングをしています。そこで理解できないコードがあったので質問します。

```c++
template <class _Tp, _Tp __v>
struct integral_constant {
 static const _Tp value = __v;
 typedef _Tp value_type;
 typedef integral_constant type;
 operator value_type() const throw() { return value; } // <= これがわからない。
};
```

[libcxx/type_traits at master · llvm-mirror/libcxx](https://github.com/llvm-mirror/libcxx/blob/master/include/type_traits)


このクラスにおけるoperatorはどういった意味でしょうか。`typedef _Tp value_type;`でvalue_typeを型名として定義して、同名の関数定義？をすることで呼出元としてはどのように使用されるのでしょうか。

こちらをコメントアウトして実際に使ってみましたが、実行結果に差はなかったです。

```c++
namespace ft {

template <class _Tp, _Tp __v>
struct integral_constant
{
public:
 static const _Tp value = __v;
 typedef _Tp value_type;
 typedef integral_constant type;
 // operator value_type() const { return value; }
};

typedef integral_constant<bool, true> true_type;
typedef integral_constant<bool, false> false_type;

template <class T>
struct is_integral : public ft::false_type {};
template <class T>
struct is_integral<const T> : public is_integral<T> {};
template <class T>
struct is_integral<volatile T> : public is_integral<T> {};
template <class T>
struct is_integral<const volatile T> : public is_integral<T> {};

template<> struct is_integral<unsigned char> : public true_type {};
template<> struct is_integral<unsigned short> : public true_type{};
template<> struct is_integral<unsigned int> : public true_type{};
template<> struct is_integral<unsigned long> : public true_type{};
template<> struct is_integral<unsigned long long> : public true_type{};
template<> struct is_integral<signed char> : public true_type{};
template<> struct is_integral<char> : public true_type{};
template<> struct is_integral<short> : public true_type{};
template<> struct is_integral<int> : public true_type{};
template<> struct is_integral<long> : public true_type{};
template<> struct is_integral<long long> : public true_type{};
template<> struct is_integral<wchar_t> : public true_type{};
}
```

```c++
#include "my_is_integral.hpp"
#include <iostream>

int main()
{
 std::cout << ft::is_integral<int>::value << std::endl;
 std::cout << ft::is_integral<unsigned int>::value << std::endl;
 return 0;
}
```

C++　クラスの中で定義された変数と同名の関数の役割がわかりません。`operator value_type() ` llvmのソースコードリーティング

### 知りたいこと

以下のようなinterfaceを定義します。

```ts
interface Itest {
 (param1: string, param2: number): boolean;
}
```

このinterfaceは以下のように使用することができます。

```ts
const testF: Itest = (param1, param2) => {
 return true;
};
```

**どうしてこのように使用できるのかがわかりません**。
typescriptのinterfaceの実装方法について自分でも調べましたが、
このようなinterface内で無名関数のようなものを定義する実装方法について言及されている記事は見つかりませんでした。

また、Itestが以下のような定義の場合、hogeはどのように設定することになるのでしょうか。

```ts
interface Itest {
 (param1: string, param2: number): boolean;
 hoge: string;
}
```

### 質問の動機

Reactの理解を深めようと思い[React.FunctionComponentの型定義](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/react/index.d.ts#L539)を読んでいたところ、以下のような実装になっていました。

```ts
 interface FunctionComponent {
 (props: PropsWithChildren, context?: any): ReactElement<any, any> | null;
 propTypes?: WeakValidationMap;
 contextTypes?: ValidationMap<any>;
 defaultProps?: Partial;
 displayName?: string;
 }
```

２行目の`(props: PropsWithChildren, context?: any): ReactElement<any, any> | null;`の挙動について調べていましたが自分では解決できず、質問に至りました。

どなたかご教示いただくか、もしくはこの定義方法について言及されているドキュメントのリンクを教えてもらえると幸いです。
宜しくお願い致します。