型システム詳解 — 静的型付けは何を守ってくれるのか

// Go: コンパイル時に型エラーが検出される
func add(a int, b int) int {
    return a + b
}
 
func main() {
    // add("hello", "world")  // コンパイルエラー: cannot use "hello" (string) as int
    result := add(1, 2)       // OK
    fmt.Println(result)
}

# Python: 実行時に型エラーが発生する
def add(a, b):
    return a + b
 
print(add(1, 2))         # 3 — OK
print(add("hello", "!")) # "hello!" — 文字列の連結として動作
# print(add(1, "hello"))  # TypeError: unsupported operand type(s) at runtime

// TypeScript: 漸進的に型を追加できる
function greet(name: string): string {
  return `Hello, ${name}!`;
}
 
// any を使えば動的型付けのように書ける（非推奨）
function legacy(x: any) {
  return x.foo.bar; // 型チェックされない
}

// TypeScript: 構造的型付け
interface Printable {
  toString(): string;
}
 
class Dog {
  constructor(public name: string) {}
  toString() { return `Dog: ${this.name}`; }
}
 
// Dog は Printable を明示的に implements していないが、
// toString() を持っているので Printable と互換
function print(p: Printable) {
  console.log(p.toString());
}
 
print(new Dog("Pochi")); // OK — 構造が一致するため

// Go: interface は暗黙的に実装される（構造的型付け）
type Stringer interface {
    String() string
}
 
type Dog struct {
    Name string
}
 
// Dog は Stringer を明示的に宣言していないが、
// String() メソッドを持つので Stringer を満たす
func (d Dog) String() string {
    return "Dog: " + d.Name
}
 
func Print(s Stringer) {
    fmt.Println(s.String())
}

// Java: 公称型付け
class Dog {
    String name;
    int age;
}
 
class Cat {
    String name;
    int age;
}
 
// Dog と Cat は同じフィールドを持つが、互換ではない
Dog dog = new Dog();
// Cat cat = dog; // コンパイルエラー: incompatible types

struct Meters(f64);
struct Kilometers(f64);
 
// 同じ f64 のラッパーだが、型としては別物
let m = Meters(1000.0);
// let km: Kilometers = m; // コンパイルエラー: mismatched types

// 型注釈なしで複雑な型も推論される
const users = [
  { name: "Alice", age: 30 },
  { name: "Bob", age: 25 },
];
// users: { name: string; age: number }[] と推論
 
const oldest = users.reduce((prev, curr) =>
  prev.age > curr.age ? prev : curr
);
// oldest: { name: string; age: number } と推論

// 使われ方から型が決まる
let mut v = Vec::new(); // この時点では Vec<_>（型未確定）
v.push(1);              // ここで Vec<i32> と確定
 
// クロージャの引数型も推論される
let doubled: Vec<i32> = v.iter().map(|x| x * 2).collect();

// := による型推論
x := 42          // int と推論
s := "hello"     // string と推論
m := map[string]int{"a": 1} // map[string]int と推論
 
// ただし関数引数や戻り値には型注釈が必須
func add(a, b int) int { // <-- 推論されない
    return a + b
}

// T は型パラメータ
function first<T>(arr: T[]): T | undefined {
  return arr[0];
}
 
const num = first([1, 2, 3]);     // num: number | undefined
const str = first(["a", "b"]);    // str: string | undefined

// Go 1.18 で導入された型パラメータ
func First[T any](s []T) (T, bool) {
    if len(s) == 0 {
        var zero T
        return zero, false
    }
    return s[0], true
}
 
// 型制約でメソッドや演算子を要求できる
type Number interface {
    ~int | ~float64
}
 
func Sum[T Number](nums []T) T {
    var total T
    for _, n := range nums {
        total += n
    }
    return total
}

// トレイト境界で型パラメータに要件を課す
fn largest<T: PartialOrd>(list: &[T]) -> &T {
    let mut largest = &list[0];
    for item in &list[1..] {
        if item > largest {
            largest = item;
        }
    }
    largest
}

// コンパイル後、T は Object に消去される
public class Box<T> {
    private T value;
    public T getValue() { return value; }
}
 
// 実行時には Box<String> も Box<Integer> も同じ Box クラス
Box<String> stringBox = new Box<>();
Box<Integer> intBox = new Box<>();
System.out.println(stringBox.getClass() == intBox.getClass()); // true

// Rust には null がない — Option<T> を使う
fn find_user(id: u64) -> Option<String> {
    if id == 1 {
        Some("Alice".to_string())
    } else {
        None
    }
}
 
// パターンマッチで安全に値を取り出す
match find_user(1) {
    Some(name) => println!("Found: {}", name),
    None => println!("Not found"),
}

// strictNullChecks: true の場合
function getLength(s: string | null): number {
  // return s.length; // エラー: 's' is possibly 'null'
  if (s !== null) {
    return s.length; // OK — null チェック後は string として扱える
  }
  return 0;
}

// Go はコンパイル時に nil を追跡しない
func findUser(id int) *User {
    if id == 1 {
        return &User{Name: "Alice"}
    }
    return nil // nil が返る可能性がある
}
 
// nil チェックを忘れるとランタイムパニック
user := findUser(2)
// fmt.Println(user.Name) // panic: nil pointer dereference
if user != nil {
    fmt.Println(user.Name) // 安全
}