Exhaustivity checking for 1-to-1 mapping between enums - rust

Question

I'm writing some basic bioinformatics code to transcribe DNA to RNA:
pub enum DnaNucleotide {
A,
C,
G,
T,
}
pub enum RnaNucleotide {
A,
C,
G,
U,
}
fn transcribe(base: &DnaNucleotide) -> RnaNucleotide {
match base {
DnaNucleotide::A => RnaNucleotide::A,
DnaNucleotide::C => RnaNucleotide::C,
DnaNucleotide::G => RnaNucleotide::G,
DnaNucleotide::T => RnaNucleotide::U,
}
}
Is there a way to get the compiler to do an exhaustivity check also on the right side of the match statement, basically ensuring a 1-1 mapping between the two enums?
(A related question: The above is probably better represented with some kind of bijective map, but I don't want to lose the exhaustivity checking. Is there a better way?)

Answer 1

The fact that a one-to-one correspondence exists between two enums suggests that you should really only be using one enum behind the scenes. Here is an example of a data model that I think suits your needs. This is naturally exhaustive because there is only a single enum to begin with.
use core::fmt::{Debug, Error, Formatter};
enum NucleicAcid {
Dna,
Rna,
}
enum Nucleotide {
A,
C,
G,
TU,
}
struct BasePair {
nucleic_acid: NucleicAcid,
nucleotide: Nucleotide,
}
impl BasePair {
fn new(nucleic_acid: NucleicAcid, nucleotide: Nucleotide) -> Self {
Self {
nucleic_acid,
nucleotide,
}
}
}
impl Debug for BasePair {
fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
use NucleicAcid::*;
use Nucleotide::*;
let BasePair {
nucleic_acid,
nucleotide,
} = self;
let nucleic_acid_str = match nucleic_acid {
Dna => "dna",
Rna => "rna",
};
let nucleotide_str = match nucleotide {
A => "A",
C => "C",
G => "G",
TU => match nucleic_acid {
Dna => "T",
Rna => "U",
},
};
f.write_fmt(format_args!("{}:{}", nucleic_acid_str, nucleotide_str))
}
}
fn main() {
let bp1 = BasePair::new(NucleicAcid::Dna, Nucleotide::TU);
let bp2 = BasePair::new(NucleicAcid::Rna, Nucleotide::C);
println!("{:?}, {:?}", bp1, bp2);
// dna:T, rna:C
}