// 值：不可变
const x = 42;
// 不能改变 42 这个值

// 身份：随时间关联不同值
let account = { balance: 100 };     // 身份 account → 值 { balance: 100 }
account = { balance: 150 };         // 身份 account → 值 { balance: 150 }
// account 身份没有变，但关联的值变了

// 函数式做法：身份指向新的不可变值
const account1 = { balance: 100 };
const account2 = { ...account1, balance: 150 };  // 新的不可变值
// account1 和 account2 都是不可变的

// ❌ 可变操作
const user = { name: 'Alice', age: 30 };
user.age = 31;  // 直接修改

// ✅ 不可变操作
const user = { name: 'Alice', age: 30 };
const updatedUser = { ...user, age: 31 };  // 创建新对象

// ❌ 数组变异
const items = [1, 2, 3];
items.push(4);        // 修改原数组
items.splice(1, 1);   // 删除元素

// ✅ 不可变数组操作
const items = [1, 2, 3];
const added = [...items, 4];                              // 添加
const removed = items.filter((_, i) => i !== 1);          // 删除
const updated = items.map((item, i) => i === 1 ? 99 : item); // 更新

// Object.freeze 只是浅冻结
const obj = Object.freeze({
  name: 'Alice',
  address: { city: 'Beijing' },
});

obj.name = 'Bob';           // 静默失败（严格模式抛错）
obj.address.city = 'Shanghai';  // ⚠️ 仍然可以修改嵌套对象！

// 深冻结函数
const deepFreeze = (obj) => {
  if (typeof obj !== 'object' || obj === null) return obj;
  Object.freeze(obj);
  Object.values(obj).forEach(deepFreeze);
  return obj;
};

# Python 原生不可变类型
# tuple, frozenset, str, int, float, bool

# ❌ 可变
user = {'name': 'Alice', 'age': 30}
user['age'] = 31

# ✅ 不可变方式
user = {'name': 'Alice', 'age': 30}
updated_user = {**user, 'age': 31}

# 使用 pyrsistent 库
from pyrsistent import pmap, pvector, pset

user = pmap({'name': 'Alice', 'age': 30})
updated_user = user.set('age', 31)  # 返回新对象

items = pvector([1, 2, 3])
added = items.append(4)             # 返回新 vector

// Rust 默认不可变
let x = 42;
// x = 43;  // 编译错误！

// 需要显式声明 mut
let mut y = 42;
y = 43;  // OK

// 结构体默认不可变
struct User {
    name: String,
    age: u32,
}

let user = User { name: "Alice".into(), age: 30 };
// user.age = 31;  // 编译错误！

// 使用 clone 创建修改后的副本
let updated_user = User {
    name: user.name.clone(),
    age: 31,
};

// 使用 derive 宏简化
#[derive(Clone)]
struct User {
    name: String,
    age: u32,
}

let updated = User { age: 31, ..user.clone() };

-- Haskell 中所有值默认不可变
data User = User { name :: String, age :: Int }

user :: User
user = User "Alice" 30

-- 使用 Record update 语法创建新值
updatedUser :: User
updatedUser = user { age = 31 }

-- 原始 user 不受影响
-- age user == 30
-- age updatedUser == 31

;; Clojure 的数据结构默认不可变
(def user {:name "Alice" :age 30})

;; assoc 返回新 map，原 map 不变
(def updated-user (assoc user :age 31))

;; 两者都保持不变
;; (:age user)         => 30
;; (:age updated-user) => 31

;; 向量操作
(def items [1 2 3])
(def added (conj items 4))     ;; [1 2 3 4]
;; items 仍然是 [1 2 3]

;; Clojure 向量使用 32 分支的 Trie
(def v1 [1 2 3 4 5])

;; conj 返回新向量，共享大部分结构
(def v2 (conj v1 6))

;; v1 和 v2 共享内部节点
;; v1 => [1 2 3 4 5]
;; v2 => [1 2 3 4 5 6]

;; 时间复杂度 O(log32 n) ≈ O(1)
;; 对百万级元素仍然高效

const { List, Map } = require('immutable');

// 创建不可变 List
const list1 = List([1, 2, 3, 4, 5]);
const list2 = list1.push(6);

console.log(list1.toArray()); // [1, 2, 3, 4, 5] 未改变
console.log(list2.toArray()); // [1, 2, 3, 4, 5, 6]

// 创建不可变 Map
const map1 = Map({ name: 'Alice', age: 30 });
const map2 = map1.set('age', 31);

console.log(map1.toJS()); // { name: 'Alice', age: 30 }
console.log(map2.toJS()); // { name: 'Alice', age: 31 }

// 性能：大列表的不可变更新
const largeList = List(Array.from({ length: 1000000 }, (_, i) => i));
const updated = largeList.set(999999, -1); // O(log32 n) ≈ O(1)

from pyrsistent import pvector, pmap, pset, freeze, thaw

# 持久化向量
v1 = pvector([1, 2, 3, 4, 5])
v2 = v1.append(6)
v3 = v1.set(0, 99)

# v1 不变
assert list(v1) == [1, 2, 3, 4, 5]
assert list(v2) == [1, 2, 3, 4, 5, 6]
assert list(v3) == [99, 2, 3, 4, 5]

# 深度嵌套的不可变数据
data = freeze({
    'users': [
        {'name': 'Alice', 'scores': [90, 85, 92]},
        {'name': 'Bob', 'scores': [78, 82, 88]},
    ]
})

# 修改嵌套数据
from pyrsistent import assoc_in
updated = assoc_in(data, ['users', 0, 'scores', 0], 95)

use im::{vector, Vector, OrdMap};

fn main() {
    // 持久化向量
    let v1: Vector<i32> = vector![1, 2, 3, 4, 5];
    let v2 = v1.push_back(6);
    let v3 = v1.update(0, 99);

    // v1 未变
    assert_eq!(v1, vector![1, 2, 3, 4, 5]);
    assert_eq!(v2, vector![1, 2, 3, 4, 5, 6]);
    assert_eq!(v3, vector![99, 2, 3, 4, 5]);

    // 持久化 Map
    let m1: OrdMap<String, i32> = OrdMap::new();
    let m2 = m2.update("count".to_string(), 1);
    // m1 仍为空，m2 包含 { "count": 1 }
}

use std::borrow::Cow;

fn process(input: &str) -> Cow<str> {
    if input.contains(' ') {
        // 需要修改：创建新字符串
        Cow::Owned(input.replace(' ', "-"))
    } else {
        // 不需要修改：借用原始数据
        Cow::Borrowed(input)
    }
}

fn main() {
    let s1 = "hello-world";
    let s2 = "hello world";

    let r1 = process(s1);  // 借用，无复制
    let r2 = process(s2);  // 创建新字符串

    println!("{}", r1);  // hello-world
    println!("{}", r2);  // hello-world
}

// Swift 的 Array、Dictionary、Set 自带 COW
var a = [1, 2, 3, 4, 5]
var b = a           // 共享同一存储

b.append(6)         // 此时才复制
print(a)            // [1, 2, 3, 4, 5]
print(b)            // [1, 2, 3, 4, 5, 6]

const state = {
  user: {
    profile: {
      address: {
        city: 'Beijing',
        street: 'Main St',
      },
    },
  },
};

// ❌ 糟糕：代码冗长
const updated = {
  ...state,
  user: {
    ...state.user,
    profile: {
      ...state.user.profile,
      address: {
        ...state.user.profile.address,
        city: 'Shanghai',
      },
    },
  },
};

// ✅ 使用 immer 库
const { produce } = require('immer');

const updated = produce(state, (draft) => {
  draft.user.profile.address.city = 'Shanghai';
});

from lenses import lens

state = {
    'user': {
        'profile': {
            'address': {
                'city': 'Beijing',
                'street': 'Main St',
            }
        }
    }
}

# 使用 pyrsistent 的 assoc_in
from pyrsistent import freeze, thaw, assoc_in

frozen_state = freeze(state)
updated = assoc_in(frozen_state, ['user', 'profile', 'address', 'city'], 'Shanghai')

// ❌ 低效：多次更新
let state = { count: 0, name: 'Alice' };
state = { ...state, count: state.count + 1 };
state = { ...state, name: 'Bob' };
state = { ...state, count: state.count + 1 };

// ✅ 高效：合并更新
const state = { count: 0, name: 'Alice' };
const finalState = {
  ...state,
  count: state.count + 2,
  name: 'Bob',
};

// ❌ 创建中间数组
const result = [1, 2, 3, 4, 5]
  .filter(x => x > 2)    // 中间数组 [3, 4, 5]
  .map(x => x * 2);      // 最终数组 [6, 8, 10]

// ✅ 使用 Transducer（无中间数组）
const transducer = R.compose(
  R.filter(x => x > 2),
  R.map(x => x * 2)
);
const result = R.transduce(transducer, R.flip(R.append), [], [1, 2, 3, 4, 5]);

// 使用引用相等性检查，O(1)
const isImmutableEqual = (a, b) => a === b;  // 引用相同即相等

// 配合 React 的 memo/useMemo 使用
const ListItem = React.memo(({ item }) => {
  return <div>{item.name}</div>;
}, (prev, next) => prev.item === next.item);  // O(1) 比较

// Redux reducer 必须返回新状态
const todoReducer = (state = [], action) => {
  switch (action.type) {
    case 'ADD_TODO':
      return [...state, { id: action.id, text: action.text, completed: false }];
    case 'TOGGLE_TODO':
      return state.map(todo =>
        todo.id === action.id
          ? { ...todo, completed: !todo.completed }
          : todo
      );
    default:
      return state;
  }
};

// React 依赖引用相等性进行浅比较优化
// 如果 state 引用不变，组件不会重新渲染

// Elm-like 架构
const initState = { todos: [], filter: 'all' };

const update = (model, msg) => {
  switch (msg.type) {
    case 'ADD':
      return { ...model, todos: [...model.todos, msg.todo] };
    case 'FILTER':
      return { ...model, filter: msg.filter };
    default:
      return model;
  }
};

// 时间旅行调试
const history = [initState];
const dispatch = (msg) => {
  const newModel = update(history[history.length - 1], msg);
  history.push(newModel);
  render(newModel);
};

// 撤销
const undo = () => {
  if (history.length > 1) {
    history.pop();
    render(history[history.length - 1]);
  }
};

// 不可变购物车
const Cart = {
  create: () => ({ items: [], total: 0 }),

  addItem: (cart, product, quantity = 1) => {
    const existing = cart.items.find(i => i.productId === product.id);
    const newItems = existing
      ? cart.items.map(i =>
          i.productId === product.id
            ? { ...i, quantity: i.quantity + quantity }
            : i
        )
      : [...cart.items, { productId: product.id, name: product.name, price: product.price, quantity }];

    return {
      items: newItems,
      total: newItems.reduce((sum, i) => sum + i.price * i.quantity, 0),
    };
  },

  removeItem: (cart, productId) => {
    const newItems = cart.items.filter(i => i.productId !== productId);
    return {
      items: newItems,
      total: newItems.reduce((sum, i) => sum + i.price * i.quantity, 0),
    };
  },
};

// 使用
let cart = Cart.create();
cart = Cart.addItem(cart, { id: 1, name: 'Laptop', price: 9999 }, 1);
cart = Cart.addItem(cart, { id: 2, name: 'Mouse', price: 99 }, 2);
// cart 的每个版本都是不可变的，可以保存历史记录

# 用不可变数据结构模拟 Git 的快照
from pyrsistent import freeze, thaw

class VersionControl:
    def __init__(self):
        self.history = [freeze({'files': {}, 'message': 'init'})]

    def commit(self, files, message):
        current = self.history[-1]
        new_state = current.set('files', freeze(files)).set('message', message)
        self.history.append(new_state)
        return new_state

    def get_version(self, index):
        return self.history[index]

    def log(self):
        return [(i, s['message']) for i, s in enumerate(self.history)]

# 每个版本都是不可变的快照
vc = VersionControl()
vc.commit({'readme.md': '# Hello'}, 'Initial commit')
vc.commit({'readme.md': '# Hello', 'main.py': 'print("hi")'}, 'Add main.py')

# 可以随时访问任何历史版本
v0 = vc.get_version(0)
v1 = vc.get_version(1)