put version and version operator in the same Option in the Atom struct

All atoms must either have a version with a version operator, or have
no version and no version operator. Putting these in the same Option
helps encode that into the type system.

src/atom/parsers.rs

@@ -253,36 +253,52 @@ impl<'a> Parseable<'a, &'a str> for Atom {
     type Parser = impl Parser<&'a str, Output = Self>;
 
     fn parser() -> Self::Parser {
-        Blocker::parser()
+        let usedeps = || {
+            UseDep::parser()
+                .separated_by(tag(","))
+                .many()
+                .delimited_by(tag("["), tag("]"))
+                .opt()
+        };
+
+        let without_version = Blocker::parser()
             .opt()
-            .and(VersionOperator::parser().opt())
             .and(Category::parser())
             .and(Name::parser().preceded_by(tag("/")))
-            .and(Version::parser().preceded_by(tag("-")).opt())
             .and(Slot::parser().preceded_by(tag(":")).opt())
-            .and(
-                UseDep::parser()
-                    .separated_by(tag(","))
-                    .many()
-                    .delimited_by(tag("["), tag("]"))
-                    .opt(),
-            )
+            .and(usedeps())
+            .map(|((((blocker, category), name), slot), usedeps)| Atom {
+                blocker,
+                category,
+                name,
+                version: None,
+                slot,
+                usedeps: usedeps.unwrap_or(Vec::new()),
+            });
+
+        let with_version = Blocker::parser()
+            .opt()
+            .and(VersionOperator::parser())
+            .and(Category::parser())
+            .and(Name::parser().preceded_by(tag("/")))
+            .and(Version::parser().preceded_by(tag("-")))
+            .and(Slot::parser().preceded_by(tag(":")).opt())
+            .and(usedeps())
             .map(
                 |((((((blocker, version_operator), category), name), version), slot), usedeps)| {
                     Atom {
                         blocker,
-                        version_operator,
                         category,
                         name,
-                        version,
+                        version: Some((version_operator, version)),
                         slot,
                         usedeps: usedeps.unwrap_or(Vec::new()),
                     }
                 },
             )
-            .verify_output(|atom| match (&atom.version_operator, &atom.version) {
-                (Some(VersionOperator::Eq), Some(_)) => true,
-                (Some(_), Some(version))
+            .verify_output(|atom| match &atom.version {
+                Some((VersionOperator::Eq, _)) => true,
+                Some((_, version))
                     if !version
                         .numbers()
                         .iter()
@@ -290,9 +306,10 @@ impl<'a> Parseable<'a, &'a str> for Atom {
                 {
                     true
                 }
-                (None, None) => true,
                 _ => false,
-            })
+            });
+
+        with_version.or(without_version)
     }
 }