diff --git a/build.mill b/build.mill
index e554c0d..0711a79 100644
--- a/build.mill
+++ b/build.mill
@@ -1,4 +1,5 @@
-//| mill-version: 1.0.0
+//| mill-version: 1.0.6
+//| mill-jvm-version: 11
 //| mvnDeps:
 //| - com.github.lolgab::mill-mima_mill1:0.2.0
 
@@ -30,7 +31,7 @@ trait MainArgsPublishModule
 
   def publishVersion = VcsVersion.vcsState().format()
 
-  override def mimaPreviousVersions = Seq("0.6.0")
+  override def mimaPreviousVersions = Seq("0.7.0", "0.7.1", "0.7.2", "0.7.3", "0.7.4", "0.7.5", "0.7.6")
 
   def mimaReportBinaryIssues() =
     if (this.isInstanceOf[ScalaNativeModule] || this.isInstanceOf[ScalaJSModule]) Task.Command{}
diff --git a/example/caseclass/src/Main.scala b/example/caseclass/src/Main.scala
index 292c33e..35d53a1 100644
--- a/example/caseclass/src/Main.scala
+++ b/example/caseclass/src/Main.scala
@@ -12,7 +12,7 @@ object Main {
       bool: Flag = Flag()
   )
   def main(args: Array[String]): Unit = {
-    val config = ParserForClass[Config].constructOrExit(args)
+    val config = Parser[Config].constructOrExit(args)
     println(config)
   }
 }
diff --git a/example/classarg/src/Main.scala b/example/classarg/src/Main.scala
index 9b3604c..36484a5 100644
--- a/example/classarg/src/Main.scala
+++ b/example/classarg/src/Main.scala
@@ -1,5 +1,5 @@
 package example.classarg
-import mainargs.{main, arg, ParserForMethods, ParserForClass, Flag}
+import mainargs.{main, arg, Parser, ParserForClass, Flag}
 
 object Main {
   @main
@@ -11,7 +11,7 @@ object Main {
       @arg(doc = "Example flag")
       bool: Flag = Flag()
   )
-  implicit def configParser = ParserForClass[Config]
+  implicit def configParser = Parser[Config]
 
   @main
   def bar(
@@ -26,5 +26,5 @@ object Main {
     println((config.foo * config.myNum + " " + config.bool.value + "\n") * n)
   }
 
-  def main(args: Array[String]): Unit = ParserForMethods(this).runOrExit(args)
+  def main(args: Array[String]): Unit = Parser(this).runOrExit(args)
 }
diff --git a/example/custom/src/Main.scala b/example/custom/src/Main.scala
index 6679553..408adc6 100644
--- a/example/custom/src/Main.scala
+++ b/example/custom/src/Main.scala
@@ -1,5 +1,5 @@
 package example.custom
-import mainargs.{main, arg, ParserForMethods, TokensReader}
+import mainargs.{main, arg, Parser, TokensReader}
 
 object Main {
   implicit object PathRead extends TokensReader[os.Path](
@@ -12,5 +12,5 @@ object Main {
     println("to:   " + to)
   }
 
-  def main(args: Array[String]): Unit = ParserForMethods(this).runOrExit(args)
+  def main(args: Array[String]): Unit = Parser(this).runOrExit(args)
 }
diff --git a/example/hello/src/Main.scala b/example/hello/src/Main.scala
index 1e548f6..961556c 100644
--- a/example/hello/src/Main.scala
+++ b/example/hello/src/Main.scala
@@ -1,5 +1,5 @@
 package example.hello
-import mainargs.{main, arg, ParserForMethods, Flag}
+import mainargs.{main, arg, Parser, Flag}
 
 object Main {
   @main
@@ -14,5 +14,5 @@ object Main {
     println(foo * myNum + " " + bool.value)
   }
 
-  def main(args: Array[String]): Unit = ParserForMethods(this).runOrExit(args)
+  def main(args: Array[String]): Unit = Parser(this).runOrExit(args)
 }
diff --git a/example/hello2/src/Main.scala b/example/hello2/src/Main.scala
index afff824..08867f8 100644
--- a/example/hello2/src/Main.scala
+++ b/example/hello2/src/Main.scala
@@ -1,5 +1,5 @@
 package example.hello2
-import mainargs.{main, arg, ParserForMethods, Flag}
+import mainargs.{main, arg, Parser, Flag}
 
 object Main {
   @main
@@ -21,5 +21,5 @@ object Main {
   ) = {
     println(s * i)
   }
-  def main(args: Array[String]): Unit = ParserForMethods(this).runOrExit(args)
+  def main(args: Array[String]): Unit = Parser(this).runOrExit(args)
 }
diff --git a/example/optseq/src/Main.scala b/example/optseq/src/Main.scala
index 1afd4df..d6e775b 100644
--- a/example/optseq/src/Main.scala
+++ b/example/optseq/src/Main.scala
@@ -1,5 +1,5 @@
 package example.optseq
-import mainargs.{main, arg, ParserForMethods, TokensReader}
+import mainargs.{main, arg, Parser, TokensReader}
 
 object Main {
   @main
@@ -11,5 +11,5 @@ object Main {
   @main
   def runVec(seq: Vector[Int]) = println(seq)
 
-  def main(args: Array[String]): Unit = ParserForMethods(this).runOrExit(args)
+  def main(args: Array[String]): Unit = Parser(this).runOrExit(args)
 }
diff --git a/example/short/src/Main.scala b/example/short/src/Main.scala
index 191174f..ade7f17 100644
--- a/example/short/src/Main.scala
+++ b/example/short/src/Main.scala
@@ -1,5 +1,5 @@
 package example.hello
-import mainargs.{main, arg, ParserForMethods, Flag}
+import mainargs.{main, arg, Parser, Flag}
 
 object Main {
   @main
@@ -8,5 +8,5 @@ object Main {
   @main
   def strs(a: Flag, b: String) = println(Seq(a.value, b))
 
-  def main(args: Array[String]): Unit = ParserForMethods(this).runOrExit(args)
+  def main(args: Array[String]): Unit = Parser(this).runOrExit(args)
 }
diff --git a/example/vararg/src/Main.scala b/example/vararg/src/Main.scala
index 3d5d6d4..f5f2aa5 100644
--- a/example/vararg/src/Main.scala
+++ b/example/vararg/src/Main.scala
@@ -1,5 +1,5 @@
 package example.vararg
-import mainargs.{main, arg, ParserForMethods, Leftover}
+import mainargs.{main, arg, Parser, Leftover}
 
 object Main {
   @main
@@ -7,5 +7,5 @@ object Main {
     println(foo * myNum + " " + rest.value)
   }
 
-  def main(args: Array[String]): Unit = ParserForMethods(this).runOrExit(args)
+  def main(args: Array[String]): Unit = Parser(this).runOrExit(args)
 }
diff --git a/example/vararg2/src/Main.scala b/example/vararg2/src/Main.scala
index 821e78c..b0879b9 100644
--- a/example/vararg2/src/Main.scala
+++ b/example/vararg2/src/Main.scala
@@ -6,7 +6,7 @@ object Main {
   case class Config(foo: String, myNum: Int = 2, rest: Leftover[String])
 
   def main(args: Array[String]): Unit = {
-    val config = ParserForClass[Config].constructOrExit(args)
+    val config = Parser[Config].constructOrExit(args)
     println(config)
   }
 }
diff --git a/example/varargold/src/Main.scala b/example/varargold/src/Main.scala
index 8744961..7b00be3 100644
--- a/example/varargold/src/Main.scala
+++ b/example/varargold/src/Main.scala
@@ -1,5 +1,5 @@
 package example.vararg
-import mainargs.{main, arg, ParserForMethods, Leftover}
+import mainargs.{main, arg, Parser, Leftover}
 
 object Main {
   @main
@@ -7,5 +7,5 @@ object Main {
     println(foo * myNum + " " + rest.value)
   }
 
-  def main(args: Array[String]): Unit = ParserForMethods(this).runOrExit(args)
+  def main(args: Array[String]): Unit = Parser(this).runOrExit(args)
 }
diff --git a/mainargs/src/Parser.scala b/mainargs/src/Parser.scala
index ef92420..1f5c506 100644
--- a/mainargs/src/Parser.scala
+++ b/mainargs/src/Parser.scala
@@ -5,6 +5,7 @@ import acyclic.skipped
 import scala.language.experimental.macros
 import java.io.PrintStream
 
+object Parser extends ParserForMethodsCompanionVersionSpecific with ParserForClassCompanionVersionSpecific
 object ParserForMethods extends ParserForMethodsCompanionVersionSpecific
 class ParserForMethods[B](val mains: MethodMains[B]) {
   @deprecated("Binary Compatibility Shim", "mainargs 0.6.0")
diff --git a/mainargs/test/src-jvm-2/AmmoniteTests.scala b/mainargs/test/src-jvm-2/AmmoniteTests.scala
index c9ea6db..5053a05 100644
--- a/mainargs/test/src-jvm-2/AmmoniteTests.scala
+++ b/mainargs/test/src-jvm-2/AmmoniteTests.scala
@@ -90,7 +90,7 @@ object AmmoniteConfig {
       @arg(doc = "Print this message")
       help: Flag
   )
-  implicit val coreParser = ParserForClass[Core]
+  implicit val coreParser = Parser[Core]
 
   @main
   case class Predef(
@@ -108,7 +108,7 @@ object AmmoniteConfig {
       )
       noHomePredef: Flag
   )
-  implicit val predefParser = ParserForClass[Predef]
+  implicit val predefParser = Parser[Predef]
 
   @main
   case class Repl(
@@ -130,11 +130,11 @@ object AmmoniteConfig {
       )
       classBased: Flag
   )
-  implicit val replParser = ParserForClass[Repl]
+  implicit val replParser = Parser[Repl]
 }
 
 object AmmoniteTests extends TestSuite {
-  val parser = ParserForClass[AmmoniteConfig]
+  val parser = Parser[AmmoniteConfig]
   val tests = Tests {
 
     test("formatMainMethods.unsorted") {
diff --git a/mainargs/test/src-jvm-2/MillTests.scala b/mainargs/test/src-jvm-2/MillTests.scala
index c849fe9..7896d0d 100644
--- a/mainargs/test/src-jvm-2/MillTests.scala
+++ b/mainargs/test/src-jvm-2/MillTests.scala
@@ -88,7 +88,7 @@ object MillTests extends TestSuite {
 
   val tests = Tests {
 
-    val parser = ParserForClass[Config]
+    val parser = Parser[Config]
 
     test("formatMainMethods") {
       val rendered = parser.helpText(sorted = false)
diff --git a/mainargs/test/src/ClassTests.scala b/mainargs/test/src/ClassTests.scala
index 3b0c8ad..d48fc65 100644
--- a/mainargs/test/src/ClassTests.scala
+++ b/mainargs/test/src/ClassTests.scala
@@ -43,11 +43,11 @@ object ClassTests extends TestSuite {
     ) = new Compat(home, silent, leftoverArgs)
   }
 
-  implicit val fooParser: ParserForClass[Foo] = ParserForClass[Foo]
-  implicit val barParser: ParserForClass[Bar] = ParserForClass[Bar]
-  implicit val quxParser: ParserForClass[Qux] = ParserForClass[Qux]
-  implicit val cliParser: ParserForClass[Cli] = ParserForClass[Cli]
-  implicit val compatParser: ParserForClass[Compat] = ParserForClass[Compat]
+  implicit val fooParser: ParserForClass[Foo] = Parser[Foo]
+  implicit val barParser: ParserForClass[Bar] = Parser[Bar]
+  implicit val quxParser: ParserForClass[Qux] = Parser[Qux]
+  implicit val cliParser: ParserForClass[Cli] = Parser[Cli]
+  implicit val compatParser: ParserForClass[Compat] = Parser[Compat]
 
   class PathWrap {
     @main
@@ -60,7 +60,7 @@ object ClassTests extends TestSuite {
       }
     }
 
-    implicit val fooParser: ParserForClass[Foo] = ParserForClass[Foo]
+    implicit val fooParser: ParserForClass[Foo] = Parser[Foo]
   }
 
   object Main {
@@ -204,7 +204,7 @@ object ClassTests extends TestSuite {
         Qux("cow", Bar(Flag(true), Foo(1, 2), "xxx"))
     }
     test("success") {
-      ParserForMethods(Main).runOrThrow(
+      Parser(Main).runOrThrow(
         Seq("-x", "1", "-y", "2", "-z", "hello")
       ) ==> "false 1 2 hello false"
     }
@@ -225,7 +225,7 @@ object ClassTests extends TestSuite {
       }
       test("path-dependent-default-method") {
         val p = new PathWrap
-        ParserForMethods(p.Main).runOrThrow(
+        Parser(p.Main).runOrThrow(
           Seq("-x", "1", "-y", "2", "-z", "hello")
         ) ==> "false 1 2 hello false"
       }
diff --git a/mainargs/test/src/ClassWithDefaultTests.scala b/mainargs/test/src/ClassWithDefaultTests.scala
index b259159..8175f1a 100644
--- a/mainargs/test/src/ClassWithDefaultTests.scala
+++ b/mainargs/test/src/ClassWithDefaultTests.scala
@@ -6,14 +6,14 @@ object ClassWithDefaultTests extends TestSuite {
   @main
   case class Foo(x: Int, y: Int = 1)
 
-  implicit val fooParser: ParserForClass[Foo] = ParserForClass[Foo]
+  implicit val fooParser: ParserForClass[Foo] = Parser[Foo]
 
   object Main {
     @main
     def run(foo: Foo, bool: Boolean = false) = s"${foo.x} ${foo.y} $bool"
   }
 
-  val mainParser = ParserForMethods(Main)
+  val mainParser = Parser(Main)
 
   val tests = Tests {
     test("simple") {
diff --git a/mainargs/test/src/ConstantTests.scala b/mainargs/test/src/ConstantTests.scala
index d5e9d0e..5cd57a9 100644
--- a/mainargs/test/src/ConstantTests.scala
+++ b/mainargs/test/src/ConstantTests.scala
@@ -12,7 +12,7 @@ object ConstantTests extends TestSuite {
     @main
     def flaggy(a: Injected, b: Boolean) = a.toString + " " + b
   }
-  val check = new Checker(ParserForMethods(Base), allowPositional = true)
+  val check = new Checker(Parser(Base), allowPositional = true)
 
   val tests = Tests {
     test - check(
diff --git a/mainargs/test/src/CoreTests.scala b/mainargs/test/src/CoreTests.scala
index 803e1f1..2216f90 100644
--- a/mainargs/test/src/CoreTests.scala
+++ b/mainargs/test/src/CoreTests.scala
@@ -258,7 +258,7 @@ object CorePositionalDisabledOnlyTests extends TestSuite {
 }
 
 object CorePositionalEnabledOnlyTests extends TestSuite {
-  val check = new Checker(ParserForMethods(CoreBase), allowPositional = true)
+  val check = new Checker(Parser(CoreBase), allowPositional = true)
 
   val tests = Tests {
     test("invoke") {
diff --git a/mainargs/test/src/DashedArgumentName.scala b/mainargs/test/src/DashedArgumentName.scala
index f21a812..d333c6c 100644
--- a/mainargs/test/src/DashedArgumentName.scala
+++ b/mainargs/test/src/DashedArgumentName.scala
@@ -16,8 +16,8 @@ object DashedArgumentName extends TestSuite {
     @main(name = "camelOptFor29NameForce")
     def camelOptFor29NameForce(@arg(name = "camelOptFor29ArgForce") camelOptFor29ArgForce: Boolean) = camelOptFor29ArgForce
   }
-  val check = new Checker(ParserForMethods(Base), allowPositional = true)
-  val snakeCaseCheck = new Checker(ParserForMethods(Base), allowPositional = true, nameMapper = Util.snakeCaseNameMapper)
+  val check = new Checker(Parser(Base), allowPositional = true)
+  val snakeCaseCheck = new Checker(Parser(Base), allowPositional = true, nameMapper = Util.snakeCaseNameMapper)
 
   val tests = Tests {
     test("backticked") {
diff --git a/mainargs/test/src/EqualsSyntaxTests.scala b/mainargs/test/src/EqualsSyntaxTests.scala
index 67311d2..268d658 100644
--- a/mainargs/test/src/EqualsSyntaxTests.scala
+++ b/mainargs/test/src/EqualsSyntaxTests.scala
@@ -19,27 +19,27 @@ object EqualsSyntaxTests extends TestSuite {
 
   val tests = Tests {
     test("simple") {
-      ParserForMethods(Main).runOrThrow(Array("--foo=bar", "--my-num=3")) ==>
+      Parser(Main).runOrThrow(Array("--foo=bar", "--my-num=3")) ==>
         "barbarbar false"
     }
     test("multipleEquals") {
       // --foo=bar syntax still works when there's an `=` on the right
-      ParserForMethods(Main).runOrThrow(Array("--foo=bar=qux")) ==>
+      Parser(Main).runOrThrow(Array("--foo=bar=qux")) ==>
         "bar=quxbar=qux false"
     }
     test("empty") {
       // --foo= syntax sets `foo` to an empty string
-      ParserForMethods(Main).runOrThrow(Array("--foo=")) ==>
+      Parser(Main).runOrThrow(Array("--foo=")) ==>
         " false"
     }
     test("shortName") {
       // -f=bar syntax does work for short names
-      ParserForMethods(Main).runEither(Array("-f=bar")) ==>
+      Parser(Main).runEither(Array("-f=bar")) ==>
         Right("barbar false")
     }
     test("notFlags") {
       // -f=bar syntax doesn't work for flags
-      ParserForMethods(Main).runEither(Array("--foo=bar", "--bool=true")) ==>
+      Parser(Main).runEither(Array("--foo=bar", "--bool=true")) ==>
          Left("""Unknown argument: "--bool=true"
                 |Expected Signature: run
                 |  --bool          Example flag
diff --git a/mainargs/test/src/FlagTests.scala b/mainargs/test/src/FlagTests.scala
index 459a2ce..e26894d 100644
--- a/mainargs/test/src/FlagTests.scala
+++ b/mainargs/test/src/FlagTests.scala
@@ -10,7 +10,7 @@ object FlagTests extends TestSuite {
     def str(a: Flag, b: String) = Seq(a.value, b)
   }
 
-  val check = new Checker(ParserForMethods(Base), allowPositional = true)
+  val check = new Checker(Parser(Base), allowPositional = true)
 
   val tests = Tests {
     test - check(
diff --git a/mainargs/test/src/HelloWorldTests.scala b/mainargs/test/src/HelloWorldTests.scala
index 7f3c5d4..2a30763 100644
--- a/mainargs/test/src/HelloWorldTests.scala
+++ b/mainargs/test/src/HelloWorldTests.scala
@@ -19,27 +19,27 @@ object HelloWorldTests extends TestSuite {
 
   val tests = Tests {
     test("explicit") {
-      ParserForMethods(Main).runOrThrow(Array("--foo", "bar", "--my-num", "3")) ==>
+      Parser(Main).runOrThrow(Array("--foo", "bar", "--my-num", "3")) ==>
         "barbarbar false"
     }
     test("short") {
-      ParserForMethods(Main).runOrThrow(Array("-f", "bar")) ==>
+      Parser(Main).runOrThrow(Array("-f", "bar")) ==>
         "barbar false"
     }
     test("default") {
-      ParserForMethods(Main).runOrThrow(Array("--foo", "bar")) ==>
+      Parser(Main).runOrThrow(Array("--foo", "bar")) ==>
         "barbar false"
     }
     test("positional") {
-      ParserForMethods(Main).runOrThrow(Array("qux", "4"), allowPositional = true) ==>
+      Parser(Main).runOrThrow(Array("qux", "4"), allowPositional = true) ==>
         "quxquxquxqux false"
     }
     test("flags") {
-      ParserForMethods(Main).runOrThrow(Array("qux", "4", "--bool"), allowPositional = true) ==>
+      Parser(Main).runOrThrow(Array("qux", "4", "--bool"), allowPositional = true) ==>
         "quxquxquxqux true"
     }
     test("either") {
-      ParserForMethods(Main).runEither(Array("qux", "4", "--bool"), allowPositional = true) ==>
+      Parser(Main).runEither(Array("qux", "4", "--bool"), allowPositional = true) ==>
         Right("quxquxquxqux true")
     }
   }
diff --git a/mainargs/test/src/HygieneTests.scala b/mainargs/test/src/HygieneTests.scala
index 4f0d578..b5d0f49 100644
--- a/mainargs/test/src/HygieneTests.scala
+++ b/mainargs/test/src/HygieneTests.scala
@@ -20,7 +20,7 @@ object HygieneTests extends TestSuite {
   val tests = Tests {
     import scala.collection.mutable._
     test("importingSeqShouldntFailCompile") {
-      ParserForMethods(Main)
+      Parser(Main)
     }
 
   }
diff --git a/mainargs/test/src/InvocationArgs.scala b/mainargs/test/src/InvocationArgs.scala
index bcafec6..51d02bc 100644
--- a/mainargs/test/src/InvocationArgs.scala
+++ b/mainargs/test/src/InvocationArgs.scala
@@ -37,7 +37,7 @@ case class LargeArgs(
 )
 
 object LargeClassTests extends TestSuite{
-  val largeArgsParser = ParserForClass[LargeArgs]
+  val largeArgsParser = Parser[LargeArgs]
 
   val tests = Tests {
     test("simple") {
diff --git a/mainargs/test/src/IssueTests.scala b/mainargs/test/src/IssueTests.scala
index 2ec7b8d..5b3c906 100644
--- a/mainargs/test/src/IssueTests.scala
+++ b/mainargs/test/src/IssueTests.scala
@@ -15,13 +15,13 @@ object IssueTests extends TestSuite {
   val tests = Tests {
     test("issue60") {
       test {
-        val parsed = ParserForMethods(Main)
+        val parsed = Parser(Main)
           .runEither(Seq("--str", "str", "a", "b", "c", "d"), allowPositional = true)
 
         assert(parsed == Right((false, "str", List("a", "b", "c", "d"))))
       }
       test {
-        val parsed = ParserForMethods(Main)
+        val parsed = Parser(Main)
           .runEither(Seq("a", "b", "c", "d"), allowPositional = true)
 
         assert(parsed == Right((false, "a", List("b", "c", "d"))))
diff --git a/mainargs/test/src/ManyTests.scala b/mainargs/test/src/ManyTests.scala
index 3b20eec..7b84cec 100644
--- a/mainargs/test/src/ManyTests.scala
+++ b/mainargs/test/src/ManyTests.scala
@@ -20,7 +20,7 @@ object ManyTests extends TestSuite {
       n: BigDecimal
   )
 
-  val parser = ParserForClass[Config]
+  val parser = Parser[Config]
   val tests = Tests {
     test {
       parser.constructEither(
diff --git a/mainargs/test/src/MultiTraitTests.scala b/mainargs/test/src/MultiTraitTests.scala
index 03cfb69..e1cec82 100644
--- a/mainargs/test/src/MultiTraitTests.scala
+++ b/mainargs/test/src/MultiTraitTests.scala
@@ -17,7 +17,7 @@ object Joined extends CommandCopy with CommandList {
 }
 
 object MultiTraitTests extends TestSuite {
-  val check = new Checker(ParserForMethods(Joined), allowPositional = true)
+  val check = new Checker(Parser(Joined), allowPositional = true)
   val tests = Tests {
     test - check(List("copy", "fromArg", "toArg"), Result.Success(("fromArg", "toArg")))
     test - check(List("test", "fromArg", "toArg"), Result.Success(("fromArg", "toArg")))
diff --git a/mainargs/test/src/OptionSeqTests.scala b/mainargs/test/src/OptionSeqTests.scala
index d37b8d7..66e3b2d 100644
--- a/mainargs/test/src/OptionSeqTests.scala
+++ b/mainargs/test/src/OptionSeqTests.scala
@@ -22,42 +22,42 @@ object OptionSeqTests extends TestSuite {
   val tests = Tests {
     test("opt") {
       test {
-        ParserForMethods(Main).runOrThrow(Array("runOpt")) ==>
+        Parser(Main).runOrThrow(Array("runOpt")) ==>
           None
       }
       test {
-        ParserForMethods(Main).runOrThrow(Array("runOpt", "--opt", "123")) ==>
+        Parser(Main).runOrThrow(Array("runOpt", "--opt", "123")) ==>
           Some(123)
       }
     }
     test("seq") {
 
       test {
-        ParserForMethods(Main).runOrThrow(Array("runSeq")) ==>
+        Parser(Main).runOrThrow(Array("runSeq")) ==>
           Seq()
       }
       test {
-        ParserForMethods(Main).runOrThrow(Array("runSeq", "--seq", "123")) ==>
+        Parser(Main).runOrThrow(Array("runSeq", "--seq", "123")) ==>
           Seq(123)
       }
     }
     test("vec") {
-      ParserForMethods(Main).runOrThrow(Array("runVec", "--seq", "123", "--seq", "456")) ==>
+      Parser(Main).runOrThrow(Array("runVec", "--seq", "123", "--seq", "456")) ==>
         Vector(123, 456)
     }
 
     test("map") {
 
       test {
-        ParserForMethods(Main).runOrThrow(Array("runMap")) ==>
+        Parser(Main).runOrThrow(Array("runMap")) ==>
           Map()
       }
       test {
-        ParserForMethods(Main).runOrThrow(Array("runMap", "--map", "abc=123")) ==>
+        Parser(Main).runOrThrow(Array("runMap", "--map", "abc=123")) ==>
           Map("abc" -> "123")
       }
       test {
-        ParserForMethods(Main).runOrThrow(
+        Parser(Main).runOrThrow(
           Array("runMap", "--map", "abc=123", "--map", "def=456")
         ) ==>
           Map("abc" -> "123", "def" -> "456")
@@ -65,13 +65,13 @@ object OptionSeqTests extends TestSuite {
     }
     test("allowRepeats") {
       test("true") {
-        ParserForMethods(Main)
+        Parser(Main)
           .runOrThrow(Array("runInt", "--int", "123", "--int", "456"), allowRepeats = true) ==>
           456
       }
       test("false") {
         intercept[Exception] {
-          ParserForMethods(Main)
+          Parser(Main)
             .runOrThrow(Array("runInt", "--int", "123", "--int", "456"), allowRepeats = false)
         }
       }
diff --git a/mainargs/test/src/ParserTests.scala b/mainargs/test/src/ParserTests.scala
index b7e6ba2..1bd8197 100644
--- a/mainargs/test/src/ParserTests.scala
+++ b/mainargs/test/src/ParserTests.scala
@@ -23,9 +23,9 @@ object ParserTests extends TestSuite {
   @main
   case class ClassBase(code: Option[String] = None, other: String = "hello")
 
-  val multiMethodParser = ParserForMethods(MultiBase)
-  val singleMethodParser = ParserForMethods(SingleBase)
-  val classParser = ParserForClass[ClassBase]
+  val multiMethodParser = Parser(MultiBase)
+  val singleMethodParser = Parser(SingleBase)
+  val classParser = Parser[ClassBase]
   val tests = Tests {
     test("runEitherMulti") {
 
diff --git a/mainargs/test/src/PositionalTests.scala b/mainargs/test/src/PositionalTests.scala
index c68cf11..97e1b7f 100644
--- a/mainargs/test/src/PositionalTests.scala
+++ b/mainargs/test/src/PositionalTests.scala
@@ -7,7 +7,7 @@ object PositionalTests extends TestSuite {
     @main
     def positional(x: Boolean, @arg(positional = true) y: Boolean, z: Boolean) = (x, y, z)
   }
-  val check = new Checker(ParserForMethods(Base), allowPositional = false)
+  val check = new Checker(Parser(Base), allowPositional = false)
 
   val tests = Tests {
     test - check(
diff --git a/mainargs/test/src/VarargsCustomTests.scala b/mainargs/test/src/VarargsCustomTests.scala
index 0073874..bf7665b 100644
--- a/mainargs/test/src/VarargsCustomTests.scala
+++ b/mainargs/test/src/VarargsCustomTests.scala
@@ -38,6 +38,6 @@ object VarargsCustomTests extends VarargsBaseTests {
     }
   }
 
-  val check = new Checker(ParserForMethods(Base), allowPositional = true)
+  val check = new Checker(Parser(Base), allowPositional = true)
   val isNewVarargsTests = true
 }
diff --git a/mainargs/test/src/VarargsNewTests.scala b/mainargs/test/src/VarargsNewTests.scala
index a0e9081..e589c1a 100644
--- a/mainargs/test/src/VarargsNewTests.scala
+++ b/mainargs/test/src/VarargsNewTests.scala
@@ -18,6 +18,6 @@ object VarargsNewTests extends VarargsBaseTests {
     }
   }
 
-  val check = new Checker(ParserForMethods(Base), allowPositional = true)
+  val check = new Checker(Parser(Base), allowPositional = true)
   val isNewVarargsTests = true
 }
diff --git a/mainargs/test/src/VarargsOldTests.scala b/mainargs/test/src/VarargsOldTests.scala
index 6d482ec..b3a7cf0 100644
--- a/mainargs/test/src/VarargsOldTests.scala
+++ b/mainargs/test/src/VarargsOldTests.scala
@@ -12,6 +12,6 @@ object VarargsOldTests extends VarargsBaseTests {
       first.toString + args.mkString
   }
 
-  val check = new Checker(ParserForMethods(Base), allowPositional = true)
+  val check = new Checker(Parser(Base), allowPositional = true)
   val isNewVarargsTests = false
 }
diff --git a/mainargs/test/src/VarargsWrappedTests.scala b/mainargs/test/src/VarargsWrappedTests.scala
index 00d03bb..c7aa476 100644
--- a/mainargs/test/src/VarargsWrappedTests.scala
+++ b/mainargs/test/src/VarargsWrappedTests.scala
@@ -35,6 +35,6 @@ object VarargsWrappedTests extends VarargsBaseTests {
     }
   }
 
-  val check = new Checker(ParserForMethods(Base), allowPositional = true)
+  val check = new Checker(Parser(Base), allowPositional = true)
   val isNewVarargsTests = true
 }
diff --git a/readme.md b/readme.md
index 5afce2a..d6ff3f5 100644
--- a/readme.md
+++ b/readme.md
@@ -60,7 +60,7 @@ object Main{
           bool: Flag) = {
     println(foo * myNum + " " + bool.value)
   }
-  def main(args: Array[String]): Unit = ParserForMethods(this).runOrExit(args)
+  def main(args: Array[String]): Unit = Parser(this).runOrExit(args)
 }
 ```
 
@@ -99,7 +99,7 @@ Setting default values for the method arguments makes them optional, with the
 default value being used if an explicit value was not passed in from the
 command-line arguments list.
 
-After calling `ParserForMethods(...)` on the `object` containing your `@main`
+After calling `Parser(...)` on the `object` containing your `@main`
 methods, you can call the following methods to perform the argument parsing and
 dispatch:
 
@@ -132,7 +132,7 @@ with `@main`. Each entrypoint can have their own set of arguments:
 
 ```scala
 package testhello2
-import mainargs.{main, arg, ParserForMethods, Flag}
+import mainargs.{main, arg, Parser, Flag}
 
 object Main{
   @main
@@ -150,7 +150,7 @@ object Main{
           s: String  = "lols") = {
     println(s * i)
   }
-  def main(args: Array[String]): Unit = ParserForMethods(this).runOrExit(args)
+  def main(args: Array[String]): Unit = Parser(this).runOrExit(args)
 }
 ```
 
@@ -168,11 +168,11 @@ lolslolslolslolslolslolslolslolslolslols
 ## Parsing Case Class Parameters
 
 If you want to construct a configuration object instead of directly calling a
-method, you can do so via `ParserForClass[T]` and `constructOrExit:
+method, you can do so via `Parser[T]` and `constructOrExit:
 
 ```scala
 package testclass
-import mainargs.{main, arg, ParserForClass, Flag}
+import mainargs.{main, arg, Parser, Flag}
 
 object Main{
   @main
@@ -183,7 +183,7 @@ object Main{
                     @arg(doc = "Example flag")
                     bool: Flag)
   def main(args: Array[String]): Unit = {
-    val config = ParserForClass[Config].constructOrExit(args)
+    val config = Parser[Config].constructOrExit(args)
     println(config)
   }
 }
@@ -201,19 +201,19 @@ Expected Signature: apply
   --bool          Example flag
 ```
 
-`ParserForClass[T]` also provides corresponding `constructOrThrow`,
+`Parser[T]` also provides corresponding `constructOrThrow`,
 `constructEither`, or `constructRaw` methods for you to handle the error cases
 in whichever style you prefer.
 
 ## Re-using Argument Sets
 
 You can share arguments between different `@main` methods by defining them in a
-`@main case class` configuration object with an implicit `ParserForClass[T]`
+`@main case class` configuration object with an implicit `Parser[T]`
 defined:
 
 ```scala
 package testclassarg
-import mainargs.{main, arg, ParserForMethods, ParserForClass, Flag}
+import mainargs.{main, arg, Parser, Parser, Flag}
 
 object Main{
   @main
@@ -223,7 +223,7 @@ object Main{
                     myNum: Int = 2,
                     @arg(doc = "Example flag")
                     bool: Flag)
-  implicit def configParser = ParserForClass[Config]
+  implicit def configParser = Parser[Config]
 
   @main
   def bar(config: Config,
@@ -237,7 +237,7 @@ object Main{
     println((config.foo * config.myNum + " " + config.bool.value + "\n") * n)
   }
 
-  def main(args: Array[String]): Unit = ParserForMethods(this).runOrExit(args)
+  def main(args: Array[String]): Unit = Parser(this).runOrExit(args)
 }
 ```
 
@@ -265,7 +265,7 @@ optional parameters without defaults or repeatable parameters
 
 ```scala
 package testoptseq
-import mainargs.{main, arg, ParserForMethods}
+import mainargs.{main, arg, Parser}
 
 object Main{
   @main
@@ -277,7 +277,7 @@ object Main{
   @main
   def runVec(seq: Vector[Int]) = println(seq)
 
-  def main(args: Array[String]): Unit = ParserForMethods(this).runOrExit(args)
+  def main(args: Array[String]): Unit = Parser(this).runOrExit(args)
 }
 ```
 
@@ -423,7 +423,7 @@ customize your usage:
 ## Customization
 
 Apart from taking the name of the main `object` or config `case class`,
-`ParserForMethods` and `ParserForClass` both have methods that support a number
+`Parser` has methods that support a number
 of useful configuration values:
 
 - `allowPositional: Boolean`: allows you to pass CLI arguments "positionally"
@@ -468,7 +468,7 @@ you can do so by defining an implicit `TokensReader[T]` for that type:
 
 ```scala
 package testcustom
-import mainargs.{main, arg, ParserForMethods, TokensReader}
+import mainargs.{main, arg, Parser, TokensReader}
 
 object Main{
   implicit object PathRead extends TokensReader.Simple[os.Path]{
@@ -482,7 +482,7 @@ object Main{
     println("to:   " + to)
   }
 
-  def main(args: Array[String]): Unit = ParserForMethods(this).runOrExit(args)
+  def main(args: Array[String]): Unit = Parser(this).runOrExit(args)
 }
 ```
 
@@ -512,7 +512,7 @@ not consumed by other parsers:
 
 ```scala
 package testvararg
-import mainargs.{main, arg, ParserForMethods, Leftover}
+import mainargs.{main, arg, Parser, Leftover}
 
 object Main{
   @main
@@ -522,7 +522,7 @@ object Main{
     println(foo * myNum + " " + rest.value)
   }
 
-  def main(args: Array[String]): Unit = ParserForMethods(this).runOrExit(args)
+  def main(args: Array[String]): Unit = Parser(this).runOrExit(args)
 }
 ```
 
@@ -567,7 +567,7 @@ of the tokens passed to the CLI:
 
 ```scala
 package testvararg
-import mainargs.{main, arg, ParserForMethods, Leftover}
+import mainargs.{main, arg, Parser, Leftover}
 
 object Main{
   @main
@@ -577,7 +577,7 @@ object Main{
     println(foo * myNum + " " + rest.value)
   }
 
-  def main(args: Array[String]): Unit = ParserForMethods(this).runOrExit(args)
+  def main(args: Array[String]): Unit = Parser(this).runOrExit(args)
 }
 ```