diff --git a/src/atom/parsers.rs b/src/atom/parsers.rs
index 958ecee..3096e67 100644
--- a/src/atom/parsers.rs
+++ b/src/atom/parsers.rs
@@ -1,6 +1,6 @@
 use core::option::Option::None;
 
-use mon::{Parser, r#if, not, numeric1, one_of, opt, tag, take_while};
+use mon::{Parser, r#if, numeric1, one_of, tag};
 
 use crate::{
     atom::{
@@ -29,7 +29,7 @@ pub fn version_operator<'a>() -> impl Parser<&'a str, Output = VersionOperator>
 
 pub fn version_number<'a>() -> impl Parser<&'a str, Output = VersionNumber> {
     numeric1()
-        .followed_by(opt(tag("*")))
+        .followed_by(tag("*").opt())
         .recognize()
         .map(|output: &str| VersionNumber(output.to_string()))
 }
@@ -45,21 +45,19 @@ pub fn version_suffix_kind<'a>() -> impl Parser<&'a str, Output = VersionSuffixK
 
 pub fn version_suffix<'a>() -> impl Parser<&'a str, Output = VersionSuffix> {
     version_suffix_kind()
-        .and(opt(version_number()))
+        .and(version_number().opt())
         .map(|(kind, number)| VersionSuffix { kind, number })
 }
 
 pub fn version<'a>() -> impl Parser<&'a str, Output = Version> {
-    let numbers = version_number().separated_list1(tag("."));
-    let suffixes = version_suffix().separated_list(tag("_"));
+    let numbers = version_number().separated_list(tag("."), 1..);
+    let suffixes = version_suffix().separated_list(tag("_"), 0..);
     let rev = version_number().preceded_by(tag("-r"));
 
     numbers
-        .and(opt(r#if(|c: &char| {
-            c.is_ascii_alphabetic() && c.is_ascii_lowercase()
-        })))
-        .and(opt(suffixes.preceded_by(tag("_"))))
-        .and(opt(rev))
+        .and(r#if(|c: &char| c.is_ascii_alphabetic() && c.is_ascii_lowercase()).opt())
+        .and(suffixes.preceded_by(tag("_")).opt())
+        .and(rev.opt())
         .map(|(((numbers, letter), suffixes), rev)| Version {
             numbers,
             letter,
@@ -70,9 +68,7 @@ pub fn version<'a>() -> impl Parser<&'a str, Output = Version> {
 
 pub fn category<'a>() -> impl Parser<&'a str, Output = Category> {
     let start = r#if(|c: &char| c.is_ascii_alphanumeric() || *c == '_');
-    let rest = take_while(r#if(|c: &char| {
-        c.is_ascii_alphanumeric() || "+_.-".contains(*c)
-    }));
+    let rest = r#if(|c: &char| c.is_ascii_alphanumeric() || "+_.-".contains(*c)).list(0..);
 
     start
         .and(rest)
@@ -82,16 +78,13 @@ pub fn category<'a>() -> impl Parser<&'a str, Output = Category> {
 
 pub fn name<'a>() -> impl Parser<&'a str, Output = Name> {
     let start = r#if(|c: &char| c.is_ascii_alphanumeric() || *c == '_');
-    let rest = take_while(
-        r#if(|c: &char| c.is_ascii_alphanumeric() || "_+".contains(*c)).or(one_of("-".chars())
-            .and_not(
-                version()
-                    .preceded_by(tag("-"))
-                    .followed_by(not(r#if(|c: &char| {
-                        c.is_ascii_alphanumeric() || "_+-".contains(*c)
-                    }))),
-            )),
-    );
+    let rest = r#if(|c: &char| c.is_ascii_alphanumeric() || "_+".contains(*c))
+        .or(one_of("-".chars()).and_not(
+            version().preceded_by(tag("-")).followed_by(
+                r#if(|c: &char| c.is_ascii_alphanumeric() || "_+-".contains(*c)).not(),
+            ),
+        ))
+        .list(0..);
 
     start
         .and(rest)
@@ -107,9 +100,7 @@ pub fn slot_operator<'a>() -> impl Parser<&'a str, Output = SlotOperator> {
 
 pub fn slotname<'a>() -> impl Parser<&'a str, Output = SlotName> {
     let start = r#if(|c: &char| c.is_ascii_alphanumeric() || *c == '_');
-    let rest = take_while(r#if(|c: &char| {
-        c.is_ascii_alphanumeric() || "+_.-".contains(*c)
-    }));
+    let rest = r#if(|c: &char| c.is_ascii_alphanumeric() || "+_.-".contains(*c)).list(0..);
 
     start
         .and(rest)
@@ -118,9 +109,10 @@ pub fn slotname<'a>() -> impl Parser<&'a str, Output = SlotName> {
 }
 
 pub fn slot<'a>() -> impl Parser<&'a str, Output = Slot> {
-    opt(slotname())
-        .and(opt(slotname().preceded_by(tag("/"))))
-        .and(opt(slot_operator()))
+    slotname()
+        .opt()
+        .and(slotname().preceded_by(tag("/")).opt())
+        .and(slot_operator().opt())
         .map(|((slot, sub), operator)| Slot {
             slot,
             sub,
@@ -136,7 +128,7 @@ pub fn usedep_sign<'a>() -> impl Parser<&'a str, Output = UseDepSign> {
 
 pub fn usedep<'a>() -> impl Parser<&'a str, Output = UseDep> {
     let a = useflag()
-        .and(opt(usedep_sign()))
+        .and(usedep_sign().opt())
         .preceded_by(tag("-"))
         .map(|(flag, sign)| UseDep {
             negate: Some(UseDepNegate::Minus),
@@ -146,7 +138,7 @@ pub fn usedep<'a>() -> impl Parser<&'a str, Output = UseDep> {
         });
 
     let b = useflag()
-        .and(opt(usedep_sign()))
+        .and(usedep_sign().opt())
         .preceded_by(tag("!"))
         .followed_by(tag("?"))
         .map(|(flag, sign)| UseDep {
@@ -157,7 +149,7 @@ pub fn usedep<'a>() -> impl Parser<&'a str, Output = UseDep> {
         });
 
     let c = useflag()
-        .and(opt(usedep_sign()))
+        .and(usedep_sign().opt())
         .followed_by(tag("?"))
         .map(|(flag, sign)| UseDep {
             negate: None,
@@ -167,7 +159,7 @@ pub fn usedep<'a>() -> impl Parser<&'a str, Output = UseDep> {
         });
 
     let d = useflag()
-        .and(opt(usedep_sign()))
+        .and(usedep_sign().opt())
         .preceded_by(tag("!"))
         .followed_by(tag("="))
         .map(|(flag, sign)| UseDep {
@@ -178,7 +170,7 @@ pub fn usedep<'a>() -> impl Parser<&'a str, Output = UseDep> {
         });
 
     let e = useflag()
-        .and(opt(usedep_sign()))
+        .and(usedep_sign().opt())
         .followed_by(tag("="))
         .map(|(flag, sign)| UseDep {
             negate: None,
@@ -188,7 +180,7 @@ pub fn usedep<'a>() -> impl Parser<&'a str, Output = UseDep> {
         });
 
     let f = useflag()
-        .and(opt(usedep_sign()))
+        .and(usedep_sign().opt())
         .map(|(flag, sign)| UseDep {
             negate: None,
             flag,
@@ -200,15 +192,19 @@ pub fn usedep<'a>() -> impl Parser<&'a str, Output = UseDep> {
 }
 
 pub fn atom<'a>() -> impl Parser<&'a str, Output = Atom> {
-    opt(blocker())
-        .and(opt(version_operator()))
+    blocker()
+        .opt()
+        .and(version_operator().opt())
         .and(category())
         .and(name().preceded_by(tag("/")))
-        .and(opt(version().preceded_by(tag("-"))))
-        .and(opt(slot().preceded_by(tag(":"))))
-        .and(opt(usedep()
-            .separated_list(tag(","))
-            .delimited_by(tag("["), tag("]"))))
+        .and(version().preceded_by(tag("-")).opt())
+        .and(slot().preceded_by(tag(":")).opt())
+        .and(
+            usedep()
+                .separated_list(tag(","), 0..)
+                .delimited_by(tag("["), tag("]"))
+                .opt(),
+        )
         .map(
             |((((((blocker, version_operator), category), name), version), slot), usedeps)| Atom {
                 blocker,
diff --git a/src/depend/parsers.rs b/src/depend/parsers.rs
index 637d6f9..10da058 100644
--- a/src/depend/parsers.rs
+++ b/src/depend/parsers.rs
@@ -8,18 +8,18 @@ use crate::{
 
 fn expr(it: InputIter<&str>) -> ParserResult<&str, Expr> {
     let all_of = expr
-        .separated_list1(whitespace1())
+        .separated_list(whitespace1(), 1..)
         .delimited_by(tag("(").followed_by(whitespace1()), tag(")"))
         .map(|exprs| Expr::AllOf(exprs));
 
     let any_of = expr
-        .separated_list1(whitespace1())
+        .separated_list(whitespace1(), 1..)
         .delimited_by(tag("(").followed_by(whitespace1()), tag(")"))
         .preceded_by(tag("||").followed_by(whitespace1()))
         .map(|exprs| Expr::AnyOf(exprs));
 
     let one_of = expr
-        .separated_list1(whitespace1())
+        .separated_list(whitespace1(), 1..)
         .delimited_by(tag("(").followed_by(whitespace1()), tag(")"))
         .preceded_by(tag("^^").followed_by(whitespace1()))
         .map(|exprs| Expr::OneOf(exprs));
@@ -44,7 +44,7 @@ fn conditional<'a>() -> impl Parser<&'a str, Output = Conditional> {
 }
 
 pub fn exprs<'a>() -> impl Parser<&'a str, Output = Vec<Expr>> {
-    expr.separated_list1(whitespace1())
+    expr.separated_list(whitespace1(), 0..)
 }
 
 #[cfg(test)]
diff --git a/src/useflag/parsers.rs b/src/useflag/parsers.rs
index a430b3d..e7b73d1 100644
--- a/src/useflag/parsers.rs
+++ b/src/useflag/parsers.rs
@@ -1,12 +1,10 @@
-use mon::{Parser, r#if, take_while};
+use mon::{Parser, r#if};
 
 use crate::useflag::UseFlag;
 
 pub fn useflag<'a>() -> impl Parser<&'a str, Output = UseFlag> {
     let start = r#if(|c: &char| c.is_ascii_alphanumeric());
-    let rest = take_while(r#if(|c: &char| {
-        c.is_ascii_alphanumeric() || "+_@-".contains(*c)
-    }));
+    let rest = r#if(|c: &char| c.is_ascii_alphanumeric() || "+_@-".contains(*c)).list(0..);
 
     start
         .and(rest)
diff --git a/tests/depend.rs b/tests/depend.rs
index 1843570..085d739 100644
--- a/tests/depend.rs
+++ b/tests/depend.rs
@@ -12,6 +12,8 @@ fn parse_md5_cache() {
 
             for line in metadata.lines() {
                 if line.starts_with("DEPEND=") {
+                    eprintln!("{line}");
+                    eprintln!();
                     depend::parsers::exprs()
                         .ignore()
                         .or(eof())