1
package cow
2

3
import "sync/atomic"
4

5
// CowSlice 写时复制的切片包装器
6
type CowSlice[T any] struct {
7
    data   []T
8
    shared atomic.Bool
9
}
10

11
// Share 从现有切片创建共享的 CoW 引用
12
func Share[T any](data []T) *CowSlice[T] {
13
    c := &CowSlice[T]{data: data}
14
    c.shared.Store(true)
15
    return c
16
}
17

18
// Read 读取数据，返回只读引用
19
func (c *CowSlice[T]) Read() []T {
20
    return c.data
21
}
22

23
// Write 获取可写引用，首次写入时触发复制
24
func (c *CowSlice[T]) Write() []T {
25
    if c.shared.Load() {
26
        // 共享状态：必须复制
27
        copied := make([]T, len(c.data))
28
        copy(copied, c.data)
29
        c.data = copied
30
        c.shared.Store(false)
31
    }
32
    return c.data
33
}
34

35
// IsOwned 返回是否独占（已复制或从未共享）
36
func (c *CowSlice[T]) IsOwned() bool {
37
    return !c.shared.Load()
38
}

1
// 配置更新：旧配置仍在被使用，新配置写时复制
2
func updateConfig(old *cow.CowSlice[ConfigItem], changes []ConfigItem) []ConfigItem {
3
    writable := old.Write() // 首次写入触发复制
4
    for _, c := range changes {
5
        writable[c.Key] = c
6
    }
7
    return writable
8
}

1
class Cow<T extends object> {
2
  private data: T;
3
  private shared: boolean;
4

5
  constructor(data: T) {
6
    this.data = data;
7
    this.shared = false;
8
  }
9

10
  // 从现有数据创建共享引用
11
  static from<T extends object>(data: T): Cow<T> {
12
    const cow = new Cow(data);
13
    cow.shared = true;
14
    return cow;
15
  }
16

17
  // 读取：直接引用，零拷贝
18
  read(): Readonly<T> {
19
    return this.data;
20
  }
21

22
  // 写入：共享时深拷贝，否则原地修改
23
  write(): T {
24
    if (this.shared) {
25
      this.data = structuredClone(this.data);
26
      this.shared = false;
27
    }
28
    return this.data;
29
  }
30

31
  // 是否独占所有权
32
  isOwned(): boolean {
33
    return !this.shared;
34
  }
35
}
36

37
// 使用示例：React 风格的状态更新
38
interface State {
39
  users: string[];
40
  count: number;
41
}
42

43
const original: State = { users: ["alice", "bob"], count: 2 };
44
const view = Cow.from(original);
45

46
// 读取——与 original 共享同一对象
47
console.log(view.read() === original); // true
48

49
// 修改——触发深拷贝
50
const mutable = view.write();
51
mutable.users.push("charlie");
52

53
// original 不受影响
54
console.log(original.users); // ["alice", "bob"]