Struct Arcmo

Source

pub struct Arcmo<T: Clone> { /* private fields */ }

Expand description

A wrapper combining Arc and Mutex for convenient shared mutable access to optional values Only works with types that implement Clone

Implementations§

Source §

impl<T: Clone> Arcmo<T>

Source

pub fn none() -> Self

Creates a new empty Arcmo

Examples found in repository ?

examples/arcmo_example.rs (line 14)

3fn main() {
4    println!("=== Creating Arcmo instances ===");
5    // Create with Some value
6    let v = Arcmo::some(42);
7    println!("Created with some: v = {:?}", v);
8
9    // Create with Default (None)
10    let default: Arcmo<i32> = Arcmo::default();
11    println!("Created with default: default = {:?}", default);
12
13    // Create explicitly as None
14    let none: Arcmo<i32> = Arcmo::none();
15    println!("Created as none: none = {:?}", none);
16
17    println!("\n=== Basic value operations ===");
18    println!("v.value() = {:?}", v.value());
19    println!("v.is_some() = {}", v.is_some());
20    println!("v.is_none() = {}", v.is_none());
21
22    println!("\n=== Modification ===");
23    // Modify existing value
24    v.modify(|x| *x += 1);
25    println!("After v += 1: {:?}", v.value());
26
27    v.modify(|x| *x *= 2);
28    println!("After v *= 2: {:?}", v.value());
29
30    // Try to modify None (should have no effect)
31    none.modify(|x| *x = 100);
32    println!("After trying to modify None: {:?}", none.value());
33
34    println!("\n=== Multiple references ===");
35    let v2 = v.clone();
36    v.modify(|x| *x += 5);
37    println!("Modified through v: {:?}", v.value());
38    println!("Observed through v2: {:?}", v2.value());
39
40    println!("\n=== Weak references ===");
41    let weak = v.downgrade();
42    println!("Weak reference: {:?}", weak);
43    println!("weak.value() = {:?}", weak.value());
44    println!("weak.is_some() = {}", weak.is_some());
45    println!("weak.is_none() = {}", weak.is_none());
46
47    // Modify through weak reference
48    weak.modify(|x| *x += 10);
49    println!("\nAfter weak modify:");
50    println!("Observed through strong ref: {:?}", v.value());
51    println!("Observed through weak ref: {:?}", weak.value());
52
53    println!("\n=== Take and Replace operations ===");
54    println!("Taking value from v: {:?}", v.take());
55    println!("After take:");
56    println!("v.is_none() = {}", v.is_none());
57    println!("weak.is_none() = {}", weak.is_none());
58
59    println!("\nReplacing with new value:");
60    let previous = v.replace(100);
61    println!("Previous value: {:?}", previous);
62    println!("New value through v: {:?}", v.value());
63    println!("New value through weak: {:?}", weak.value());
64
65    println!("\n=== Weak reference behavior when strong ref is dropped ===");
66    {
67        let temp = Arcmo::some(999);
68        let weak_temp = temp.downgrade();
69        println!("Before drop - weak_temp.value() = {:?}", weak_temp.value());
70        drop(temp);
71        println!("After drop - weak_temp.value() = {:?}", weak_temp.value());
72    }
73
74    println!("\n=== Complex type example ===");
75    let vec_arcmo = Arcmo::some(vec![1, 2, 3]);
76    println!("Vector Arcmo: {:?}", vec_arcmo);
77
78    vec_arcmo.modify(|v| v.push(4));
79    println!("After push: {:?}", vec_arcmo.value());
80
81    let weak_vec = vec_arcmo.downgrade();
82    weak_vec.modify(|v| v.extend_from_slice(&[5, 6]));
83    println!("After weak modify: {:?}", vec_arcmo.value());
84
85    println!("\n=== Default for different types ===");
86    let default_vec: Arcmo<Vec<i32>> = Arcmo::default();
87    let default_string: Arcmo<String> = Arcmo::default();
88    println!("Default Vec<i32>: {:?}", default_vec);
89    println!("Default String: {:?}", default_string);
90}

Source

pub fn some(value: T) -> Self

Creates a new Arcmo containing Some(value)

Examples found in repository ?

examples/arcmo_example.rs (line 6)

3fn main() {
4    println!("=== Creating Arcmo instances ===");
5    // Create with Some value
6    let v = Arcmo::some(42);
7    println!("Created with some: v = {:?}", v);
8
9    // Create with Default (None)
10    let default: Arcmo<i32> = Arcmo::default();
11    println!("Created with default: default = {:?}", default);
12
13    // Create explicitly as None
14    let none: Arcmo<i32> = Arcmo::none();
15    println!("Created as none: none = {:?}", none);
16
17    println!("\n=== Basic value operations ===");
18    println!("v.value() = {:?}", v.value());
19    println!("v.is_some() = {}", v.is_some());
20    println!("v.is_none() = {}", v.is_none());
21
22    println!("\n=== Modification ===");
23    // Modify existing value
24    v.modify(|x| *x += 1);
25    println!("After v += 1: {:?}", v.value());
26
27    v.modify(|x| *x *= 2);
28    println!("After v *= 2: {:?}", v.value());
29
30    // Try to modify None (should have no effect)
31    none.modify(|x| *x = 100);
32    println!("After trying to modify None: {:?}", none.value());
33
34    println!("\n=== Multiple references ===");
35    let v2 = v.clone();
36    v.modify(|x| *x += 5);
37    println!("Modified through v: {:?}", v.value());
38    println!("Observed through v2: {:?}", v2.value());
39
40    println!("\n=== Weak references ===");
41    let weak = v.downgrade();
42    println!("Weak reference: {:?}", weak);
43    println!("weak.value() = {:?}", weak.value());
44    println!("weak.is_some() = {}", weak.is_some());
45    println!("weak.is_none() = {}", weak.is_none());
46
47    // Modify through weak reference
48    weak.modify(|x| *x += 10);
49    println!("\nAfter weak modify:");
50    println!("Observed through strong ref: {:?}", v.value());
51    println!("Observed through weak ref: {:?}", weak.value());
52
53    println!("\n=== Take and Replace operations ===");
54    println!("Taking value from v: {:?}", v.take());
55    println!("After take:");
56    println!("v.is_none() = {}", v.is_none());
57    println!("weak.is_none() = {}", weak.is_none());
58
59    println!("\nReplacing with new value:");
60    let previous = v.replace(100);
61    println!("Previous value: {:?}", previous);
62    println!("New value through v: {:?}", v.value());
63    println!("New value through weak: {:?}", weak.value());
64
65    println!("\n=== Weak reference behavior when strong ref is dropped ===");
66    {
67        let temp = Arcmo::some(999);
68        let weak_temp = temp.downgrade();
69        println!("Before drop - weak_temp.value() = {:?}", weak_temp.value());
70        drop(temp);
71        println!("After drop - weak_temp.value() = {:?}", weak_temp.value());
72    }
73
74    println!("\n=== Complex type example ===");
75    let vec_arcmo = Arcmo::some(vec![1, 2, 3]);
76    println!("Vector Arcmo: {:?}", vec_arcmo);
77
78    vec_arcmo.modify(|v| v.push(4));
79    println!("After push: {:?}", vec_arcmo.value());
80
81    let weak_vec = vec_arcmo.downgrade();
82    weak_vec.modify(|v| v.extend_from_slice(&[5, 6]));
83    println!("After weak modify: {:?}", vec_arcmo.value());
84
85    println!("\n=== Default for different types ===");
86    let default_vec: Arcmo<Vec<i32>> = Arcmo::default();
87    let default_string: Arcmo<String> = Arcmo::default();
88    println!("Default Vec<i32>: {:?}", default_vec);
89    println!("Default String: {:?}", default_string);
90}

Source

pub fn modify<F, R>(&self, f: F) -> R
where T: Default, F: FnOnce(&mut T) -> R,

Modifies the contained value using the provided closure. If no value exists, creates one using T::Default before applying the modification. Returns the result of the closure.

Examples found in repository ?

examples/arcmo_example.rs (line 24)

3fn main() {
4    println!("=== Creating Arcmo instances ===");
5    // Create with Some value
6    let v = Arcmo::some(42);
7    println!("Created with some: v = {:?}", v);
8
9    // Create with Default (None)
10    let default: Arcmo<i32> = Arcmo::default();
11    println!("Created with default: default = {:?}", default);
12
13    // Create explicitly as None
14    let none: Arcmo<i32> = Arcmo::none();
15    println!("Created as none: none = {:?}", none);
16
17    println!("\n=== Basic value operations ===");
18    println!("v.value() = {:?}", v.value());
19    println!("v.is_some() = {}", v.is_some());
20    println!("v.is_none() = {}", v.is_none());
21
22    println!("\n=== Modification ===");
23    // Modify existing value
24    v.modify(|x| *x += 1);
25    println!("After v += 1: {:?}", v.value());
26
27    v.modify(|x| *x *= 2);
28    println!("After v *= 2: {:?}", v.value());
29
30    // Try to modify None (should have no effect)
31    none.modify(|x| *x = 100);
32    println!("After trying to modify None: {:?}", none.value());
33
34    println!("\n=== Multiple references ===");
35    let v2 = v.clone();
36    v.modify(|x| *x += 5);
37    println!("Modified through v: {:?}", v.value());
38    println!("Observed through v2: {:?}", v2.value());
39
40    println!("\n=== Weak references ===");
41    let weak = v.downgrade();
42    println!("Weak reference: {:?}", weak);
43    println!("weak.value() = {:?}", weak.value());
44    println!("weak.is_some() = {}", weak.is_some());
45    println!("weak.is_none() = {}", weak.is_none());
46
47    // Modify through weak reference
48    weak.modify(|x| *x += 10);
49    println!("\nAfter weak modify:");
50    println!("Observed through strong ref: {:?}", v.value());
51    println!("Observed through weak ref: {:?}", weak.value());
52
53    println!("\n=== Take and Replace operations ===");
54    println!("Taking value from v: {:?}", v.take());
55    println!("After take:");
56    println!("v.is_none() = {}", v.is_none());
57    println!("weak.is_none() = {}", weak.is_none());
58
59    println!("\nReplacing with new value:");
60    let previous = v.replace(100);
61    println!("Previous value: {:?}", previous);
62    println!("New value through v: {:?}", v.value());
63    println!("New value through weak: {:?}", weak.value());
64
65    println!("\n=== Weak reference behavior when strong ref is dropped ===");
66    {
67        let temp = Arcmo::some(999);
68        let weak_temp = temp.downgrade();
69        println!("Before drop - weak_temp.value() = {:?}", weak_temp.value());
70        drop(temp);
71        println!("After drop - weak_temp.value() = {:?}", weak_temp.value());
72    }
73
74    println!("\n=== Complex type example ===");
75    let vec_arcmo = Arcmo::some(vec![1, 2, 3]);
76    println!("Vector Arcmo: {:?}", vec_arcmo);
77
78    vec_arcmo.modify(|v| v.push(4));
79    println!("After push: {:?}", vec_arcmo.value());
80
81    let weak_vec = vec_arcmo.downgrade();
82    weak_vec.modify(|v| v.extend_from_slice(&[5, 6]));
83    println!("After weak modify: {:?}", vec_arcmo.value());
84
85    println!("\n=== Default for different types ===");
86    let default_vec: Arcmo<Vec<i32>> = Arcmo::default();
87    let default_string: Arcmo<String> = Arcmo::default();
88    println!("Default Vec<i32>: {:?}", default_vec);
89    println!("Default String: {:?}", default_string);
90}

Source

pub fn take(&self) -> Option<T>

Sets the value to None and returns the previous value if it existed

Examples found in repository ?

examples/arcmo_example.rs (line 54)

3fn main() {
4    println!("=== Creating Arcmo instances ===");
5    // Create with Some value
6    let v = Arcmo::some(42);
7    println!("Created with some: v = {:?}", v);
8
9    // Create with Default (None)
10    let default: Arcmo<i32> = Arcmo::default();
11    println!("Created with default: default = {:?}", default);
12
13    // Create explicitly as None
14    let none: Arcmo<i32> = Arcmo::none();
15    println!("Created as none: none = {:?}", none);
16
17    println!("\n=== Basic value operations ===");
18    println!("v.value() = {:?}", v.value());
19    println!("v.is_some() = {}", v.is_some());
20    println!("v.is_none() = {}", v.is_none());
21
22    println!("\n=== Modification ===");
23    // Modify existing value
24    v.modify(|x| *x += 1);
25    println!("After v += 1: {:?}", v.value());
26
27    v.modify(|x| *x *= 2);
28    println!("After v *= 2: {:?}", v.value());
29
30    // Try to modify None (should have no effect)
31    none.modify(|x| *x = 100);
32    println!("After trying to modify None: {:?}", none.value());
33
34    println!("\n=== Multiple references ===");
35    let v2 = v.clone();
36    v.modify(|x| *x += 5);
37    println!("Modified through v: {:?}", v.value());
38    println!("Observed through v2: {:?}", v2.value());
39
40    println!("\n=== Weak references ===");
41    let weak = v.downgrade();
42    println!("Weak reference: {:?}", weak);
43    println!("weak.value() = {:?}", weak.value());
44    println!("weak.is_some() = {}", weak.is_some());
45    println!("weak.is_none() = {}", weak.is_none());
46
47    // Modify through weak reference
48    weak.modify(|x| *x += 10);
49    println!("\nAfter weak modify:");
50    println!("Observed through strong ref: {:?}", v.value());
51    println!("Observed through weak ref: {:?}", weak.value());
52
53    println!("\n=== Take and Replace operations ===");
54    println!("Taking value from v: {:?}", v.take());
55    println!("After take:");
56    println!("v.is_none() = {}", v.is_none());
57    println!("weak.is_none() = {}", weak.is_none());
58
59    println!("\nReplacing with new value:");
60    let previous = v.replace(100);
61    println!("Previous value: {:?}", previous);
62    println!("New value through v: {:?}", v.value());
63    println!("New value through weak: {:?}", weak.value());
64
65    println!("\n=== Weak reference behavior when strong ref is dropped ===");
66    {
67        let temp = Arcmo::some(999);
68        let weak_temp = temp.downgrade();
69        println!("Before drop - weak_temp.value() = {:?}", weak_temp.value());
70        drop(temp);
71        println!("After drop - weak_temp.value() = {:?}", weak_temp.value());
72    }
73
74    println!("\n=== Complex type example ===");
75    let vec_arcmo = Arcmo::some(vec![1, 2, 3]);
76    println!("Vector Arcmo: {:?}", vec_arcmo);
77
78    vec_arcmo.modify(|v| v.push(4));
79    println!("After push: {:?}", vec_arcmo.value());
80
81    let weak_vec = vec_arcmo.downgrade();
82    weak_vec.modify(|v| v.extend_from_slice(&[5, 6]));
83    println!("After weak modify: {:?}", vec_arcmo.value());
84
85    println!("\n=== Default for different types ===");
86    let default_vec: Arcmo<Vec<i32>> = Arcmo::default();
87    let default_string: Arcmo<String> = Arcmo::default();
88    println!("Default Vec<i32>: {:?}", default_vec);
89    println!("Default String: {:?}", default_string);
90}

Source

pub fn replace(&self, value: T) -> Option<T>

Sets the value to Some(value) and returns the previous value if it existed

Examples found in repository ?

examples/arcmo_example.rs (line 60)

3fn main() {
4    println!("=== Creating Arcmo instances ===");
5    // Create with Some value
6    let v = Arcmo::some(42);
7    println!("Created with some: v = {:?}", v);
8
9    // Create with Default (None)
10    let default: Arcmo<i32> = Arcmo::default();
11    println!("Created with default: default = {:?}", default);
12
13    // Create explicitly as None
14    let none: Arcmo<i32> = Arcmo::none();
15    println!("Created as none: none = {:?}", none);
16
17    println!("\n=== Basic value operations ===");
18    println!("v.value() = {:?}", v.value());
19    println!("v.is_some() = {}", v.is_some());
20    println!("v.is_none() = {}", v.is_none());
21
22    println!("\n=== Modification ===");
23    // Modify existing value
24    v.modify(|x| *x += 1);
25    println!("After v += 1: {:?}", v.value());
26
27    v.modify(|x| *x *= 2);
28    println!("After v *= 2: {:?}", v.value());
29
30    // Try to modify None (should have no effect)
31    none.modify(|x| *x = 100);
32    println!("After trying to modify None: {:?}", none.value());
33
34    println!("\n=== Multiple references ===");
35    let v2 = v.clone();
36    v.modify(|x| *x += 5);
37    println!("Modified through v: {:?}", v.value());
38    println!("Observed through v2: {:?}", v2.value());
39
40    println!("\n=== Weak references ===");
41    let weak = v.downgrade();
42    println!("Weak reference: {:?}", weak);
43    println!("weak.value() = {:?}", weak.value());
44    println!("weak.is_some() = {}", weak.is_some());
45    println!("weak.is_none() = {}", weak.is_none());
46
47    // Modify through weak reference
48    weak.modify(|x| *x += 10);
49    println!("\nAfter weak modify:");
50    println!("Observed through strong ref: {:?}", v.value());
51    println!("Observed through weak ref: {:?}", weak.value());
52
53    println!("\n=== Take and Replace operations ===");
54    println!("Taking value from v: {:?}", v.take());
55    println!("After take:");
56    println!("v.is_none() = {}", v.is_none());
57    println!("weak.is_none() = {}", weak.is_none());
58
59    println!("\nReplacing with new value:");
60    let previous = v.replace(100);
61    println!("Previous value: {:?}", previous);
62    println!("New value through v: {:?}", v.value());
63    println!("New value through weak: {:?}", weak.value());
64
65    println!("\n=== Weak reference behavior when strong ref is dropped ===");
66    {
67        let temp = Arcmo::some(999);
68        let weak_temp = temp.downgrade();
69        println!("Before drop - weak_temp.value() = {:?}", weak_temp.value());
70        drop(temp);
71        println!("After drop - weak_temp.value() = {:?}", weak_temp.value());
72    }
73
74    println!("\n=== Complex type example ===");
75    let vec_arcmo = Arcmo::some(vec![1, 2, 3]);
76    println!("Vector Arcmo: {:?}", vec_arcmo);
77
78    vec_arcmo.modify(|v| v.push(4));
79    println!("After push: {:?}", vec_arcmo.value());
80
81    let weak_vec = vec_arcmo.downgrade();
82    weak_vec.modify(|v| v.extend_from_slice(&[5, 6]));
83    println!("After weak modify: {:?}", vec_arcmo.value());
84
85    println!("\n=== Default for different types ===");
86    let default_vec: Arcmo<Vec<i32>> = Arcmo::default();
87    let default_string: Arcmo<String> = Arcmo::default();
88    println!("Default Vec<i32>: {:?}", default_vec);
89    println!("Default String: {:?}", default_string);
90}

Source

pub fn value(&self) -> Option<T>

Returns a copy of the contained value if it exists

Examples found in repository ?

examples/arcmo_example.rs (line 18)

3fn main() {
4    println!("=== Creating Arcmo instances ===");
5    // Create with Some value
6    let v = Arcmo::some(42);
7    println!("Created with some: v = {:?}", v);
8
9    // Create with Default (None)
10    let default: Arcmo<i32> = Arcmo::default();
11    println!("Created with default: default = {:?}", default);
12
13    // Create explicitly as None
14    let none: Arcmo<i32> = Arcmo::none();
15    println!("Created as none: none = {:?}", none);
16
17    println!("\n=== Basic value operations ===");
18    println!("v.value() = {:?}", v.value());
19    println!("v.is_some() = {}", v.is_some());
20    println!("v.is_none() = {}", v.is_none());
21
22    println!("\n=== Modification ===");
23    // Modify existing value
24    v.modify(|x| *x += 1);
25    println!("After v += 1: {:?}", v.value());
26
27    v.modify(|x| *x *= 2);
28    println!("After v *= 2: {:?}", v.value());
29
30    // Try to modify None (should have no effect)
31    none.modify(|x| *x = 100);
32    println!("After trying to modify None: {:?}", none.value());
33
34    println!("\n=== Multiple references ===");
35    let v2 = v.clone();
36    v.modify(|x| *x += 5);
37    println!("Modified through v: {:?}", v.value());
38    println!("Observed through v2: {:?}", v2.value());
39
40    println!("\n=== Weak references ===");
41    let weak = v.downgrade();
42    println!("Weak reference: {:?}", weak);
43    println!("weak.value() = {:?}", weak.value());
44    println!("weak.is_some() = {}", weak.is_some());
45    println!("weak.is_none() = {}", weak.is_none());
46
47    // Modify through weak reference
48    weak.modify(|x| *x += 10);
49    println!("\nAfter weak modify:");
50    println!("Observed through strong ref: {:?}", v.value());
51    println!("Observed through weak ref: {:?}", weak.value());
52
53    println!("\n=== Take and Replace operations ===");
54    println!("Taking value from v: {:?}", v.take());
55    println!("After take:");
56    println!("v.is_none() = {}", v.is_none());
57    println!("weak.is_none() = {}", weak.is_none());
58
59    println!("\nReplacing with new value:");
60    let previous = v.replace(100);
61    println!("Previous value: {:?}", previous);
62    println!("New value through v: {:?}", v.value());
63    println!("New value through weak: {:?}", weak.value());
64
65    println!("\n=== Weak reference behavior when strong ref is dropped ===");
66    {
67        let temp = Arcmo::some(999);
68        let weak_temp = temp.downgrade();
69        println!("Before drop - weak_temp.value() = {:?}", weak_temp.value());
70        drop(temp);
71        println!("After drop - weak_temp.value() = {:?}", weak_temp.value());
72    }
73
74    println!("\n=== Complex type example ===");
75    let vec_arcmo = Arcmo::some(vec![1, 2, 3]);
76    println!("Vector Arcmo: {:?}", vec_arcmo);
77
78    vec_arcmo.modify(|v| v.push(4));
79    println!("After push: {:?}", vec_arcmo.value());
80
81    let weak_vec = vec_arcmo.downgrade();
82    weak_vec.modify(|v| v.extend_from_slice(&[5, 6]));
83    println!("After weak modify: {:?}", vec_arcmo.value());
84
85    println!("\n=== Default for different types ===");
86    let default_vec: Arcmo<Vec<i32>> = Arcmo::default();
87    let default_string: Arcmo<String> = Arcmo::default();
88    println!("Default Vec<i32>: {:?}", default_vec);
89    println!("Default String: {:?}", default_string);
90}

Source

pub fn is_some(&self) -> bool

Returns true if the contained value is Some

Examples found in repository ?

examples/arcmo_example.rs (line 19)

3fn main() {
4    println!("=== Creating Arcmo instances ===");
5    // Create with Some value
6    let v = Arcmo::some(42);
7    println!("Created with some: v = {:?}", v);
8
9    // Create with Default (None)
10    let default: Arcmo<i32> = Arcmo::default();
11    println!("Created with default: default = {:?}", default);
12
13    // Create explicitly as None
14    let none: Arcmo<i32> = Arcmo::none();
15    println!("Created as none: none = {:?}", none);
16
17    println!("\n=== Basic value operations ===");
18    println!("v.value() = {:?}", v.value());
19    println!("v.is_some() = {}", v.is_some());
20    println!("v.is_none() = {}", v.is_none());
21
22    println!("\n=== Modification ===");
23    // Modify existing value
24    v.modify(|x| *x += 1);
25    println!("After v += 1: {:?}", v.value());
26
27    v.modify(|x| *x *= 2);
28    println!("After v *= 2: {:?}", v.value());
29
30    // Try to modify None (should have no effect)
31    none.modify(|x| *x = 100);
32    println!("After trying to modify None: {:?}", none.value());
33
34    println!("\n=== Multiple references ===");
35    let v2 = v.clone();
36    v.modify(|x| *x += 5);
37    println!("Modified through v: {:?}", v.value());
38    println!("Observed through v2: {:?}", v2.value());
39
40    println!("\n=== Weak references ===");
41    let weak = v.downgrade();
42    println!("Weak reference: {:?}", weak);
43    println!("weak.value() = {:?}", weak.value());
44    println!("weak.is_some() = {}", weak.is_some());
45    println!("weak.is_none() = {}", weak.is_none());
46
47    // Modify through weak reference
48    weak.modify(|x| *x += 10);
49    println!("\nAfter weak modify:");
50    println!("Observed through strong ref: {:?}", v.value());
51    println!("Observed through weak ref: {:?}", weak.value());
52
53    println!("\n=== Take and Replace operations ===");
54    println!("Taking value from v: {:?}", v.take());
55    println!("After take:");
56    println!("v.is_none() = {}", v.is_none());
57    println!("weak.is_none() = {}", weak.is_none());
58
59    println!("\nReplacing with new value:");
60    let previous = v.replace(100);
61    println!("Previous value: {:?}", previous);
62    println!("New value through v: {:?}", v.value());
63    println!("New value through weak: {:?}", weak.value());
64
65    println!("\n=== Weak reference behavior when strong ref is dropped ===");
66    {
67        let temp = Arcmo::some(999);
68        let weak_temp = temp.downgrade();
69        println!("Before drop - weak_temp.value() = {:?}", weak_temp.value());
70        drop(temp);
71        println!("After drop - weak_temp.value() = {:?}", weak_temp.value());
72    }
73
74    println!("\n=== Complex type example ===");
75    let vec_arcmo = Arcmo::some(vec![1, 2, 3]);
76    println!("Vector Arcmo: {:?}", vec_arcmo);
77
78    vec_arcmo.modify(|v| v.push(4));
79    println!("After push: {:?}", vec_arcmo.value());
80
81    let weak_vec = vec_arcmo.downgrade();
82    weak_vec.modify(|v| v.extend_from_slice(&[5, 6]));
83    println!("After weak modify: {:?}", vec_arcmo.value());
84
85    println!("\n=== Default for different types ===");
86    let default_vec: Arcmo<Vec<i32>> = Arcmo::default();
87    let default_string: Arcmo<String> = Arcmo::default();
88    println!("Default Vec<i32>: {:?}", default_vec);
89    println!("Default String: {:?}", default_string);
90}

Source

pub fn is_none(&self) -> bool

Returns true if the contained value is None

Examples found in repository ?

examples/arcmo_example.rs (line 20)

3fn main() {
4    println!("=== Creating Arcmo instances ===");
5    // Create with Some value
6    let v = Arcmo::some(42);
7    println!("Created with some: v = {:?}", v);
8
9    // Create with Default (None)
10    let default: Arcmo<i32> = Arcmo::default();
11    println!("Created with default: default = {:?}", default);
12
13    // Create explicitly as None
14    let none: Arcmo<i32> = Arcmo::none();
15    println!("Created as none: none = {:?}", none);
16
17    println!("\n=== Basic value operations ===");
18    println!("v.value() = {:?}", v.value());
19    println!("v.is_some() = {}", v.is_some());
20    println!("v.is_none() = {}", v.is_none());
21
22    println!("\n=== Modification ===");
23    // Modify existing value
24    v.modify(|x| *x += 1);
25    println!("After v += 1: {:?}", v.value());
26
27    v.modify(|x| *x *= 2);
28    println!("After v *= 2: {:?}", v.value());
29
30    // Try to modify None (should have no effect)
31    none.modify(|x| *x = 100);
32    println!("After trying to modify None: {:?}", none.value());
33
34    println!("\n=== Multiple references ===");
35    let v2 = v.clone();
36    v.modify(|x| *x += 5);
37    println!("Modified through v: {:?}", v.value());
38    println!("Observed through v2: {:?}", v2.value());
39
40    println!("\n=== Weak references ===");
41    let weak = v.downgrade();
42    println!("Weak reference: {:?}", weak);
43    println!("weak.value() = {:?}", weak.value());
44    println!("weak.is_some() = {}", weak.is_some());
45    println!("weak.is_none() = {}", weak.is_none());
46
47    // Modify through weak reference
48    weak.modify(|x| *x += 10);
49    println!("\nAfter weak modify:");
50    println!("Observed through strong ref: {:?}", v.value());
51    println!("Observed through weak ref: {:?}", weak.value());
52
53    println!("\n=== Take and Replace operations ===");
54    println!("Taking value from v: {:?}", v.take());
55    println!("After take:");
56    println!("v.is_none() = {}", v.is_none());
57    println!("weak.is_none() = {}", weak.is_none());
58
59    println!("\nReplacing with new value:");
60    let previous = v.replace(100);
61    println!("Previous value: {:?}", previous);
62    println!("New value through v: {:?}", v.value());
63    println!("New value through weak: {:?}", weak.value());
64
65    println!("\n=== Weak reference behavior when strong ref is dropped ===");
66    {
67        let temp = Arcmo::some(999);
68        let weak_temp = temp.downgrade();
69        println!("Before drop - weak_temp.value() = {:?}", weak_temp.value());
70        drop(temp);
71        println!("After drop - weak_temp.value() = {:?}", weak_temp.value());
72    }
73
74    println!("\n=== Complex type example ===");
75    let vec_arcmo = Arcmo::some(vec![1, 2, 3]);
76    println!("Vector Arcmo: {:?}", vec_arcmo);
77
78    vec_arcmo.modify(|v| v.push(4));
79    println!("After push: {:?}", vec_arcmo.value());
80
81    let weak_vec = vec_arcmo.downgrade();
82    weak_vec.modify(|v| v.extend_from_slice(&[5, 6]));
83    println!("After weak modify: {:?}", vec_arcmo.value());
84
85    println!("\n=== Default for different types ===");
86    let default_vec: Arcmo<Vec<i32>> = Arcmo::default();
87    let default_string: Arcmo<String> = Arcmo::default();
88    println!("Default Vec<i32>: {:?}", default_vec);
89    println!("Default String: {:?}", default_string);
90}

Source

pub fn downgrade(&self) -> WeakArcmo<T>

Returns a weak reference to the contained value

Examples found in repository ?

examples/arcmo_example.rs (line 41)

3fn main() {
4    println!("=== Creating Arcmo instances ===");
5    // Create with Some value
6    let v = Arcmo::some(42);
7    println!("Created with some: v = {:?}", v);
8
9    // Create with Default (None)
10    let default: Arcmo<i32> = Arcmo::default();
11    println!("Created with default: default = {:?}", default);
12
13    // Create explicitly as None
14    let none: Arcmo<i32> = Arcmo::none();
15    println!("Created as none: none = {:?}", none);
16
17    println!("\n=== Basic value operations ===");
18    println!("v.value() = {:?}", v.value());
19    println!("v.is_some() = {}", v.is_some());
20    println!("v.is_none() = {}", v.is_none());
21
22    println!("\n=== Modification ===");
23    // Modify existing value
24    v.modify(|x| *x += 1);
25    println!("After v += 1: {:?}", v.value());
26
27    v.modify(|x| *x *= 2);
28    println!("After v *= 2: {:?}", v.value());
29
30    // Try to modify None (should have no effect)
31    none.modify(|x| *x = 100);
32    println!("After trying to modify None: {:?}", none.value());
33
34    println!("\n=== Multiple references ===");
35    let v2 = v.clone();
36    v.modify(|x| *x += 5);
37    println!("Modified through v: {:?}", v.value());
38    println!("Observed through v2: {:?}", v2.value());
39
40    println!("\n=== Weak references ===");
41    let weak = v.downgrade();
42    println!("Weak reference: {:?}", weak);
43    println!("weak.value() = {:?}", weak.value());
44    println!("weak.is_some() = {}", weak.is_some());
45    println!("weak.is_none() = {}", weak.is_none());
46
47    // Modify through weak reference
48    weak.modify(|x| *x += 10);
49    println!("\nAfter weak modify:");
50    println!("Observed through strong ref: {:?}", v.value());
51    println!("Observed through weak ref: {:?}", weak.value());
52
53    println!("\n=== Take and Replace operations ===");
54    println!("Taking value from v: {:?}", v.take());
55    println!("After take:");
56    println!("v.is_none() = {}", v.is_none());
57    println!("weak.is_none() = {}", weak.is_none());
58
59    println!("\nReplacing with new value:");
60    let previous = v.replace(100);
61    println!("Previous value: {:?}", previous);
62    println!("New value through v: {:?}", v.value());
63    println!("New value through weak: {:?}", weak.value());
64
65    println!("\n=== Weak reference behavior when strong ref is dropped ===");
66    {
67        let temp = Arcmo::some(999);
68        let weak_temp = temp.downgrade();
69        println!("Before drop - weak_temp.value() = {:?}", weak_temp.value());
70        drop(temp);
71        println!("After drop - weak_temp.value() = {:?}", weak_temp.value());
72    }
73
74    println!("\n=== Complex type example ===");
75    let vec_arcmo = Arcmo::some(vec![1, 2, 3]);
76    println!("Vector Arcmo: {:?}", vec_arcmo);
77
78    vec_arcmo.modify(|v| v.push(4));
79    println!("After push: {:?}", vec_arcmo.value());
80
81    let weak_vec = vec_arcmo.downgrade();
82    weak_vec.modify(|v| v.extend_from_slice(&[5, 6]));
83    println!("After weak modify: {:?}", vec_arcmo.value());
84
85    println!("\n=== Default for different types ===");
86    let default_vec: Arcmo<Vec<i32>> = Arcmo::default();
87    let default_string: Arcmo<String> = Arcmo::default();
88    println!("Default Vec<i32>: {:?}", default_vec);
89    println!("Default String: {:?}", default_string);
90}