値の不変性

let x = 1; / let mut x = 1;

let v = vec![1, 2];
// v.push(3);       // コンパイルエラー: mutではない
// v = vec![3];     // コンパイルエラー: 再代入もできない

let mut w = vec![1, 2];
w.push(3);          // OK: mutを明示した束縛
w = vec![4];        // OK: 再代入

fn add(v: &mut Vec<i32>) { v.push(1); } // 変更可能な参照を渡す

束縛は既定で不変で、`mut`を明示したときだけ再代入と変更ができる。`&mut`は同時に1つしか存在できないため、共有と変更が同時に起きない。ただし変更は言語機能として存在し、`mut`・借用所有権を移さずに、値を一時的に貸し出して使わせること。Rustでは`&T`（読み取り専用）と`&mut T`（変更可能）で表し、借りている間の書き換えや破棄をコンパイラが検査する。・所有権値の持ち主を一つに定め、持ち主がいなくなったときに値を破棄する仕組み。Rustが代表例で、値を別の変数や関数へ渡すと持ち主が移り（move）、元の変数は使えなくなる。を学ぶ必要がある。melangは変更そのものを設けないので、この仕組みを必要としない。

let x = ... / let mut x = ... / mut field

struct User { name : String; mut age : Int }

let a = { name: "alice", age: 20 }
// a.name = "bob"        // エラー: mutではないフィールド
a.age = 21               // OK: mutフィールド

let mut n = 0
n = n + 1                // OK: mutな変数

let arr = [1, 2]
arr[0] = 9               // OK: Arrayは変更できる

不変な束縛・フィールドが既定で、変更するときは`mut`を付けて明示する。`Array`などは変更でき、不変なコレクションは`immut`パッケージとして別に用意される。不変と可変を言語上で区別する点はRustに近い。

let x = ... / var x = ...

struct User { var name: String }
let a = User(name: "alice")
// a.name = "bob"        // コンパイルエラー: letのstructは中身も不変

var b = User(name: "alice")
b.name = "bob"           // OK

class Box { var value = 0 }
let c = Box()
c.value = 1              // OK: classは参照型で、letでも中身は変更できる

`struct`などの値型は代入時にコピーされるため、`let`にすれば中身も変更できず、共有による影響も出ない。一方で`class`は参照型で、`let`でもプロパティを変更できる。値型と参照型で不変の意味が変わる。

val x = ... / var x = ...

val tags = mutableListOf("a")
// tags = mutableListOf("b")  // コンパイルエラー: valは再代入不可
tags.add("admin")              // OK: MutableListは変更できる

val ro: List<String> = tags    // 読み取り専用のビュー
// ro.add("x")                 // コンパイルエラー
tags.add("y")                  // roからも見える

data class User(val name: String)
val renamed = User("alice").copy(name = "bob")

`val`と`var`を使い分け、`val`を基本とするのが慣習である。`List`は読み取り専用のインターフェースで、実体が`MutableList`の場合は別の参照から変更でき、不変が保証されるわけではない。`data class`の`copy`で、新しい値を作る書き方ができる。

final T x = ...; / record User(String name) {}

final List<String> tags = new ArrayList<>();
// tags = new ArrayList<>();  // コンパイルエラー: 再代入
tags.add("admin");             // OK: 参照先は変更できる

record User(String name) {}    // フィールドはfinal（浅い不変）
var fixed = List.of("a", "b"); // 不変コレクション
// fixed.add("c");             // 実行時にUnsupportedOperationException

`final`は束縛（変数・フィールド）を固定するだけで、参照先のオブジェクトは変更できる。`record`や`List.of`で不変にできるが、選ぶのは書き手である。不変コレクションの違反は、コンパイル時ではなく実行時に例外として現れる。

val x = ... / var x = ...

case class User(name: String, tags: List[String])
val a = User("alice", List("a"))
// a.name = "bob"                       // コンパイルエラー
val b = a.copy(name = "bob")            // 新しい値を生成
val c = a.copy(tags = a.tags :+ "admin")

var n = 0
n += 1                                  // OK: varは再代入できる

import scala.collection.mutable
val buf = mutable.ListBuffer(1)
buf += 2                                // OK: 可変コレクションも使える

`val`・`case class`・不変コレクションが既定で、更新は`copy`や`:+`で新しい値を作って表す。一方で`var`と`scala.collection.mutable`も使えるため、不変は慣習であり、言語が強制するわけではない。

readonly T x; / record User(string Name);

public record User(string Name);   // initのみのプロパティ
var a = new User("alice");
// a.Name = "bob";                  // コンパイルエラー
var b = a with { Name = "bob" };    // 新しい値を生成

private readonly List<string> tags = new();
// tags = new();                    // コンパイルエラー（コンストラクタ外）
tags.Add("admin");                  // OK: 参照先は変更できる

var im = ImmutableList.Create("a"); // System.Collections.Immutable

`readonly`はフィールドの再代入を防ぐだけで、参照先は変更できる。`record`と`with`式で、新しい値を作る書き方が言語機能になっている。`ImmutableList`などの不変コレクションは別のライブラリで、使うかどうかは書き手が選ぶ。

const T x; / const T& x

const std::vector<int> v = {1, 2};
// v.push_back(3);  // コンパイルエラー

std::vector<int> w = {1, 2};
w.push_back(3);     // OK
w = {4};            // OK: 再代入

// constの参照からでも、const_castで外せてしまう
auto& m = const_cast<std::vector<int>&>(v);

既定は変更可能で、不変にするのは`const`を付ける側の任意である。`const`は参照やメンバ関数にも付けられ表現力が高いが、`const_cast`や`mutable`メンバで抜け道が残る。不変を保つには書き手の規律が要る。

const int x = 1; / const int *p

const int x = 10;
// x = 20; // コンパイルエラー

int arr[] = {1, 2, 3};
arr[0] = 9; // OK: 配列の要素は変更できる

const char *s = "hello";
char *mutable_s = (char *)s; // constを外すキャスト
mutable_s[0] = 'H'; // 文字列リテラルへの書き込みは未定義動作（実行時クラッシュもあり得る）

`const`修飾子はC++より先にC89で導入されたが、既定は変更可能でありC++の`const`とほぼ同じ設計思想を持つ（C++はここに`const_cast`という専用の抜け道キャストを追加した）。Cでは通常のキャストで`const`を外せてしまい、文字列リテラルのように実際には読み取り専用領域に置かれるデータを書き換えようとすると、コンパイルは通るのに実行時に未定義動作になるという、コンパイル時の検査と実行時の実体が食い違う典型例を持つ。

const n = 1 / var x = 1

const limit = 10 // 数値・文字列などのコンパイル時定数だけ

type User struct{ Name string; Tags []string }
u := User{"alice", []string{"a"}}
u = User{"bob", nil}       // 再代入
u.Name = "bob"             // フィールドの変更
u.Tags = append(u.Tags, "admin")
u.Tags[0] = "x"            // sliceの要素の変更

`const`は数値・文字列・真偽値などのコンパイル時定数にしか使えず、struct・slice・mapを不変にする手段はない。文字列は不変だが、他のデータは変更できる。sliceは同じ配列を共有するため、別の変数から見た値が変わることがある。

const x = 1; / var x = 1;

const v = [_]i32{ 1, 2 }; // const: 要素も変更できない
// v[0] = 9; // コンパイルエラー

var w = [_]i32{ 1, 2 };
w[0] = 9; // OK: varな配列

fn increment(p: *i32) void {
    p.* += 1; // 非constポインタ経由でのみ書き込める
}

`const`と`var`が束縛の可変性を明確に分け、`const`は再代入も中身の変更もできない。ポインタも`*T`（書き込み可）と`*const T`（読み取り専用）で型として区別され、`*const T`経由では書き込めない。Rustの借用所有権を移さずに、値を一時的に貸し出して使わせること。Rustでは`&T`（読み取り専用）と`&mut T`（変更可能）で表し、借りている間の書き換えや破棄をコンパイラが検査する。チェッカのような所有権値の持ち主を一つに定め、持ち主がいなくなったときに値を破棄する仕組み。Rustが代表例で、値を別の変数や関数へ渡すと持ち主が移り（move）、元の変数は使えなくなる。規則とは別物で、複数の可変ポインタが同時に存在することを言語が防ぐ仕組みではない点に注意。

let x = ... / let r = ref 0 / mutable field

type user = { name : string; mutable age : int }

let a = { name = "alice"; age = 20 }
let b = { a with name = "bob" }   (* 新しい値 *)
(* a.name <- "x"                     コンパイルエラー: mutableではない *)
a.age <- 21                       (* OK: mutableフィールド *)

let r = ref 0
let () = r := !r + 1              (* OK: refは変更できる *)

let arr = [| 1; 2 |]
let () = arr.(0) <- 9             (* OK: 配列は変更できる *)

`let`束縛とレコードは既定で不変で、`with`で新しい値を作れる。ただし`ref`・`mutable`フィールド・配列・`Bytes`など、変更を使う手段が言語に含まれる。関数型が中心の言語だが、変更を明示して選べる。

let x = ... / let mutable x = ... / mutable field

type User = { Name : string; mutable Age : int }

let a = { Name = "alice"; Age = 20 }
let b = { a with Name = "bob" }   // 新しい値。aは変わらない
// a.Name <- "x"                 // コンパイルエラー: mutableではない
a.Age <- 21                      // OK: mutableフィールド

let mutable n = 0
n <- n + 1                       // OK: mutableな変数

`let`束縛とレコードは既定で不変で、`with`で新しい値を作れる。変更したいフィールド・変数には`mutable`を明示的に付ける必要がある。OCaml由来の`ref`型（可変セル）も引き続き使え、.NETとの相互運用のためclassの可変プロパティも扱える。関数型が中心の言語だが、変更を明示して選べる点はOCamlと同じ。

let x = ... / data User = User { name :: String }

data User = User { name :: String, tags :: [String] }

let a = User { name = "alice", tags = ["a"] }
let b = a { name = "bob" }        -- 新しい値。aは変わらない
let c = a { tags = tags a ++ ["admin"] }

-- 変更が必要な場合は、型に現れる別の仕組みを使う
import Data.IORef
main = do
  r <- newIORef (0 :: Int)
  modifyIORef r (+ 1)

束縛は再代入されず、データも不変である。更新は、レコード更新構文や関数で新しい値を作って表す。変更可能な状態は`IORef`・`ST`・`MVar`などとして型に現れ、純粋な処理と区別される。melangの方針に最も近いが、状態変更を型で区別する点は、melangでは決めていない。

X = ... / Map#{key := Value}

User = #{name => "alice", tags => ["a"]},
Other = User,
User2 = User#{name := "bob"},   %% 新しいmapを作り、別の変数へ束縛する
%% User = User2. は badmatch（既に束縛済みの変数は上書きできない）
%% Other は #{name => "alice", ...} のまま変わらない

Tags = maps:get(tags, User) ++ ["admin"],  %% 新しいlist

%% 状態は、再帰で新しい状態へ遷移して持つ
loop(Count) ->
    receive
        inc -> loop(Count + 1)
    end.

Elixirの`x = 1`に続く`x = 2`のようなrebindingすら許さず、同じ変数名への再束縛は既に束縛済みの値と一致する場合しか成立しない厳密な単一代入（single assignment）。データはすべて不変で、更新は新しい値を作って別の変数に束縛する。プロセスの状態は再帰で新しい状態に遷移させ、melangが目指す「値は不変・再代入は禁止」という設計に、束縛の面ではElixirより近い。

x = ... / %{map | key: value}

user = %{name: "alice", tags: ["a"]}
other = user
user = %{user | name: "bob"}   # 新しいmapを作り、名前をrebindingする
# other は %{name: "alice", ...} のまま変わらない

tags = user.tags ++ ["admin"]  # 新しいlist

# 状態は、再帰で新しい状態へ遷移して持つ
def loop(count) do
  receive do
    :inc -> loop(count + 1)
  end
end

`x = 1`のあとに`x = 2`と書けるが、これは同じ名前を別の値へ束縛し直すだけで、元のデータは変わらない。データはすべて不変で、更新は新しい値を作って表す。プロセスの状態は、再帰で新しい状態に遷移させる。melangは、rebindingも再代入として禁止する点が異なる。

const x = ... / readonly field: T / as const

const user = { name: "alice", tags: ["a"] };
// user = { name: "bob", tags: [] };   // エラー: 再代入
user.name = "bob";                      // OK: constでも変更できる

type RO = Readonly<{ name: string; tags: readonly string[] }>;
const ro: RO = { name: "alice", tags: ["a"] };
// ro.name = "bob";                     // 型エラー

const loose: { name: string } = ro;     // readonlyを外して代入できる
loose.name = "bob";                     // 型は通り、実行時に変更される

`const`は束縛だけを固定する。`readonly`や`Readonly<T>`は型だけの制限で、実行時には何も防がず、readonlyを外した型へ代入できる場合もある。不変性は型検査の範囲に留まる。

const x = ... / Object.freeze(obj)

const user = { name: "alice", tags: ["a"] };
user.name = "bob";          // OK: constでもプロパティは変更できる
user.tags.push("admin");    // OK

const frozen = Object.freeze({ name: "alice", tags: ["a"] });
frozen.name = "bob";        // 無視される（strict modeではTypeError）
frozen.tags.push("admin");  // OK: freezeは浅く、tagsの中身は変更できる

`const`は束縛だけを固定する。`Object.freeze`は最上位のプロパティしか固定せず、入れ子のオブジェクトや配列の中身は変更できる。深く不変にするには、再帰的に凍結するか、ライブラリを使う必要がある。

public readonly string $name; / readonly class (8.2)

final class User {
    public function __construct(public readonly string $name) {}
    public function withName(string $name): static {
        return new static($name);
    }
}

$a = new User("alice");
// $a->name = "bob";      // Error: readonlyは初期化後に変更できない
$b = $a->withName("bob"); // 新しい値を生成

$arr = [1, 2];
$arr[] = 3;               // OK: 配列は値として扱われるが、変数の中身は変えられる

`readonly`プロパティ（8.1）と`readonly class`（8.2）で、初期化後の変更を禁止できる。配列は代入時に値として扱われる（コピーオンライト）ため、別の変数から見える影響は出ない。一方でオブジェクトは、ハンドルが共有される。不変にするかどうかは、書き手の選択である。

obj.freeze / Data.define(:name)

User = Data.define(:name)
a = User.new(name: "alice")
b = a.with(name: "bob")     # 新しい値を生成
# a.instance_variable_set(:@name, "x")  # FrozenError

s = "abc"
s << "d"                    # OK: 文字列も変更できる
list = [3, 1, 2]
list.sort!                  # OK: 破壊的メソッド

NAME = "x"
NAME = "y"                  # 警告のみで、再代入できてしまう

文字列・配列・ハッシュなど、オブジェクトは通常変更でき、`sort!`や`<<`などの破壊的メソッドが一般的に使われる。`freeze`は浅く、定数への再代入も警告で済む。3.2の`Data.define`は、不変な値オブジェクトを作る手段である。

@dataclass(frozen=True) / tuple / frozenset

from dataclasses import dataclass, replace

@dataclass(frozen=True)
class User:
    name: str
    tags: tuple = ()

a = User("alice")
# a.name = "bob"             # FrozenInstanceError
b = replace(a, name="bob")   # 新しい値を生成

tags = ["a"]
tags.append("admin")         # OK: listは変更できる
NAME = "x"; NAME = "y"       # OK: 定数を宣言する仕組みはない

`list`・`dict`・`set`・通常のクラスのインスタンスは変更でき、それが一般的な使い方である。`tuple`・`frozenset`・`str`・`frozen=True`のdataclassは不変だが、`frozen`は浅く、中身が`list`なら変更できる。定数を宣言する仕組みは言語にない。