関数と型 — 引数・戻り値・オーバーロード

function add(a: number, b: number): number {
  return a + b;
}

const multiply = (a: number, b: number): number => a * b;

// 型エイリアスで関数の型に名前を付ける
type Comparator<T> = (a: T, b: T) => number;
 
const byAge: Comparator<{ age: number }> = (a, b) => a.age - b.age;

function greet(name: string, greeting?: string): string {
  // greeting の型は string | undefined になる
  return `${greeting ?? 'こんにちは'}、${name}さん`;
}
 
greet('田中'); // "こんにちは、田中さん" — 省略できる
greet('田中', 'おはよう'); // "おはよう、田中さん"

function greetWithDefault(name: string, greeting: string = 'こんにちは'): string {
  // greeting の型は string（undefined の可能性が消えている）
  return `${greeting}、${name}さん`;
}

function sum(...numbers: number[]): number {
  return numbers.reduce((a, b) => a + b, 0);
}
 
sum(1, 2, 3); // 6
sum(); // 0 — 0個でもOK

function joinWith(separator: string, ...parts: string[]): string {
  return parts.join(separator);
}
 
joinWith('-', '2026', '07', '09'); // "2026-07-09"

function first(...items: [string, ...string[]]): string {
  return items[0]; // 少なくとも1個あることが型で保証されている
}
 
first('a', 'b'); // ✅
// first();      // ❌ エラー：引数が足りない

type ClickHandler = (event: MouseEvent) => void;
 
function registerHandler(handler: ClickHandler): void {
  document.addEventListener('click', handler);
}
 
// 呼び出し側は引数の型を書かなくてよい（event は MouseEvent と推論される）
registerHandler((event) => {
  console.log(event.clientX);
});

const numbers = [1, 2, 3];
 
// forEach のコールバック型は (value, index, array) => void だが…
numbers.forEach((value) => console.log(value)); // ✅ 使わない引数は省略できる

type ButtonProps = {
  label: string;
  onClick: (event: React.MouseEvent<HTMLButtonElement>) => void;
};

// ❌ Function 型は引数のチェックが一切効かない
const handler: Function = (a: number) => a * 2;
handler('文字列', true, []); // エラーにならず、実行時に壊れる

// ユニオン型で書くと…
function double(value: string | number): string | number {
  return typeof value === 'string' ? value + value : value * 2;
}
 
const result = double(5);
// result の型は string | number — number を渡したのに絞り込まれない

// オーバーロードシグネチャ（呼び出し側から見える型）
function double(value: string): string;
function double(value: number): number;
// 実装シグネチャ（すべてのパターンを受けられる型で書く。外からは見えない）
function double(value: string | number): string | number {
  return typeof value === 'string' ? value + value : value * 2;
}
 
const s = double('abc'); // string 型 — "abcabc"
const n = double(5); // number 型 — 10

function logMessage(message: string): void {
  console.log(message);
  // return を書かない（または return; だけ）
}
 
// void な関数の戻り値を使おうとすると型エラー
const result = logMessage('hello');
result.toUpperCase(); // Error: 'result' は 'void' 型

// イベントハンドラは「戻り値を使わない」ことを void で表す
type ClickHandler = (event: MouseEvent) => void;
 
// 戻り値が void な関数型には、実際に値を返す関数も代入できる
const handler: ClickHandler = (e) => e.target; // エラーにならない

// throw する関数の戻り値型は never
function fail(message: string): never {
  throw new Error(message);
}
 
// 無限ループも never
function infiniteLoop(): never {
  while (true) {}
}

function assertDefined<T>(val: T | null | undefined, label: string): T {
  if (val == null) {
    fail(`${label} は必須です`); // never を返すので、以降 val は T 型に確定
  }
  return val; // ここでは val: T
}

function findUser(id: number): User | undefined {
  return users.find((u) => u.id === id); // 見つからないと undefined
}