fn with_active_symbols<T>(logic: impl FnOnce(&mut Symbols) -> T) -> T {

    let mut symbols = ACTIVE_SYMBOLS.lock().expect("poisoned");

    if symbols.is_none() {

        *symbols = Some(Symbols {

            active: HashSet::new(),

            slots: Vec::new(),

            free_slots: Vec::new(),

        });

    }

    logic(symbols.as_mut().expect("always initialized"))

}

#[derive(Debug, Clone)]

    pub fn as_str(&self) -> &str {

        &self.0 .0.value

    }

    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {

        self.0 .0.index.hash(state);

    }

    fn eq(&self, other: &Self) -> bool {

        self.0 .0.index == other.0 .0.index

    }

#[derive(Debug, Clone)]

    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {

        self.0.value.hash(state);

    }

    fn eq(&self, other: &Self) -> bool {

        self.0.index == other.0.index

    }

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

        f.write_str(self)

    }

    fn borrow(&self) -> &str {

        &self.0.value

    }

    fn from(sym: &'a str) -> Self {

        with_active_symbols(|symbols| {

            if let Some(symbol) = symbols.active.get(sym).cloned() {

                Symbol(symbol)

                let value = sym.to_string();

                let index = if let Some(free_slot) = symbols.free_slots.pop() {

                    free_slot

                    let slot_id = symbols.slots.len();

                    symbols.slots.push(None);

                    slot_id

                let symbol = Symbol(SharedData(Arc::new(Data {

                    index,

                    value,

                    freeing: AtomicBool::new(false),

                })));

                symbols.active.insert(symbol.0.clone());

                symbols.slots[index] = Some(symbol.clone());

                symbol

        })

    }

    fn deref(&self) -> &Self::Target {

        &self.0 .0.value

    }

    fn eq(&self, other: &str) -> bool {

        &**self == other

    }

    fn eq(&self, other: &&'a str) -> bool {

        self == *other

    }

    fn drop(&mut self) {

        // The main Symbols structure holds two strong references to the same

        // Arc we hold. Thus, if we reach 3 strong count (our ref included), we

        // need to remove the symbol so it can be freeed.

        //

        // We can use any form of atomics here because if the strong count is 3,

        // we can be guaranteed the only thread able to free our data is this

        // thread.

        if Arc::strong_count(&self.0) == 3

            && self

                .0

                .freeing

                .compare_exchange(

                    false,

                    true,

                    atomic::Ordering::Relaxed,

                    atomic::Ordering::Relaxed,

                )

                .is_ok()

        {

            with_active_symbols(|symbols| {

                // Check that the strong count hasn't changed. If it has, we

                // need to allow the symbol to stay alive.

                if Arc::strong_count(&self.0) > 3 {

                    self.0.freeing.store(false, atomic::Ordering::Relaxed);

                } else {

                    symbols.active.remove(self);

                    symbols.slots[self.0.index] = None;

                    symbols.free_slots.push(self.0.index);

                }

            });

        }

    }

#[test]

fn basics() {

    let first_symbol = Symbol::from("basics-test-symbol");

    let slot = first_symbol.0 .0.index;

    let first_again = Symbol::from("basics-test-symbol");

    assert_eq!(slot, first_again.0 .0.index);

    assert_eq!(first_symbol, first_again);

    drop(first_again);

    // Dropping the second copy shouldn't free the underlying symbol

    with_active_symbols(|symbols| {

        assert!(symbols.active.contains("basics-test-symbol"));

        assert!(!symbols.slots.is_empty());

        assert!(symbols.slots[slot].is_some());

        assert!(!symbols.free_slots.iter().any(|free| *free == slot));

    });

    drop(first_symbol);

    with_active_symbols(|symbols| {

        assert!(!symbols.active.contains("basics-test-symbol"));

        match &symbols.slots[slot] {

                assert!(symbols.free_slots.iter().any(|free| *free == slot));

    });

}