Arc<Mutex>

Guides

Rust walkthroughs

← Back to all guides

What is the purpose of dashmap::DashSet compared to DashMap<K, ()> for concurrent set operations?

DashSet provides a more ergonomic and semantically correct API for set operations while internally using DashMap<K, ()>, eliminating the need to work with meaningless () values and providing dedicated set methods like insert, remove, and contains that return the expected boolean results rather than Option<()>. Both are functionally equivalent in terms of concurrency and performance, but DashSet expresses intent clearly and reduces boilerplate for the common "I only need to track presence" use case.

The Relationship Between DashSet and DashMap

use dashmap::{DashMap, DashSet};
 
fn relationship() {
    // Internally, DashSet is essentially:
    // struct DashSet<T>(DashMap<T, ()>);
    
    // Both store keys with sharding for concurrent access
    // DashSet wraps DashMap and hides the () value
    
    let set: DashSet<String> = DashSet::new();
    let map: DashMap<String, ()> = DashMap::new();
    
    // DashSet is simpler for set semantics
    set.insert("key".to_string());
    
    // DashMap requires the () value
    map.insert("key".to_string(), ());
}

DashSet is a thin wrapper around DashMap<K, ()> that provides a cleaner API.

Basic Set Operations

use dashmap::DashSet;
 
fn basic_operations() {
    let set: DashSet<i32> = DashSet::new();
    
    // Insert returns bool (true if newly inserted)
    let was_new = set.insert(1);
    assert!(was_new);  // First insert
    
    let was_new_again = set.insert(1);
    assert!(!was_new_again);  // Already existed
    
    // Contains checks presence
    assert!(set.contains(&1));
    assert!(!set.contains(&2));
    
    // Remove returns bool (true if it existed)
    let existed = set.remove(&1);
    assert!(existed);
    
    let existed_again = set.remove(&1);
    assert!(!existed_again);  // Already removed
}

DashSet provides intuitive set operations with boolean return values.

Equivalent DashMap Operations

use dashmap::DashMap;
 
fn equivalent_operations() {
    let map: DashMap<i32, ()> = DashMap::new();
    
    // Insert returns Option<V> (None if new)
    let previous = map.insert(1, ());
    assert!(previous.is_none());  // First insert
    
    let previous_again = map.insert(1, ());
    assert!(previous_again.is_some());  // Existed, returns Some(())
    
    // Contains checks presence
    assert!(map.contains_key(&1));
    assert!(!map.contains_key(&2));
    
    // Remove returns Option<V>
    let removed = map.remove(&1);
    assert!(removed.is_some());  // Returns Some(())
    
    let removed_again = map.remove(&1);
    assert!(removed_again.is_none());  // Didn't exist
}

DashMap requires handling Option<()> instead of simple booleans.

The Ergonomics Difference

use dashmap::{DashMap, DashSet};
 
fn ergonomics_comparison() {
    // DashSet: Clean, semantic API
    let set: DashSet<String> = DashSet::new();
    
    if set.insert("item".to_string()) {
        println!("New item added");
    }
    
    if set.remove(&"item".to_string()) {
        println!("Item removed");
    }
    
    // DashMap: Extra noise with () values
    let map: DashMap<String, ()> = DashMap::new();
    
    if map.insert("item".to_string(), ()).is_none() {
        println!("New item added");
    }
    
    if map.remove(&"item".to_string()).is_some() {
        println!("Item removed");
    }
}

DashSet returns booleans directly, avoiding Option<()> handling.

Set-Specific Methods

use dashmap::DashSet;
 
fn set_methods() {
    let set: DashSet<i32> = DashSet::new();
    
    // Set-specific methods that make sense for collections of unique items
    
    set.insert(1);
    set.insert(2);
    set.insert(3);
    
    // Iteration over values (not key-value pairs)
    for value in set.iter() {
        println!("Value: {}", value);
    }
    
    // Set cardinality
    assert_eq!(set.len(), 3);
    
    // Check emptiness
    assert!(!set.is_empty());
    
    // Clear all entries
    set.clear();
    assert!(set.is_empty());
}

DashSet methods operate on values directly, not key-value pairs.

DashMap's Key-Value Focus

use dashmap::DashMap;
 
fn map_methods() {
    let map: DashMap<i32, ()> = DashMap::new();
    
    // Must always work with the () value
    
    map.insert(1, ());
    map.insert(2, ());
    map.insert(3, ());
    
    // Iteration over key-value pairs
    for entry in map.iter() {
        let (key, _value) = entry.key_value();
        // _value is always (), pointless to handle
        println!("Key: {}", key);
    }
    
    // Or iterate over keys only
    for key in map.iter() {
        println!("Key: {}", key.key());
    }
}

DashMap forces you to handle the meaningless () value throughout.

Memory Layout Comparison

use dashmap::{DashMap, DashSet};
 
fn memory_layout() {
    // Both use the same internal structure
    // DashMap shards its entries across multiple shards
    // Each shard is an RwLock<HashMap<K, V>>
    
    // DashSet internally: DashMap<K, ()>
    // The () is a zero-sized type, so it doesn't add memory overhead
    
    let set: DashSet<String> = DashSet::new();
    let map: DashMap<String, ()> = DashMap::new();
    
    // Memory overhead is essentially identical
    // The () takes no space, but the API differs
    
    // Both benefit from:
    // - Sharded locking for concurrent access
    // - Cache-friendly iteration
    // - Atomic operations per shard
}

Memory overhead is identical; () is zero-sized.

Concurrent Access Patterns

use dashmap::DashSet;
use std::sync::Arc;
use std::thread;
 
fn concurrent_access() {
    let set: Arc<DashSet<i32>> = Arc::new(DashSet::new());
    
    let mut handles = vec![];
    
    for i in 0..10 {
        let set_clone = Arc::clone(&set);
        handles.push(thread::spawn(move || {
            // Multiple threads can insert concurrently
            set_clone.insert(i);
            
            // Check presence
            if set_clone.contains(&i) {
                println!("Thread {} found its value", i);
            }
        }));
    }
    
    for handle in handles {
        handle.join().unwrap();
    }
    
    // All values inserted concurrently
    assert_eq!(set.len(), 10);
}

Both types support concurrent operations with sharded locking.

The View Pattern

use dashmap::DashSet;
 
fn view_pattern() {
    let set: DashSet<String> = DashSet::new();
    
    set.insert("hello".to_string());
    set.insert("world".to_string());
    
    // Get a view of an entry
    if let Some(entry) = set.get(&"hello".to_string()) {
        // entry is a reference guard
        println!("Found: {}", entry);
    }
    
    // With DashMap, you'd get a key-value pair
    // But with DashSet, you just get the value
}

DashSet::get returns a value reference, not a key-value reference.

Set Operations Between Collections

use dashmap::DashSet;
use std::collections::HashSet;
 
fn set_operations() {
    let set: DashSet<i32> = DashSet::new();
    set.insert(1);
    set.insert(2);
    set.insert(3);
    
    // Convert to standard HashSet for complex operations
    let hash_set: HashSet<i32> = set.iter().map(|v| *v).collect();
    
    // DashSet doesn't have union, intersection, etc.
    // You'd need to implement them or convert
    
    let other: HashSet<i32> = [2, 3, 4].into_iter().collect();
    
    // Intersection
    let intersection: HashSet<i32> = hash_set.intersection(&other).copied().collect();
    assert_eq!(intersection, [2, 3].into_iter().collect::<HashSet<_>>());
}

DashSet lacks mathematical set operations; convert to HashSet for those.

Use Case: Tracking Active Connections

use dashmap::DashSet;
use std::sync::Arc;
use std::net::SocketAddr;
 
fn active_connections() {
    let active: Arc<DashSet<SocketAddr>> = Arc::new(DashSet::new());
    
    // When connection starts
    let addr: SocketAddr = "127.0.0.1:8080".parse().unwrap();
    active.insert(addr);
    
    // Check if connection is active
    if active.contains(&addr) {
        println!("Connection {} is active", addr);
    }
    
    // When connection ends
    active.remove(&addr);
    
    // The DashSet expresses "presence tracking" clearly
    // DashMap would require () everywhere, obscuring intent
}

DashSet clearly expresses "I'm tracking which items exist."

Use Case: Deduplication

use dashmap::DashSet;
use std::sync::Arc;
use std::thread;
 
fn deduplication() {
    let seen: Arc<DashSet<String>> = Arc::new(DashSet::new());
    
    let handles: Vec<_> = (0..10)
        .map(|i| {
            let seen = Arc::clone(&seen);
            thread::spawn(move || {
                let value = format!("item-{}", i % 3);  // Duplicates
                
                // insert returns true if new
                if seen.insert(value.clone()) {
                    println!("New: {}", value);
                } else {
                    println!("Duplicate: {}", value);
                }
            })
        })
        .collect();
    
    for handle in handles {
        handle.join().unwrap();
    }
    
    // Only 3 unique values
    assert_eq!(seen.len(), 3);
}

DashSet::insert returning bool is perfect for deduplication logic.

When DashMap Is Still Needed

use dashmap::DashMap;
 
fn when_to_use_map() {
    // Use DashMap when:
    // 1. You need to store actual values with keys
    
    let counters: DashMap<String, i32> = DashMap::new();
    counters.insert("requests", 0);
    counters.entry("requests").and_modify(|v| *v += 1);
    
    // 2. You need entry API for conditional updates
    
    let config: DashMap<String, String> = DashMap::new();
    config.entry("timeout".to_string())
        .or_insert("30s".to_string());
    
    // 3. You need to update values
    
    let scores: DashMap<String, u32> = DashMap::new();
    scores.insert("player1".to_string(), 100);
    scores.entry("player1".to_string()).and_modify(|s| *s += 50);
}

Use DashMap when you need associated values or complex entry operations.

Performance Characteristics

use dashmap::{DashMap, DashSet};
 
fn performance() {
    // Both have identical performance characteristics
    
    // 1. Sharding divides data across multiple locks
    //    - Default is number of CPUs * 4
    //    - Reduces contention between threads
    
    // 2. Operations are O(1) average case
    //    - Hash to find shard, then HashMap operation
    
    // 3. Memory overhead
    //    - DashSet stores: key + ()
    //    - DashMap stores: key + value
    //    - Since () is ZST, memory is identical
    
    // 4. Cache behavior
    //    - Iteration is cache-friendly within each shard
    
    // The choice between DashSet and DashMap<K, ()> is purely
    // ergonomic, not performance-related
}

Performance is identical; the choice is purely about API ergonomics.

Entry API Comparison

use dashmap::{DashMap, DashSet};
 
fn entry_api() {
    // DashMap has rich entry API
    let map: DashMap<String, i32> = DashMap::new();
    map.entry("key".to_string())
        .or_insert(0)
        .and_modify(|v| *v += 1);
    
    // DashSet has simpler entry API
    let set: DashSet<String> = DashSet::new();
    
    // Entry API exists but simpler
    set.entry("key".to_string()).or_insert();
    // No value to modify, just presence
    
    // If you need rich updates, use DashMap
    // If you just need presence, use DashSet
}

DashSet has a simpler entry API since there's no value to modify.

Reading DashSet Source

// Conceptually, DashSet is implemented like:
 
pub struct DashSet<T> {
    inner: DashMap<T, ()>,
}
 
impl<T> DashSet<T> {
    pub fn insert(&self, key: T) -> bool {
        self.inner.insert(key, ()).is_none()
    }
    
    pub fn contains(&self, key: &T) -> bool {
        self.inner.contains_key(key)
    }
    
    pub fn remove(&self, key: &T) -> bool {
        self.inner.remove(key).is_some()
    }
}

DashSet wraps DashMap and translates return types.

Synthesis

Comparison table:

Aspect DashSet<T> DashMap<T, ()>
Insert returns bool (true if new) Option<()> (None if new)
Remove returns bool (true if existed) Option<()> (Some if existed)
Contains method contains(&T) contains_key(&T)
Iteration iter() yields &T iter() yields (&K, &V)
Entry API Simpler (no value) Full entry API
Memory overhead Same (ZST for ()) Same
Performance Identical Identical
Semantic clarity "Collection of items" "Keys with void values"

Key insight: DashSet exists purely for ergonomics and semantic clarity. Internally, it's implemented as DashMap<K, ()>, so there's no performance or memory difference. The benefit is in the API: insert returns bool instead of Option<()>, contains is named clearly instead of contains_key, and iteration yields values directly instead of key-value pairs. Use DashSet when you're tracking presence (active connections, seen items, unique identifiers) and don't need associated values. Use DashMap<T, ()> only if you're stuck with an API that expects a DashMap, or if you need the more complex entry API for some reason. The choice between them is about expressing intent clearly—DashSet says "this is a set," while DashMap<K, ()> says "this is a map with meaningless values."