型注釈の位置

let age: i32 = 20;

let age: i32 = 20; // 変数宣言は省略可能

fn greet(name: String) -> String { // 関数シグネチャは常に明示
    format!("Hello, {name}")
}

`let`束縛はコンパイラソースコードを解析し、実行可能な形式（機械語や中間表現）に変換するプログラム。静的型付け言語では、実行前にコンパイラが型の不整合などをチェックする役割も担う。が型推論するため型注釈を省略できるが、関数の引数・戻り値は常に`: Type`/`-> Type`という後置構文で明示しなければならない。「ローカルでは推論に任せ、公開インターフェースでは明示する」という境界線を言語仕様として強制している設計。

let age : Int = 20

let age : Int = 20
let name = "Alice" // 型推論でString

fn greet(name : String) -> String { // 引数・戻り値は明示
  "Hello, " + name
}

`name : Type`というpostfix構文で、Rust/Swiftと同じ系統に属する。ローカル変数は型推論に任せられるが、関数シグネチャは明示が基本という設計も共通しており、新興言語がpostfix系の慣習を踏襲していることが分かる。

let age: Int = 20

let age: Int = 20
let name = "Alice" // 型推論でString

func greet(name: String) -> String { // 引数・戻り値は明示が基本
    "Hello, \(name)"
}

`name: Type`というpostfix構文をKotlinと共有する。関数の引数・戻り値は基本的に明示が必要で、ローカル変数の強い型推論とは対照的。クロージャの引数に限り、文脈から型を省略できる場合がある。

val age: Int = 20

val age: Int = 20
val name = "Alice" // 型推論でString

fun greet(name: String) = "Hello, $name" // 式本体なら戻り値の型を省略できる
fun greet2(name: String): String { return "Hello, $name" } // ブロック本体は明示が必要

`name: Type`という一貫したpostfix構文。引数の型注釈は必須で推論できないが、戻り値の型は式本体（`= expr`）で定義した関数に限り推論できるという、本体の書き方によって推論範囲が変わる設計。

int age = 20;

int age = 20;
var name = "Alice"; // Java 10以降、ローカル変数のみ推論できる

String greet(String name) { // 引数・戻り値は常にprefixで明示
    return "Hello, " + name;
}

`Type name`という前置構文が基本で、フィールド・引数・戻り値すべてに一貫して適用される。`var`はローカル変数宣言にのみ使え、引数や戻り値の型推論は言語仕様として存在しない。

val age: Int = 20

val age: Int = 20
val name = "Alice" // 型推論でString

def greet(name: String) = s"Hello, $name" // 戻り値の型は省略できるが非推奨

`name: Type`というpostfix構文。引数の型は必須だが、メソッドの戻り値型はコンパイラソースコードを解析し、実行可能な形式（機械語や中間表現）に変換するプログラム。静的型付け言語では、実行前にコンパイラが型の不整合などをチェックする役割も担う。が本体から推論でき、文法上は省略できる。ただし公開APIで省略すると意図しない型が推論されるリスクがあるため、スタイルガイドでは明示が推奨される——「書けること」と「書くべきこと」が分かれる例。

int age = 20;

int age = 20;
var name = "Alice"; // varによる推論

string Greet(string name) { // 引数・戻り値は常にprefixで明示
    return $"Hello, {name}";
}

`Type name`という前置構文が基本で、Javaと同じ設計思想を継承する。`var`はローカル変数の型推論に使えるが、メソッドの引数・戻り値には使えず、公開シグネチャは常に明示的な型を書くことになる。

int age = 20;

int age = 20; // 型が名前より前
auto name = std::string("Alice"); // autoで推論

auto add(int a, int b) -> int { // trailing return typeで戻り値を後置
    return a + b;
}

基本はCから受け継いだ`Type name`という前置構文。一方C++11で導入されたtrailing return type構文（`auto f() -> Type`）は、テンプレートで戻り値の型を引数から導出する必要から生まれた、後置構文への部分的な移行。同じ言語の中でprefix/postfixが混在する例。

int age = 20;

int age = 20; // 型が名前より前

char *greet(char *name) { // 引数・戻り値ともprefixで明示
    return name;
}

int (*compare)(const void *, const void *); // 関数ポインタは宣言が読みにくい典型例

`Type name`という前置構文の大元であり、C++やJavaの`Type name`はここから直接受け継がれた。型推論の構文がないため、宣言は常に完全な形で書く必要がある。関数ポインタや多次元配列が絡むと、宣言子を内側から外側へ読む複雑な規則（俗に「螺旋規則」とも呼ばれる）が必要になり、この読みにくさがGoのpostfix方式（`var name Type`）やRust/Swiftの`name: Type`のような設計を後押しした一因になっている。

var age int = 20

var age int = 20
name := "Alice" // :=で推論

func greet(name string) string { // 引数・戻り値は常に明示
    return "Hello, " + name
}

`var name Type`という一貫したpostfix構文を採用しており、Cの`Type name`とは逆順。`:=`によるローカルの型推論はあるが、関数シグネチャでは常に型を書く必要があり、公開APIの可読性を型推論より優先する設計。

const age: i32 = 20;

const age: i32 = 20; // 変数宣言は省略可能
const name = "Alice"; // 型推論で *const [5:0]u8

fn greet(name: []const u8) []const u8 { // 引数・戻り値は常に明示（矢印は使わない）
    return name;
}

`name: Type`というpostfix構文で、`const`/`var`宣言は初期化式から型推論できる。関数は`fn f(args) ReturnType`という形で、Goのように戻り値の型に矢印を使わず引数リストの直後に置くが、Rust/Goと同様に引数・戻り値は推論できず常に明示が必要。

let age : int = 20

let age : int = 20
let name = "Alice" (* 型注釈なしでも推論される *)

let greet (name : string) : string = "Hello, " ^ name
(* 型注釈をすべて省略しても推論できる *)
let greet name = "Hello, " ^ name

変数・引数・戻り値のいずれも`: Type`という後置構文だが、Hindley-Milner推論により実務上はほとんど省略される。さらに`.ml`（実装）とは別に`.mli`（インターフェース）ファイルへ型シグネチャだけを分離して書くこともでき、Haskellの独立したシグネチャ行をファイル単位に発展させたような設計になっている。

let age : int = 20

let age : int = 20
let name = "Alice" // 型注釈なしでも推論される

let greet (name : string) : string = "Hello, " + name
// 型注釈をすべて省略しても推論できる
let greet name = "Hello, " + name

変数・引数・戻り値のいずれも`: Type`という後置構文で、OCamlと同じくHindley-Milner推論により実務上はほとんど省略される。`.fs`（実装）とは別に`.fsi`（シグネチャ）ファイルへ型シグネチャだけを分離して書くこともでき、OCamlの`.mli`をそのまま.NET向けに受け継いだ設計になっている。

age :: Int
age = 20

age :: Int
age = 20

greet :: String -> String -- 引数と戻り値を矢印でつなげた1つの型
greet name = "Hello, " ++ name

値そのものの定義行とは別に`name :: Type`という型シグネチャを独立した行として書く。関数はカリー化された1引数関数の連鎖として扱われるため、引数と戻り値を構文上区別せず`A -> B`のように矢印でつなぐ。型注釈はHindley-Milner推論によりほぼ省略できるが、可読性のためシグネチャを明示するのが慣習になっている。

-spec greet(string()) -> string().

%% Age = 20. 変数自体に型注釈はない

-spec greet(string()) -> string(). %% 関数定義の直前に別行で型を書く
greet(Name) -> "Hello, " ++ Name.

変数には型注釈がないが、関数には`-spec`という属性を関数定義の直前に別行で書ける。Haskellの`name :: Type`という独立したシグネチャ行に近い発想で、Elixirの`@spec`はこの構文をそのまま踏襲している。コンパイラソースコードを解析し、実行可能な形式（機械語や中間表現）に変換するプログラム。静的型付け言語では、実行前にコンパイラが型の不整合などをチェックする役割も担う。自体は検査せず、Dialyzerという外部の静的解析ツールが型の整合性を検査する。

@spec greet(String.t()) :: String.t()

age = 20 # 変数自体に型注釈はない

@spec greet(String.t()) :: String.t() # 関数定義の直前に別行で型を書く
def greet(name), do: "Hello, " <> name

変数には型注釈がないが、関数には`@spec`という属性を`def`の直前に別行で書ける。構文上はHaskellの`name :: Type`という独立したシグネチャ行に近い発想だが、コンパイラソースコードを解析し、実行可能な形式（機械語や中間表現）に変換するプログラム。静的型付け言語では、実行前にコンパイラが型の不整合などをチェックする役割も担う。自体は検査せずDialyzerという外部の静的解析ツールが検査を担う点が異なる。

let age: number = 20;

let age: number = 20;
let name = "Alice"; // 型推論でstring

function greet(name: string) { // 引数はstrictモードで実質必須
    return `Hello, ${name}`; // 戻り値の型は推論される
}

`name: Type`というpostfix構文で、変数・戻り値はコンパイラソースコードを解析し、実行可能な形式（機械語や中間表現）に変換するプログラム。静的型付け言語では、実行前にコンパイラが型の不整合などをチェックする役割も担う。が推論できるため省略されることが多い。一方、引数の型は`noImplicitAny`を有効にした標準的な設定では推論できず、省略するとエラーになるため実質的に明示が必須という非対称な設計。

let age = 20;

let age = 20;

function greet(name) { // 引数・戻り値ともに型注釈は書けない
    return "Hello, " + name;
}

変数宣言・関数引数・戻り値のいずれにも型注釈を書く構文がない。TypeScriptが型注釈を後付けで追加した土台であり、prefix/postfixという比較軸自体が存在しない基準点として位置づけられる。

function setAge(int $age): void {}

$age = 20; // 変数自体には型注釈を書けない

function setAge(int $age): void { // 引数はprefix(int $age)、戻り値はpostfix(: void)
    // ...
}

変数自体には型注釈の構文がないが、関数の引数は`Type $name`という前置、戻り値は`: Type`という後置と、1つの関数シグネチャの中でprefix/postfixが混在する。引数はC系の伝統を継ぎ、戻り値は後発の`: Type`構文（PHP 7以降）を採用した歴史的経緯の違いがそのまま表れている。

age = 20

age = 20
age = "Alice" # 再代入で型が変わる

def greet(name)  # 引数・戻り値に型注釈を書く構文がない
  "Hello, #{name}"
end

変数・引数・戻り値のいずれにも型注釈の構文がなく、型を付けたい場合はRBSという`.rbs`拡張子の別ファイルにシグネチャだけを書く。OCamlの`.mli`と似た「実装と型定義をファイルごと分離する」発想だが、Rubyでは型注釈が言語コアに一切存在しない点がOCamlとは異なる。

age: int = 20

age: int = 20
name = "Alice"  # 型ヒントなしでも書ける（動的型付け）

def greet(name: str) -> str:  # 引数・戻り値ともpostfixで明示できる
    return f"Hello, {name}"

変数・引数・戻り値のすべてに`: Type`というpostfixの型ヒントを書けるが、これはあくまで静的解析ツール（mypy等）のためのアノテーションで、実行時の型チェックには影響しない。「型注釈の構文を持つこと」と「静的型付けであること」が別問題であることを示す例。