Correct naming conventions in rna-transcription exercise (#991)

* Correct naming conventions in rna-transcription exercise

Closes #986

* Revert camel-casing for comments

Author: benreyn

exercises/rna-transcription/example.rs

@@ -28,13 +28,13 @@ impl Nucleotide {
 ///
 /// Guaranteed that Uracil is not present thanks to `new`.
 #[derive(Debug, Eq, PartialEq, Clone)]
-pub struct DNA(Vec<Nucleotide>);
+pub struct Dna(Vec<Nucleotide>);
 
-impl DNA {
+impl Dna {
     /// Parse a DNA string, checking it is valid.
     ///
     /// The error value is the first invalid character index (char index, not utf8).
-    pub fn new(input: &str) -> Result<DNA, usize> {
+    pub fn new(input: &str) -> Result<Dna, usize> {
         let mut out = Vec::new();
         for (idx, ch) in input.chars().enumerate() {
             match Nucleotide::from_char(ch) {
@@ -46,10 +46,10 @@ impl DNA {
                 }
             }
         }
-        Ok(DNA(out))
+        Ok(Dna(out))
     }
 
-    pub fn into_rna(mut self) -> RNA {
+    pub fn into_rna(mut self) -> Rna {
         for nuc in self.0.iter_mut() {
             *nuc = match *nuc {
                 Nucleotide::Adenine => Nucleotide::Uracil,
@@ -59,18 +59,18 @@ impl DNA {
                 Nucleotide::Uracil => unreachable!(),
             }
         }
-        RNA(self.0)
+        Rna(self.0)
     }
 }
 
 #[derive(Debug, Eq, PartialEq, Clone)]
-pub struct RNA(Vec<Nucleotide>);
+pub struct Rna(Vec<Nucleotide>);
 
-impl RNA {
+impl Rna {
     /// Parse a RNA string, checking it is valid.
     ///
     /// The error value is the first invalid character index (char index, not utf8).
-    pub fn new(input: &str) -> Result<RNA, usize> {
+    pub fn new(input: &str) -> Result<Rna, usize> {
         let mut out = Vec::new();
         for (idx, ch) in input.chars().enumerate() {
             match Nucleotide::from_char(ch) {
@@ -82,6 +82,6 @@ impl RNA {
                 }
             }
         }
-        Ok(RNA(out))
+        Ok(Rna(out))
     }
 }

exercises/rna-transcription/src/lib.rs

@@ -1,21 +1,21 @@
 #[derive(Debug, PartialEq)]
-pub struct DNA;
+pub struct Dna;
 
 #[derive(Debug, PartialEq)]
-pub struct RNA;
+pub struct Rna;
 
-impl DNA {
-    pub fn new(dna: &str) -> Result<DNA, usize> {
-        unimplemented!("Construct new DNA from '{}' string. If string contains invalid nucleotides return index of first invalid nucleotide", dna);
+impl Dna {
+    pub fn new(dna: &str) -> Result<Dna, usize> {
+        unimplemented!("Construct new Dna from '{}' string. If string contains invalid nucleotides return index of first invalid nucleotide", dna);
     }
 
-    pub fn into_rna(self) -> RNA {
-        unimplemented!("Transform DNA {:?} into corresponding RNA", self);
+    pub fn into_rna(self) -> Rna {
+        unimplemented!("Transform Dna {:?} into corresponding Rna", self);
     }
 }
 
-impl RNA {
-    pub fn new(rna: &str) -> Result<RNA, usize> {
-        unimplemented!("Construct new RNA from '{}' string. If string contains invalid nucleotides return index of first invalid nucleotide", rna);
+impl Rna {
+    pub fn new(rna: &str) -> Result<Rna, usize> {
+        unimplemented!("Construct new Rna from '{}' string. If string contains invalid nucleotides return index of first invalid nucleotide", rna);
     }
 }

exercises/rna-transcription/tests/rna-transcription.rs

@@ -2,87 +2,87 @@ use rna_transcription as dna;
 
 #[test]
 fn test_valid_dna_input() {
-    assert!(dna::DNA::new("GCTA").is_ok());
+    assert!(dna::Dna::new("GCTA").is_ok());
 }
 
 #[test]
 #[ignore]
 fn test_valid_rna_input() {
-    assert!(dna::RNA::new("CGAU").is_ok());
+    assert!(dna::Rna::new("CGAU").is_ok());
 }
 
 #[test]
 #[ignore]
 fn test_invalid_dna_input() {
     // Invalid character
-    assert_eq!(dna::DNA::new("X").err(), Some(0));
+    assert_eq!(dna::Dna::new("X").err(), Some(0));
     // Valid nucleotide, but invalid in context
-    assert_eq!(dna::DNA::new("U").err(), Some(0));
+    assert_eq!(dna::Dna::new("U").err(), Some(0));
     // Longer string with contained errors
-    assert_eq!(dna::DNA::new("ACGTUXXCTTAA").err(), Some(4));
+    assert_eq!(dna::Dna::new("ACGTUXXCTTAA").err(), Some(4));
 }
 
 #[test]
 #[ignore]
 fn test_invalid_rna_input() {
     // Invalid character
-    assert_eq!(dna::RNA::new("X").unwrap_err(), 0);
+    assert_eq!(dna::Rna::new("X").unwrap_err(), 0);
     // Valid nucleotide, but invalid in context
-    assert_eq!(dna::RNA::new("T").unwrap_err(), 0);
+    assert_eq!(dna::Rna::new("T").unwrap_err(), 0);
     // Longer string with contained errors
-    assert_eq!(dna::RNA::new("ACGUTTXCUUAA").unwrap_err(), 4);
+    assert_eq!(dna::Rna::new("ACGUTTXCUUAA").unwrap_err(), 4);
 }
 
 #[test]
 #[ignore]
 fn test_acid_equals_acid() {
-    assert_eq!(dna::DNA::new("CGA").unwrap(), dna::DNA::new("CGA").unwrap());
-    assert_ne!(dna::DNA::new("CGA").unwrap(), dna::DNA::new("AGC").unwrap());
-    assert_eq!(dna::RNA::new("CGA").unwrap(), dna::RNA::new("CGA").unwrap());
-    assert_ne!(dna::RNA::new("CGA").unwrap(), dna::RNA::new("AGC").unwrap());
+    assert_eq!(dna::Dna::new("CGA").unwrap(), dna::Dna::new("CGA").unwrap());
+    assert_ne!(dna::Dna::new("CGA").unwrap(), dna::Dna::new("AGC").unwrap());
+    assert_eq!(dna::Rna::new("CGA").unwrap(), dna::Rna::new("CGA").unwrap());
+    assert_ne!(dna::Rna::new("CGA").unwrap(), dna::Rna::new("AGC").unwrap());
 }
 
 #[test]
 #[ignore]
 fn test_transcribes_cytosine_guanine() {
     assert_eq!(
-        dna::RNA::new("G").unwrap(),
-        dna::DNA::new("C").unwrap().into_rna()
+        dna::Rna::new("G").unwrap(),
+        dna::Dna::new("C").unwrap().into_rna()
     );
 }
 
 #[test]
 #[ignore]
 fn test_transcribes_guanine_cytosine() {
     assert_eq!(
-        dna::RNA::new("C").unwrap(),
-        dna::DNA::new("G").unwrap().into_rna()
+        dna::Rna::new("C").unwrap(),
+        dna::Dna::new("G").unwrap().into_rna()
     );
 }
 
 #[test]
 #[ignore]
 fn test_transcribes_adenine_uracil() {
     assert_eq!(
-        dna::RNA::new("U").unwrap(),
-        dna::DNA::new("A").unwrap().into_rna()
+        dna::Rna::new("U").unwrap(),
+        dna::Dna::new("A").unwrap().into_rna()
     );
 }
 
 #[test]
 #[ignore]
 fn test_transcribes_thymine_to_adenine() {
     assert_eq!(
-        dna::RNA::new("A").unwrap(),
-        dna::DNA::new("T").unwrap().into_rna()
+        dna::Rna::new("A").unwrap(),
+        dna::Dna::new("T").unwrap().into_rna()
     );
 }
 
 #[test]
 #[ignore]
 fn test_transcribes_all_dna_to_rna() {
     assert_eq!(
-        dna::RNA::new("UGCACCAGAAUU").unwrap(),
-        dna::DNA::new("ACGTGGTCTTAA").unwrap().into_rna()
+        dna::Rna::new("UGCACCAGAAUU").unwrap(),
+        dna::Dna::new("ACGTGGTCTTAA").unwrap().into_rna()
     )
 }