共享与可变：Rc、RefCell 和运行时的值

1
$ cargo build --bin ch08_shared_list_move
2
   Compiling rust-lab v0.1.0 (/tmp/rust-lab)
3
error[E0382]: borrow of moved value: `a`
4
 --> src/bin/ch08_shared_list_move.rs:6:22
5
  |
6
2 |     let a: Vec<i64> = Vec::new();
7
  |         - move occurs because `a` has type `Vec<i64>`, which does not implement the `Copy` trait
8
3 |     let b = a;
9
  |             - value moved here
10
...
11
6 |     println!("{:?}", a);
12
  |                      ^ value borrowed here after move
13
  |
14
help: consider cloning the value if the performance cost is acceptable
15
  |
16
3 |     let b = a.clone();
17
  |              ++++++++
18

19
For more information about this error, try `rustc --explain E0382`.
20
error: could not compile `rust-lab` (bin "ch08_shared_list_move") due to 1 previous error

1
use std::cell::RefCell;
2
use std::rc::Rc;
3

4
fn main() {
5
    let a: Rc<RefCell<Vec<i64>>> = Rc::new(RefCell::new(Vec::new()));
6
    let b = Rc::clone(&a);
7
    println!("strong count: {}", Rc::strong_count(&a));
8
    b.borrow_mut().push(1);
9
    a.borrow_mut().push(2);
10
    println!("a = {:?}", a.borrow());
11
    println!("b = {:?}", b.borrow());
12
    println!("same allocation: {}", Rc::ptr_eq(&a, &b));
13
    drop(b);
14
    println!("strong count after drop(b): {}", Rc::strong_count(&a));
15
}

1
[package]
2
name = "pebble-value"
3
description = "Runtime values for the Pebble tree-walking interpreter."
4
version.workspace = true
5
edition.workspace = true
6
rust-version.workspace = true
7
authors.workspace = true
8
license.workspace = true
9
repository.workspace = true
10

11
[dependencies]
12
pebble-span.workspace = true
13
pebble-diag.workspace = true
14
pebble-ast.workspace = true
15

16
[lints]
17
workspace = true

1
/// A Pebble runtime value.
2
///
3
/// Heap-allocated variants share through [`Rc`]; the mutable ones wrap their
4
/// contents in [`RefCell`] so mutation is checked at run time rather than at
5
/// compile time.
6
#[derive(Clone)]
7
pub enum Value {
8
    /// `nil`
9
    Nil,
10
    /// `true` / `false`
11
    Bool(bool),
12
    /// A 64-bit signed integer.
13
    Int(i64),
14
    /// A 64-bit float.
15
    Float(f64),
16
    /// An immutable, shared string.
17
    Str(Rc<str>),
18
    /// A mutable, shared list.
19
    List(Rc<RefCell<Vec<Value>>>),
20
}

1
impl Value {
2
    /// Builds a string value.
3
    #[must_use]
4
    pub fn string(text: impl Into<Rc<str>>) -> Self {
5
        Value::Str(text.into())
6
    }
7

8
    /// Builds a list value.
9
    #[must_use]
10
    pub fn list(items: Vec<Value>) -> Self {
11
        Value::List(Rc::new(RefCell::new(items)))
12
    }
13

14
    /// The value's type name, as `type()` reports it.
15
    #[must_use]
16
    pub const fn type_name(&self) -> &'static str {
17
        match self {
18
            Value::Nil => "nil",
19
            Value::Bool(_) => "bool",
20
            Value::Int(_) => "int",
21
            Value::Float(_) => "float",
22
            Value::Str(_) => "string",
23
            Value::List(_) => "list",
24
        }
25
    }
26

27
    /// Truthiness: only `nil` and `false` are falsy.
28
    #[must_use]
29
    pub const fn is_truthy(&self) -> bool {
30
        !matches!(self, Value::Nil | Value::Bool(false))
31
    }
32

33
    /// The language `==` operator.
34
    ///
35
    /// Numbers compare across `int`/`float`; strings compare by contents;
36
    /// everything else (lists, maps, functions) compares by identity, so two
37
    /// equal-looking lists are *not* `==` unless they are the same list.
38
    #[must_use]
39
    pub fn equals(&self, other: &Value) -> bool {
40
        match (self, other) {
41
            (Value::Nil, Value::Nil) => true,
42
            (Value::Bool(a), Value::Bool(b)) => a == b,
43
            (Value::Int(a), Value::Int(b)) => a == b,
44
            (Value::Int(a), Value::Float(b)) | (Value::Float(b), Value::Int(a)) => {
45
                (*a as f64) == *b
46
            }
47
            (Value::Float(a), Value::Float(b)) => a == b,
48
            (Value::Str(a), Value::Str(b)) => a == b,
49
            (Value::List(a), Value::List(b)) => Rc::ptr_eq(a, b),
50
            _ => false,
51
        }
52
    }
53
}

1
impl From<i64> for Value {
2
    fn from(value: i64) -> Self {
3
        Value::Int(value)
4
    }
5
}
6

7
impl From<f64> for Value {
8
    fn from(value: f64) -> Self {
9
        Value::Float(value)
10
    }
11
}
12

13
impl From<bool> for Value {
14
    fn from(value: bool) -> Self {
15
        Value::Bool(value)
16
    }
17
}
18

19
impl From<&str> for Value {
20
    fn from(value: &str) -> Self {
21
        Value::Str(Rc::from(value))
22
    }
23
}
24

25
impl From<String> for Value {
26
    fn from(value: String) -> Self {
27
        Value::Str(Rc::from(value.as_str()))
28
    }
29
}

1
/// Renders a value, guarding against cycles in self-referential lists.
2
fn write_value(
3
    f: &mut fmt::Formatter<'_>,
4
    value: &Value,
5
    depth: usize,
6
    quoted: bool,
7
) -> fmt::Result {
8
    const MAX_DEPTH: usize = 4;
9
    match value {
10
        Value::Nil => f.write_str("nil"),
11
        Value::Bool(inner) => write!(f, "{inner}"),
12
        Value::Int(inner) => write!(f, "{inner}"),
13
        Value::Float(inner) => {
14
            if inner.is_finite() && inner.fract() == 0.0 {
15
                write!(f, "{inner:.1}")
16
            } else {
17
                write!(f, "{inner}")
18
            }
19
        }
20
        Value::Str(inner) => {
21
            if quoted {
22
                write!(f, "{inner:?}")
23
            } else {
24
                f.write_str(inner)
25
            }
26
        }
27
        Value::List(items) => {
28
            if depth >= MAX_DEPTH {
29
                return f.write_str("[...]");
30
            }
31
            f.write_str("[")?;
32
            for (index, item) in items.borrow().iter().enumerate() {
33
                if index > 0 {
34
                    f.write_str(", ")?;
35
                }
36
                write_value(f, item, depth + 1, true)?;
37
            }
38
            f.write_str("]")
39
        }
40
    }
41
}

1
#[cfg(test)]
2
mod scratch {
3
    use super::*;
4

5
    #[test]
6
    fn clones_share_one_list() {
7
        let a = Value::list(vec![]);
8
        let b = a.clone();
9
        if let Value::List(items) = &b {
10
            items.borrow_mut().push(Value::Int(1));
11
        }
12
        println!("a = {a}");
13
        println!("b = {b}");
14
        println!("a == b: {}", a.equals(&b));
15
        if let Value::List(items) = &a {
16
            items.borrow_mut().push(a.clone());
17
        }
18
        println!("cyclic = {a}");
19
    }
20
}

1
$ cargo build --bin ch08_derive_hash
2
   Compiling rust-lab v0.1.0 (/tmp/rust-lab)
3
error[E0277]: the trait bound `f64: Hash` is not satisfied
4
 --> src/bin/ch08_derive_hash.rs:4:11
5
  |
6
1 | #[derive(Hash, PartialEq, Eq)]
7
  |          ---- in this derive macro expansion
8
...
9
4 |     Float(f64),
10
  |           ^^^ the trait `Hash` is not implemented for `f64`
11
  |
12
  = help: the following other types implement trait `Hash`:
13
            i128
14
            i16
15
            i32
16
            i64
17
            i8
18
            isize
19
            u128
20
            u16
21
          and 4 others
22

23
error[E0277]: the trait bound `f64: Eq` is not satisfied
24
 --> src/bin/ch08_derive_hash.rs:4:11
25
  |
26
1 | #[derive(Hash, PartialEq, Eq)]
27
  |                           -- in this derive macro expansion
28
...

1
        Value::Map(entries) => {
2
            if depth >= MAX_DEPTH {
3
                return f.write_str("#{...}");
4
            }
5
            f.write_str("#{")?;
6
            for (index, (key, item)) in entries.borrow().iter().enumerate() {
7
                if index > 0 {
8
                    f.write_str(", ")?;
9
                }
10
                write_value(f, &key.0, depth + 1, true)?;
11
                f.write_str(": ")?;
12
                write_value(f, item, depth + 1, true)?;
13
            }
14
            f.write_str("}")
15
        }

1
    /// Hashing consistent with [`Value::key_eq`].
2
    fn key_hash<H: Hasher>(&self, state: &mut H) {
3
        match self {
4
            Value::Nil => 0u8.hash(state),
5
            Value::Bool(value) => {
6
                1u8.hash(state);
7
                value.hash(state);
8
            }
9
            Value::Int(value) => {
10
                2u8.hash(state);
11
                value.hash(state);
12
            }
13
            Value::Float(value) => {
14
                3u8.hash(state);
15
                value.to_bits().hash(state);
16
            }
17
            Value::Str(value) => {
18
                4u8.hash(state);
19
                value.hash(state);
20
            }
21
            Value::List(value) => {
22
                5u8.hash(state);
23
                Rc::as_ptr(value).hash(state);
24
            }
25
            Value::Map(value) => {
26
                6u8.hash(state);
27
                Rc::as_ptr(value).hash(state);
28
            }
29
        }
30
    }

1
use std::cell::RefCell;
2
use std::collections::HashMap;
3
use std::hash::{Hash, Hasher};
4
use std::rc::Rc;
5

6
struct ByContents(Rc<RefCell<Vec<i64>>>);
7

8
impl PartialEq for ByContents {
9
    fn eq(&self, other: &Self) -> bool {
10
        *self.0.borrow() == *other.0.borrow()
11
    }
12
}
13

14
impl Eq for ByContents {}
15

16
impl Hash for ByContents {
17
    fn hash<H: Hasher>(&self, state: &mut H) {
18
        self.0.borrow().hash(state);
19
    }
20
}
21

22
fn main() {
23
    let list = Rc::new(RefCell::new(vec![1]));
24
    let mut map = HashMap::new();
25
    map.insert(ByContents(Rc::clone(&list)), "one");
26
    println!("before push: {:?}", map.get(&ByContents(Rc::clone(&list))));
27
    list.borrow_mut().push(2);
28
    println!("after push:  {:?}", map.get(&ByContents(Rc::clone(&list))));
29
    println!("entries: {}", map.len());
30
}

1
/// A map key: a [`Value`] with a reflexive `Eq`/`Hash` implementation.
2
#[derive(Clone)]
3
pub struct MapKey(pub Value);
4

5
impl MapKey {
6
    /// Borrows the underlying value.
7
    #[must_use]
8
    pub fn value(&self) -> &Value {
9
        &self.0
10
    }
11
}
12

13
impl PartialEq for MapKey {
14
    fn eq(&self, other: &Self) -> bool {
15
        self.0.key_eq(&other.0)
16
    }
17
}
18

19
impl Eq for MapKey {}
20

21
impl Hash for MapKey {
22
    fn hash<H: Hasher>(&self, state: &mut H) {
23
        self.0.key_hash(state);
24
    }
25
}
26

27
impl From<Value> for MapKey {
28
    fn from(value: Value) -> Self {
29
        MapKey(value)
30
    }
31
}

1
$ cargo test -p pebble-value
2
   Compiling pebble-value v0.1.0 (/tmp/pebble-rebuild-08/crates/pebble-value)
3
error[E0277]: the trait bound `MapKey: Eq` is not satisfied
4
   --> crates/pebble-value/src/lib.rs:293:13
5
    |
6
293 |         map.insert(MapKey(Value::Float(f64::NAN)), Value::Int(1));
7
    |             ^^^^^^ unsatisfied trait bound
8
    |
9
help: the trait `Eq` is not implemented for `MapKey`
10
   --> crates/pebble-value/src/lib.rs:248:1
11
    |
12
248 | pub struct MapKey(pub Value);
13
    | ^^^^^^^^^^^^^^^^^
14
note: required by a bound in `std::collections::HashMap::<K, V, S, A>::insert`
15
...

1
$ cargo test -p pebble-value
2
    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.01s
3
     Running unittests src/lib.rs (target/debug/deps/pebble_value-8a12146cf753ccc2)
4

5
running 2 tests
6
test tests::list_identity_not_structure_for_equality ... ok
7
test tests::map_keys_survive_nan_and_lists ... ok
8

9
test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
10

11
   Doc-tests pebble_value
12

13
running 0 tests
14

15
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

1
/// `lhs + rhs` with number/string/list overloading.
2
pub fn add(lhs: &Value, rhs: &Value, span: Span) -> Result<Value, RuntimeError> {
3
    match (lhs, rhs) {
4
        (Value::Int(a), Value::Int(b)) => a
5
            .checked_add(*b)
6
            .map(Value::Int)
7
            .ok_or_else(|| overflow(span)),
8
        (Value::Int(a), Value::Float(b)) => Ok(Value::Float(*a as f64 + b)),
9
        (Value::Float(a), Value::Int(b)) => Ok(Value::Float(a + *b as f64)),
10
        (Value::Float(a), Value::Float(b)) => Ok(Value::Float(a + b)),
11
        (Value::Str(a), Value::Str(b)) => {
12
            let mut text = String::with_capacity(a.len() + b.len());
13
            text.push_str(a);
14
            text.push_str(b);
15
            Ok(Value::string(text))
16
        }
17
        (Value::List(a), Value::List(b)) => {
18
            let mut items = a.borrow().clone();
19
            items.extend(b.borrow().iter().cloned());
20
            Ok(Value::list(items))
21
        }
22
        _ => Err(TypeError::binary("+", lhs, rhs).into_error(span)),
23
    }
24
}

1
/// Describes a type mismatch, with a note suggesting a conversion.
2
struct TypeError {
3
    op: String,
4
    lhs: String,
5
    rhs: String,
6
}
7

8
impl TypeError {
9
    fn binary(op: &str, lhs: &Value, rhs: &Value) -> Self {
10
        Self {
11
            op: op.to_string(),
12
            lhs: lhs.type_name().to_string(),
13
            rhs: rhs.type_name().to_string(),
14
        }
15
    }
16

17
    fn into_error(self, span: Span) -> RuntimeError {
18
        RuntimeError::new(
19
            span,
20
            format!(
21
                "cannot apply `{}` to {} and {}",
22
                self.op, self.lhs, self.rhs
23
            ),
24
        )
25
        .with_note("operands of arithmetic operators must both be numbers")
26
    }
27
}