use core::hash::Hash;

use beancount_types::Link;

use xxhash_rust::xxh3::Xxh3;

            TransactionKind::Purchase | TransactionKind::Sale
        ) {
            transaction.add_link(
                Link::try_from(format!("^union-investment.{:X}", hash(date, &context))).unwrap(),
            );
        }
        if matches!(
            transaction_kind,

}
fn hash(date: Date, context: &TemplateContext) -> u128 {
    let mut hasher = Xxh3::new();
    (context.depot, context.position, date.year(), date.month()).hash(&mut hasher);
    hasher.digest128()

xxhash-rust.workspace    = true

#![warn(clippy::all, clippy::nursery, clippy::pedantic)]

    /// Produces an iterator over the segments of the path.
    pub fn segments(&self) -> Segments<'_> {
        Segments {
            inner: self.name.split(':'),

    /// Returns the final segment of the account name.
    #[must_use]
    pub fn leaf_name(&self) -> &Seg {
        let leaf = self
            .name
            .rsplit_once(':')
            .map_or(&self.name, |(_, leaf)| leaf);
        unsafe {
            // SAFETY: By construction, if `self` is a valid account name, `leaf` is a valid account segment.
            Seg::from_unchecked(leaf)

        self.name.split_once(':').map(|(parent, _)| {

        self.name.rsplit_once(':').map(|(parent, _)| {

    }
    /// Produces an iterator over the segments of the path.
    pub fn segments(&self) -> Segments<'_> {
        Segments {
            inner: self.name.split(':'),
        }

}

impl Acc {

        self.name.hash(state)

        self.name.hash(state);

impl PartialOrd<Cow<'_, Acc>> for Acc {
    fn partial_cmp(&self, other: &Cow<'_, Acc>) -> Option<Ordering> {

impl PartialOrd<Cow<'_, Self>> for Acc {
    fn partial_cmp(&self, other: &Cow<'_, Self>) -> Option<Ordering> {

impl From<&Account> for Account {

impl From<&Self> for Account {

    fn from(value: &Account) -> Self {

    fn from(value: &Self) -> Self {

        (**self).hash(state)

        (**self).hash(state);

 "xxhash-rust",