Advent of Code 2020 in Rust day 5: bitvec

#[test]
fn test_input_one() {
    assert_eq!(process_seat("FBFBBFFRLR"), Seat { row: 44, column: 5 });
}

#[derive(Debug, Eq, PartialEq)]
struct Seat {
    row: usize,
    column: usize,
}
impl Seat {
    fn id(&self) -> usize {
        self.row * 8 + self.column
    }
}

fn process_seat(input: &str) -> Seat {
    let mut groups = input
        .chars()
        .group_by(|c| *c == 'F' || *c == 'B')
        .into_iter()
        .map(|(_, s)| {
            s.map(|v| match v {
                'B' | 'R' => true,
                'F' | 'L' => false,
                _ => panic!("asfkj"),
            })
            .collect::<BitVec>()
        })
        .collect::<Vec<_>>();

    groups[0].reverse();
    groups[1].reverse();

    Seat {
        row: groups[0][0..7].load::<u8>().into(),
        column: groups[1][0..].load::<u8>().into(),
    }
}

fn char_to_bool(c: char) -> bool {
    match c {
        'B' | 'R' => true,
        'F' | 'L' => false,
        _ => panic!("asfkj"),
    }
}

fn process_seat(input: &str) -> Seat {
    let mut a = input.chars().take(7).map(char_to_bool).collect::<BitVec>();
    let mut b = input
        .chars()
        .skip(7)
        .take(3)
        .map(char_to_bool)
        .collect::<BitVec>();

    a.reverse();
    b.reverse();

    Seat {
        row: a[0..].load::<u8>().into(),
        column: b[0..].load::<u8>().into(),
    }
}