leaklist

A simple, concurrent, lock-free, singly-linked list. Only supports prepending items, and will leak an allocation for each new element.

This type of list can be useful for setting up a chain of objects that only need to be initialized once and will live for the duration of the program.

Example

let list: LeakList<u32> = LeakList::new();
let node1 = list.push_front(1);
let node2 = list.push_front(2);
println!("node1: {:?}", node1);
println!("node2: {:?}", node2);

std::thread::scope(|s| {
    s.spawn(|| {
        let node3 = list.push_front(3);
        println!("node3: {:?}", node3);
    });
    s.spawn(|| {
        let node4 = list.push_front(4);
        println!("node4: {:?}", node4);
    });
});

println!("list: {:?}", list.iter().copied().collect::<Vec<_>>());

Output may be:

node1: Node { val: 1, next: None }
node2: Node { val: 2, next: Some(Node { val: 1, next: None }) }
node3: Node { val: 3, next: Some(Node { val: 2, next: Some(Node { val: 1, next: None }) }) }
node4: Node { val: 4, next: Some(Node { val: 3, next: Some(Node { val: 2, next: Some(Node { val: 1, next: None }) }) }) }
list: [4, 3, 2, 1]

Or:

node1: Node { val: 1, next: None }
node2: Node { val: 2, next: Some(Node { val: 1, next: None }) }
node4: Node { val: 4, next: Some(Node { val: 2, next: Some(Node { val: 1, next: None }) }) }
node3: Node { val: 3, next: Some(Node { val: 4, next: Some(Node { val: 2, next: Some(Node { val: 1, next: None }) }) }) }
list: [3, 4, 2, 1]

License

This project is dual-licensed under the MIT and Apache-2.0 licenses.