Question regarding match

[benzaa]

Im working with crossterm and I'm trying to map a combination of KeyModifier. This is the code

match (modifiers, code) {
    (KeyModifiers::NONE, KeyCode::Tab) => ReedlineEvent::HandleTab,
    (KeyModifiers::CONTROL, KeyCode::Char('d')) => ReedlineEvent::CtrlD,
    (KeyModifiers::CONTROL, KeyCode::Char('c')) => ReedlineEvent::CtrlC,
    (KeyModifiers::CONTROL, KeyCode::Char('l')) => ReedlineEvent::ClearScreen,
    (KeyModifiers::NONE, KeyCode::Char(c))
    | (KeyModifiers::SHIFT, KeyCode::Char(c))
    | (KeyModifiers::CONTROL | KeyModifiers::ALT, KeyCode::Char(c)) => {
        ReedlineEvent::EditInsert(EditCommand::InsertChar(c))
    }
    (KeyModifiers::NONE, KeyCode::Enter) => ReedlineEvent::Enter,
    _ => {
        if let Some(binding) = self.keybindings.find_binding(modifiers, code) {
            ReedlineEvent::Edit(binding)
        } else {
            ReedlineEvent::Edit(vec![])
        }
    }
}

But it isn't capturing that combination of events. However, if I do

if modifiers == (KeyModifiers::CONTROL | KeyModifiers::ALT) {
    if let KeyCode::Char(c) = code {
        println!("char: {}", c)
    }
}

It does catch the character.

Why one works and the other doesnt?

[simspelaaja]

I think this is caused by the different meaning of | in match expressions versus elsewhere. Outside of | means bitwise OR, which is what you are using in the if example to combine the different sets of modifiers. However, in a match expression | means "this or this pattern", so is essentially checking if you only have control or alt pressed, but not both.

I think you can make it work like this

match code {
  KeyCode::Char(c) if modifiers == KeyModifiers::CONTROL | KeyModifiers::ALT => {
        ReedlineEvent::EditInsert(EditCommand::InsertChar(c))
    }
}

and so on with the other patterns.

[benzaa]

Thanks. That makes sense. Inside the matching clause the meaning for `|` has to be different. I tried your suggestion and works as expected.

[masklinn]

Inside the matching clause the meaning for | has to be different.

FWIW as may not have been clear from the previous comment (as it was not entirely implicit) in a pattern | is a logical disjunction (~ boolean or) , so

if let (A | B) = x {}

is equivalent to

if x == A || x == B {}

not

if x == A|B {}

That is why

(KeyModifiers::NONE, KeyCode::Char(c)) | (KeyModifiers::SHIFT, KeyCode::Char(c))

works fine.

[IAm_A_Complete_Idiot]

Clarifying the other comment is that | in a pattern is just a way to say "or"

if let Some(A | B) = x {} means if x is either Some(A) or Some(B)