In Rust, is there a way to make function accept two types without a trait?

I am pretty new to Rust. My question is more theoretical. The problem is this.

I have a state machine (to parse XML via quick-xml crate but this is not important for this question) whose transition logic is controlled by a match expression. A lot of branches of the expression have additional match guards. Most of those match guards are pretty identical and look like:

Event::Start(bs: BytesStart) if bs.local_name().as_ref() == b"any-tag" => NextState,
// and
Event::End(be: BytesEnd) if be.local_name().as_ref() == b"any-tag" => SomeOtherState,

To clean up the code I would like to move that equality comparison to a separate function, like:

fn tag_is(tag: &<either BytesStart or BytesEnd>, assertion: &str) -> bool {
    tag.local_name().as_ref() == assertion.as_bytes()
}
// and use it
Event::Start(bs: BytesStart) if tag_is(&bs, "any-tag") => NextState,

BytesStart and BytesEnd are different structs/types, and both have their own .local_name() methods. If the .local_name() was defined in some trait (TraitWithLocalName) and implemented for both, then I would write a generic like:

fn tag_is(tag: &impl TraitWithLocalName, assertion: &str) -> bool {...}

So, the question is, how to deal with that kind of situation - when a function might accept various types of an argument, which don't share the same trait?

You can write your own trait that has this function and implement it for both BytesStart and BytesEnd.

You cannot do this with a function. If you really wanted to, you could try doing it with a macro. I would strongly prefer defining my own trait to doing things this way, but it's up to you.

macro_rules! tag_is {
    ($x: expr, $assertion: expr) => {{
        let assertion: &str = $assertion; // type checking - makes sure assertion is a str.
        let s: &[u8] = $x.local_name().as_ref();
        s == assertion.as_bytes()
    }} 
}

struct BytesStart;

impl BytesStart {
    fn local_name(&self) -> &str {
        "hello"
    }
}

struct BytesEnd;

impl BytesEnd {
    fn local_name(&self) -> &[u8] {
        b"any-tag"
    }
}

pub fn main() {
    println!("{}", tag_is!(BytesStart, "any-tag")); // false
    println!("{}", tag_is!(BytesEnd, "any-tag")); // true
}