smart_access 0.7.0

A minimalistic "lazy bidirectional pointer" framework.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

#![no_std]

use smart_access::Cps;

#[test]
fn test1() {
    let mut foo = 3;

    foo.batch_ct().add(|x,_| { *x += 1; } ).run();

    assert!(foo == 4);
}

#[test]
fn test2() {
    let mut foo = [1, 2, 3, 4, 5, 6];

    let bar = (&mut foo[..]).at(0).replace(7);
    assert!(foo == [7, 2, 3, 4, 5, 6]);
    assert!(bar == Some(1));
}


// copied almost verbatim from core_impls.rs

#[test]
fn test_slice() {
    let mut foo = [1,2,3,4,5];

    let update = |i| move |slice: &mut [i32]| {
        let old_value = slice[0];
        
        slice[0] = i;

        old_value
    };
    
    assert!((&mut foo[..]).at(1..3).access(update(6)) == Some(2));
    assert!(foo == [1,6,3,4,5]);
    
    assert!((&mut foo[..]).at(2..).access(update(7)) == Some(3));
    assert!(foo == [1,6,7,4,5]);
    
    assert!((&mut foo[..]).at(..4).access(update(8)) == Some(1));
    assert!(foo == [8,6,7,4,5]);
    
    assert!((&mut foo[..]).at(..).access(update(9)) == Some(8));
    assert!(foo == [9,6,7,4,5]);
    
    assert!((&mut foo[..]).at(..=6).access(update(1)) == None);
    assert!(foo == [9,6,7,4,5]);
    
    assert!((&mut foo[..]).at(3..=4).access(update(0)) == Some(4));
    assert!(foo == [9,6,7,0,5]);

    assert!((&mut foo[..]).at(4).replace(1) == Some(5));
    assert!(foo == [9,6,7,0,1]);
}

#[test]
fn test_optional() {
    let mut foo: Option<i32> = Some(0);
    let mut bar: Option<i32> = None;

    assert!(foo.at(()).replace(1) == Some(0));
    assert!(foo == Some(1));
    assert!(bar.at(()).replace(2) == None);
    assert!(bar == None);

    let mut foo: Result<i32,i32> = Ok(0);
    let mut bar: Result<i32,i32> = Err(1);
    
    assert!(foo.at(()).replace(1) == Some(0));
    assert!(foo == Ok(1));
    assert!(bar.at(()).replace(2) == None);
    assert!(bar == Err(1));
}


#[cfg(feature="detach")]
#[test]
fn test_detach() {
    let mut foo = Some(Some(Some(0)));
    let mut bar = Some(Some(Some(0)));

    let (_, detached) = foo.at(()).at(()).at(()).detach();
    let the_same_path = detached.clone();

    bar.attach(the_same_path).replace(1);
    assert!(foo == Some(Some(Some(0))));
    assert!(bar == Some(Some(Some(1))));

    foo.attach(detached).replace(2);
    assert!(foo == Some(Some(Some(2))));
    assert!(bar == Some(Some(Some(1))));

    let (_, path) = bar.at(()).at(()).detach();
    bar.attach(path.at(())).replace(3);
    assert!(bar == Some(Some(Some(3))));
}