diff --git a/src/Simulation/CsharpGeneration.Tests/Circuits/EntryPointTests.qs b/src/Simulation/CsharpGeneration.Tests/Circuits/EntryPointTests.qs
index 54efe03736d..4f12bc51f3a 100644
--- a/src/Simulation/CsharpGeneration.Tests/Circuits/EntryPointTests.qs
+++ b/src/Simulation/CsharpGeneration.Tests/Circuits/EntryPointTests.qs
@@ -106,6 +106,15 @@ namespace Microsoft.Quantum.CsharpGeneration.Testing.EntryPoint {
 
 // ---
 
+namespace Microsoft.Quantum.CsharpGeneration.Testing.EntryPoint {
+    @EntryPoint()
+    operation AcceptUnit(u : Unit) : Unit {
+        return u;
+    }
+}
+
+// ---
+
 namespace Microsoft.Quantum.CsharpGeneration.Testing.EntryPoint {
     @EntryPoint()
     operation AcceptStringArray(xs : String[]) : String[] {
@@ -117,8 +126,44 @@ namespace Microsoft.Quantum.CsharpGeneration.Testing.EntryPoint {
 
 namespace Microsoft.Quantum.CsharpGeneration.Testing.EntryPoint {
     @EntryPoint()
-    operation AcceptUnit(u : Unit) : Unit {
-        return u;
+    operation AcceptBigIntArray(bs : BigInt[]) : BigInt[] {
+        return bs;
+    }
+}
+
+// ---
+
+namespace Microsoft.Quantum.CsharpGeneration.Testing.EntryPoint {
+    @EntryPoint()
+    operation AcceptPauliArray(ps : Pauli[]) : Pauli[] {
+        return ps;
+    }
+}
+
+// ---
+
+namespace Microsoft.Quantum.CsharpGeneration.Testing.EntryPoint {
+    @EntryPoint()
+    operation AcceptRangeArray(rs : Range[]) : Range[] {
+        return rs;
+    }
+}
+
+// ---
+
+namespace Microsoft.Quantum.CsharpGeneration.Testing.EntryPoint {
+    @EntryPoint()
+    operation AcceptResultArray(rs : Result[]) : Result[] {
+        return rs;
+    }
+}
+
+// ---
+
+namespace Microsoft.Quantum.CsharpGeneration.Testing.EntryPoint {
+    @EntryPoint()
+    operation AcceptUnitArray(us : Unit[]) : Unit[] {
+        return us;
     }
 }
 
diff --git a/src/Simulation/CsharpGeneration.Tests/EntryPointTests.fs b/src/Simulation/CsharpGeneration.Tests/EntryPointTests.fs
index 038acd5d4f0..0e93aeb32e5 100644
--- a/src/Simulation/CsharpGeneration.Tests/EntryPointTests.fs
+++ b/src/Simulation/CsharpGeneration.Tests/EntryPointTests.fs
@@ -224,6 +224,10 @@ let ``Accepts Pauli`` () =
     given ["-p"; "PauliX"] |> yields "PauliX"
     given ["-p"; "PauliY"] |> yields "PauliY"
     given ["-p"; "PauliZ"] |> yields "PauliZ"
+    given ["-p"; "paulii"] |> yields "PauliI"
+    given ["-p"; "paulix"] |> yields "PauliX"
+    given ["-p"; "pauliy"] |> yields "PauliY"
+    given ["-p"; "pauliz"] |> yields "PauliZ"
     given ["-p"; "PauliW"] |> fails
 
 [<Fact>]
@@ -266,31 +270,79 @@ let ``Accepts String`` () =
     given ["-s"; "Hello, World!"] |> yields "Hello, World!"
 
 [<Fact>]
-let ``Accepts String array`` () =
+let ``Accepts Unit`` () =
     let given = test 12
+    given ["-u"; "()"] |> yields ""
+    given ["-u"; "42"] |> fails
+
+[<Fact>]
+let ``Accepts String array`` () =
+    let given = test 13
     given ["--xs"; "foo"] |> yields "[foo]"
     given ["--xs"; "foo"; "bar"] |> yields "[foo,bar]"
     given ["--xs"; "foo bar"; "baz"] |> yields "[foo bar,baz]"
     given ["--xs"; "foo"; "bar"; "baz"] |> yields "[foo,bar,baz]"
+    given ["--xs"] |> fails
 
 [<Fact>]
-let ``Accepts Unit`` () =
+let ``Accepts BigInt array`` () =
+    let given = test 14
+    given ["--bs"; "9223372036854775808"] |> yields "[9223372036854775808]"
+    given ["--bs"; "1"; "2"; "9223372036854775808"] |> yields "[1,2,9223372036854775808]"
+    given ["--bs"; "1"; "2"; "4.2"] |> fails
+
+[<Fact>]
+let ``Accepts Pauli array`` () =
+    let given = test 15
+    given ["--ps"; "PauliI"] |> yields "[PauliI]"
+    given ["--ps"; "PauliZ"; "PauliX"] |> yields "[PauliZ,PauliX]"
+    given ["--ps"; "PauliY"; "PauliY"; "PauliY"] |> yields "[PauliY,PauliY,PauliY]"
+    given ["--ps"; "PauliY"; "PauliZ"; "PauliW"] |> fails
+
+[<Fact>]
+let ``Accepts Range array`` () =
+    let given = test 16
+    given ["--rs"; "1..10"] |> yields "[1..1..10]"
+    given ["--rs"; "1..10"; "2..4..20"] |> yields "[1..1..10,2..4..20]"
+    given ["--rs"; "1 ..10"; "2 ..4 ..20"] |> yields "[1..1..10,2..4..20]"
+    given ["--rs"; "1 .. 10"; "2 .. 4 .. 20"] |> yields "[1..1..10,2..4..20]"
+    given ["--rs"; "1 .. 1o"; "2 .. 4 .. 20"] |> fails
+
+[<Fact>]
+let ``Accepts Result array`` () =
+    let given = test 17
+    given ["--rs"; "One"] |> yields "[One]"
+    given ["--rs"; "One"; "Zero"] |> yields "[One,Zero]"
+    given ["--rs"; "Zero"; "One"; "Two"] |> fails
+
+[<Fact>]
+let ``Accepts Unit array`` () =
+    let given = test 18
+    given ["--us"; "()"] |> yields "[()]"
+    given ["--us"; "()"; "()"] |> yields "[(),()]"
+    given ["--us"; "()"; "()"; "()"] |> yields "[(),(),()]"
+    given ["--us"; "()"; "unit"; "()"] |> fails
+
+[<Fact>]
+let ``Supports repeat-name array syntax`` () =
     let given = test 13
-    given ["-u"; "()"] |> yields ""
-    given ["-u"; "42"] |> fails
+    given ["--xs"; "Hello"; "--xs"; "World"] |> yields "[Hello,World]"
+    given ["--xs"; "foo"; "bar"; "--xs"; "baz"] |> yields "[foo,bar,baz]"
+    given ["--xs"; "foo"; "--xs"; "bar"; "--xs"; "baz"] |> yields "[foo,bar,baz]"
+    given ["--xs"; "foo bar"; "--xs"; "baz"] |> yields "[foo bar,baz]"
 
 
 // Multiple Options
 
 [<Fact>]
 let ``Accepts two options`` () =
-    let given = test 14
+    let given = test 19
     given ["-n"; "7"; "-b"; "true"] |> yields "7 True"
     given ["-b"; "true"; "-n"; "7"] |> yields "7 True"
 
 [<Fact>]
 let ``Accepts three options`` () =
-    let given = test 15
+    let given = test 20
     given ["-n"; "7"; "-b"; "true"; "--xs"; "foo"] |> yields "7 True [foo]"
     given ["--xs"; "foo"; "-n"; "7"; "-b"; "true"] |> yields "7 True [foo]"
     given ["-n"; "7"; "--xs"; "foo"; "-b"; "true"] |> yields "7 True [foo]"
@@ -298,7 +350,7 @@ let ``Accepts three options`` () =
 
 [<Fact>]
 let ``Requires all options`` () =
-    let given = test 15
+    let given = test 20
     given ["-b"; "true"; "--xs"; "foo"] |> fails
     given ["-n"; "7"; "--xs"; "foo"] |> fails
     given ["-n"; "7"; "-b"; "true"] |> fails
@@ -312,13 +364,13 @@ let ``Requires all options`` () =
 
 [<Fact>]
 let ``Uses kebab-case`` () =
-    let given = test 16
+    let given = test 21
     given ["--camel-case-name"; "foo"] |> yields "foo"
     given ["--camelCaseName"; "foo"] |> fails
 
 [<Fact>]
 let ``Uses single-dash short names`` () =
-    let given = test 17
+    let given = test 22
     given ["-x"; "foo"] |> yields "foo"
     given ["--x"; "foo"] |> fails
 
@@ -327,7 +379,7 @@ let ``Uses single-dash short names`` () =
 
 [<Fact>]
 let ``Shadows --simulator`` () =
-    let given = test 18
+    let given = test 23
     given ["--simulator"; "foo"] |> yields "foo"
     given ["--simulator"; AssemblyConstants.ResourcesEstimator] |> yields AssemblyConstants.ResourcesEstimator
     given ["-s"; AssemblyConstants.ResourcesEstimator; "--simulator"; "foo"] |> fails 
@@ -335,14 +387,14 @@ let ``Shadows --simulator`` () =
 
 [<Fact>]
 let ``Shadows -s`` () =
-    let given = test 19
+    let given = test 24
     given ["-s"; "foo"] |> yields "foo"
     given ["--simulator"; AssemblyConstants.ToffoliSimulator; "-s"; "foo"] |> yields "foo"
     given ["--simulator"; "bar"; "-s"; "foo"] |> fails
 
 [<Fact>]
 let ``Shadows --version`` () =
-    let given = test 20
+    let given = test 25
     given ["--version"; "foo"] |> yields "foo"
 
 
@@ -361,30 +413,30 @@ BorrowedWidth   0"
 
 [<Fact>]
 let ``Supports QuantumSimulator`` () =
-    let given = test 21
+    let given = test 26
     given ["--simulator"; AssemblyConstants.QuantumSimulator; "--use-h"; "false"] |> yields "Hello, World!"
     given ["--simulator"; AssemblyConstants.QuantumSimulator; "--use-h"; "true"] |> yields "Hello, World!"
 
 [<Fact>]
 let ``Supports ToffoliSimulator`` () =
-    let given = test 21
+    let given = test 26
     given ["--simulator"; AssemblyConstants.ToffoliSimulator; "--use-h"; "false"] |> yields "Hello, World!"
     given ["--simulator"; AssemblyConstants.ToffoliSimulator; "--use-h"; "true"] |> fails
 
 [<Fact>]
 let ``Supports ResourcesEstimator`` () =
-    let given = test 21
+    let given = test 26
     given ["--simulator"; AssemblyConstants.ResourcesEstimator; "--use-h"; "false"] |> yields resourceSummary
     given ["--simulator"; AssemblyConstants.ResourcesEstimator; "--use-h"; "true"] |> yields resourceSummary
 
 [<Fact>]
 let ``Rejects unknown simulator`` () =
-    let given = test 21
+    let given = test 26
     given ["--simulator"; "FooSimulator"; "--use-h"; "false"] |> fails
 
 [<Fact>]
 let ``Supports default standard simulator`` () =
-    let given = testWith 21 AssemblyConstants.ResourcesEstimator
+    let given = testWith 26 AssemblyConstants.ResourcesEstimator
     given ["--use-h"; "false"] |> yields resourceSummary
     given ["--simulator"; AssemblyConstants.QuantumSimulator; "--use-h"; "false"] |> yields "Hello, World!"
 
@@ -392,7 +444,7 @@ let ``Supports default standard simulator`` () =
 let ``Supports default custom simulator`` () =
     // This is not really a "custom" simulator, but the driver does not recognize the fully-qualified name of the
     // standard simulators, so it is treated as one.
-    let given = testWith 21 typeof<ToffoliSimulator>.FullName
+    let given = testWith 26 typeof<ToffoliSimulator>.FullName
     given ["--use-h"; "false"] |> yields "Hello, World!"
     given ["--use-h"; "true"] |> fails
     given ["--simulator"; typeof<ToffoliSimulator>.FullName; "--use-h"; "false"] |> yields "Hello, World!"
@@ -425,7 +477,7 @@ Options:
 Commands:
   simulate    (default) Run the program using a local simulator."
 
-    let given = test 22
+    let given = test 27
     given ["--help"] |> yields message
     given ["-h"] |> yields message
     given ["-?"] |> yields message
diff --git a/src/Simulation/CsharpGeneration/EntryPoint.fs b/src/Simulation/CsharpGeneration/EntryPoint.fs
index 0d060066d23..7a2148ea449 100644
--- a/src/Simulation/CsharpGeneration/EntryPoint.fs
+++ b/src/Simulation/CsharpGeneration/EntryPoint.fs
@@ -1,4 +1,7 @@
-module Microsoft.Quantum.QsCompiler.CsharpGeneration.EntryPoint
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+module Microsoft.Quantum.QsCompiler.CsharpGeneration.EntryPoint
 
 open Microsoft.CodeAnalysis.CSharp
 open Microsoft.CodeAnalysis.CSharp.Syntax
@@ -45,36 +48,52 @@ let private constantsClass =
              constant "ResourcesEstimator" "string" (``literal`` AssemblyConstants.ResourcesEstimator)]
         ``}``
 
+/// The name of the C# type used by the parameter in its command-line option, given its Q# type.
+let rec private csharpParameterTypeName context (qsType : ResolvedType) =
+    match qsType.Resolution with
+    | ArrayType itemType -> sprintf "System.Collections.Generic.IEnumerable<%s>"
+                                    (csharpParameterTypeName context itemType)
+    | _ -> SimulationCode.roslynTypeName context qsType
+
 /// A sequence of all of the named parameters in the argument tuple and their respective C# and Q# types.
 let rec private parameters context doc = function
     | QsTupleItem variable ->
-        match variable.VariableName, variable.Type.Resolution with
-        | ValidName name, ArrayType itemType ->
-            // Command-line parsing libraries can't convert to IQArray. Use IEnumerable instead.
-            let typeName = sprintf "System.Collections.Generic.IEnumerable<%s>"
-                                   (SimulationCode.roslynTypeName context itemType)
-            Seq.singleton { Name = name.Value
-                            QsharpType = variable.Type
-                            CsharpTypeName = typeName
-                            Description = ParameterDescription doc name.Value }
-        | ValidName name, _ ->
+        match variable.VariableName with
+        | ValidName name ->
             Seq.singleton { Name = name.Value
                             QsharpType = variable.Type
-                            CsharpTypeName = SimulationCode.roslynTypeName context variable.Type
+                            CsharpTypeName = csharpParameterTypeName context variable.Type
                             Description = ParameterDescription doc name.Value }
-        | InvalidName, _ -> Seq.empty
+        | InvalidName -> Seq.empty
     | QsTuple items -> items |> Seq.map (parameters context doc) |> Seq.concat
 
-/// The custom argument handler for the given Q# type.
-let private argumentHandler =
-    // TODO: Support array types derived from types that need a custom argument handler.
-    function
-    | UnitType -> Some "UnitArgumentHandler"
-    | Result -> Some "ResultArgumentHandler"
-    | BigInt -> Some "BigIntArgumentHandler"
-    | Range -> Some "RangeArgumentHandler"
-    | _ -> None
-    >> Option.map (fun handler -> ``ident`` "Driver" <|.|> ``ident`` handler)
+/// The argument parser for the Q# type.
+let private argumentParser qsType =
+    let rec valueParser = function
+        | ArrayType (itemType : ResolvedType) -> valueParser itemType.Resolution
+        | BigInt -> Some "TryParseBigInteger"
+        | Range -> Some "TryParseQRange"
+        | Result -> Some "TryParseResult"
+        | UnitType -> Some "TryParseQVoid"
+        | _ -> None
+    let argParser =
+        match qsType with
+        | ArrayType _ -> "ParseArgumentsWith"
+        | _ -> "ParseArgumentWith"
+    valueParser qsType |> Option.map (fun valueParser ->
+        ``ident`` "Parsers" <.> (``ident`` argParser, [``ident`` "Parsers" <|.|> ``ident`` valueParser]))
+
+/// Adds suggestions, if any, to the option based on the Q# type.
+let private withSuggestions qsType option =
+    let rec suggestions = function
+        | ArrayType (itemType : ResolvedType) -> suggestions itemType.Resolution
+        | Result -> ["Zero"; "One"]
+        | _ -> []
+    match suggestions qsType with
+    | [] -> option
+    | suggestions ->
+        let args = option :: List.map ``literal`` suggestions
+        ``invoke`` (``ident`` "System.CommandLine.OptionExtensions.WithSuggestions") ``(`` args ``)``
 
 /// A property containing a sequence of command-line options corresponding to each parameter given.
 let private parameterOptionsProperty parameters =
@@ -86,16 +105,16 @@ let private parameterOptionsProperty parameters =
             if name.Length = 1
             then ``literal`` ("-" + name)
             else ``literal`` "--" <+> ``invoke`` toKebabCaseIdent ``(`` [``literal`` name] ``)``
-        let members =
-            argumentHandler qsType.Resolution
-            |> Option.map (fun handler -> ``ident`` "Argument" <-- handler :> ExpressionSyntax)
-            |> Option.toList
-            |> List.append [``ident`` "Required" <-- ``true``]
+        let args =
+            match argumentParser qsType.Resolution with
+            | Some parser -> [nameExpr; parser; upcast ``false``; ``literal`` desc]
+            | None -> [nameExpr; ``literal`` desc]
 
-        ``new init`` (``type`` [sprintf "%s<%s>" optionTypeName typeName]) ``(`` [nameExpr; ``literal`` desc] ``)``
+        ``new init`` (``type`` [sprintf "%s<%s>" optionTypeName typeName]) ``(`` args ``)``
             ``{``
-                members
+                [``ident`` "Required" <-- ``true``]
             ``}``
+        |> withSuggestions qsType.Resolution
 
     let options = parameters |> Seq.map getOption |> Seq.toList
     ``property-arrow_get`` optionsEnumerableTypeName "Options" [``public``; ``static``]
@@ -116,11 +135,10 @@ let private runMethod context (entryPoint : QsCallable) =
     let taskTypeName = sprintf "System.Threading.Tasks.Task<%s>" returnTypeName
     let factoryParamName = "__factory__"
 
-    let getArgExpr { Name = name; QsharpType = qsType } =
+    let argExpr { Name = name; QsharpType = qsType } =
         let property = ``ident`` "this" <|.|> ``ident`` (parameterPropertyName name)
         match qsType.Resolution with
         | ArrayType itemType ->
-            // Convert the IEnumerable property into a QArray.
             let arrayTypeName = sprintf "QArray<%s>" (SimulationCode.roslynTypeName context itemType)
             ``new`` (``type`` arrayTypeName) ``(`` [property] ``)``
         | _ -> property
@@ -128,7 +146,7 @@ let private runMethod context (entryPoint : QsCallable) =
     let callArgs : seq<ExpressionSyntax> =
         Seq.concat [
             Seq.singleton (upcast ``ident`` factoryParamName)
-            Seq.map getArgExpr (parameters context entryPoint.Documentation entryPoint.ArgumentTuple)
+            Seq.map argExpr (parameters context entryPoint.Documentation entryPoint.ArgumentTuple)
         ]
 
     ``arrow_method`` taskTypeName "Run" ``<<`` [] ``>>``
@@ -197,10 +215,12 @@ let private generatedClasses context (entryPoint : QsCallable) =
 
 /// The source code for the entry point driver.
 let private driver (entryPoint : QsCallable) =
-    let name = "Microsoft.Quantum.CsharpGeneration.Resources.EntryPointDriver.cs"
-    use stream = Assembly.GetExecutingAssembly().GetManifestResourceStream name
-    use reader = new StreamReader(stream)
-    reader.ReadToEnd().Replace("@Namespace", generatedNamespace entryPoint.FullName.Namespace.Value)
+    let source fileName =
+        let resourceName = "Microsoft.Quantum.CsharpGeneration.Resources.EntryPoint." + fileName
+        use stream = Assembly.GetExecutingAssembly().GetManifestResourceStream resourceName
+        use reader = new StreamReader(stream)
+        reader.ReadToEnd().Replace("@Namespace", generatedNamespace entryPoint.FullName.Namespace.Value)
+    String.Join (Environment.NewLine, source "Driver.cs", source "Parsers.cs", source "Validation.cs")
 
 /// Generates C# source code for a standalone executable that runs the Q# entry point.
 let generate context entryPoint =
diff --git a/src/Simulation/CsharpGeneration/Microsoft.Quantum.CsharpGeneration.fsproj b/src/Simulation/CsharpGeneration/Microsoft.Quantum.CsharpGeneration.fsproj
index 88c0c4e8082..0a279b90245 100644
--- a/src/Simulation/CsharpGeneration/Microsoft.Quantum.CsharpGeneration.fsproj
+++ b/src/Simulation/CsharpGeneration/Microsoft.Quantum.CsharpGeneration.fsproj
@@ -8,7 +8,9 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <EmbeddedResource Include="Resources\EntryPointDriver.cs" />
+    <EmbeddedResource Include="Resources\EntryPoint\Driver.cs" />
+    <EmbeddedResource Include="Resources\EntryPoint\Parsers.cs" />
+    <EmbeddedResource Include="Resources\EntryPoint\Validation.cs" />
     <Compile Include="..\Common\DelaySign.fs" Link="DelaySign.fs" />
     <Compile Include="Context.fs" />
     <Compile Include="SimulationCode.fs" />
@@ -28,5 +30,5 @@
   <ItemGroup>
     <ProjectReference Include="..\RoslynWrapper\Microsoft.Quantum.RoslynWrapper.fsproj" />
   </ItemGroup>
-  
+
 </Project>
diff --git a/src/Simulation/CsharpGeneration/Resources/EntryPoint/Driver.cs b/src/Simulation/CsharpGeneration/Resources/EntryPoint/Driver.cs
new file mode 100644
index 00000000000..d461e0f133e
--- /dev/null
+++ b/src/Simulation/CsharpGeneration/Resources/EntryPoint/Driver.cs
@@ -0,0 +1,209 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+namespace @Namespace
+{
+    using Microsoft.Quantum.Simulation.Core;
+    using Microsoft.Quantum.Simulation.Simulators;
+    using System;
+    using System.Collections.Generic;
+    using System.Collections.Immutable;
+    using System.CommandLine;
+    using System.CommandLine.Builder;
+    using System.CommandLine.Help;
+    using System.CommandLine.Invocation;
+    using System.CommandLine.Parsing;
+    using System.Linq;
+    using System.Threading.Tasks;
+
+    /// <summary>
+    /// The entry point driver is the entry point for the C# application that executes the Q# entry point.
+    /// </summary>
+    internal static class Driver
+    {
+        /// <summary>
+        /// A modification of the command line <see cref="HelpBuilder"/> class.
+        /// </summary>
+        private sealed class QsHelpBuilder : HelpBuilder
+        {
+            public QsHelpBuilder(IConsole console) : base(console) { }
+
+            protected override string ArgumentDescriptor(IArgument argument)
+            {
+                // Hide long argument descriptors.
+                var descriptor = base.ArgumentDescriptor(argument);
+                return descriptor.Length > 30 ? argument.Name : descriptor;
+            }
+        }
+
+        /// <summary>
+        /// Runs the entry point.
+        /// </summary>
+        /// <param name="args">The command-line arguments.</param>
+        /// <returns>The exit code.</returns>
+        private static async Task<int> Main(string[] args)
+        {
+            var simulate = new Command("simulate", "(default) Run the program using a local simulator.");
+            TryCreateOption(
+                Constants.SimulatorOptions,
+                () => EntryPoint.DefaultSimulator,
+                "The name of the simulator to use.").Then(option =>
+                {
+                    option.Argument.AddSuggestions(ImmutableHashSet<string>.Empty
+                        .Add(Constants.QuantumSimulator)
+                        .Add(Constants.ToffoliSimulator)
+                        .Add(Constants.ResourcesEstimator)
+                        .Add(EntryPoint.DefaultSimulator));
+                    simulate.AddOption(option);
+                });
+            simulate.Handler = CommandHandler.Create<EntryPoint, string>(Simulate);
+
+            var root = new RootCommand(EntryPoint.Summary) { simulate };
+            foreach (var option in EntryPoint.Options) { root.AddGlobalOption(option); }
+
+            // Set the simulate command as the default.
+            foreach (var option in simulate.Options) { root.AddOption(option); }
+            root.Handler = simulate.Handler;
+
+            return await new CommandLineBuilder(root)
+                .UseDefaults()
+                .UseHelpBuilder(context => new QsHelpBuilder(context.Console))
+                .Build()
+                .InvokeAsync(args);
+        }
+
+        /// <summary>
+        /// Simulates the entry point.
+        /// </summary>
+        /// <param name="entryPoint">The entry point.</param>
+        /// <param name="simulator">The simulator to use.</param>
+        /// <returns>The exit code.</returns>
+        private static async Task<int> Simulate(EntryPoint entryPoint, string simulator)
+        {
+            simulator = DefaultIfShadowed(Constants.SimulatorOptions.First(), simulator, EntryPoint.DefaultSimulator);
+            switch (simulator)
+            {
+                case Constants.ResourcesEstimator:
+                    var resourcesEstimator = new ResourcesEstimator();
+                    await entryPoint.Run(resourcesEstimator);
+                    Console.WriteLine(resourcesEstimator.ToTSV());
+                    break;
+                default:
+                    var (isCustom, createSimulator) = simulator switch
+                    {
+                        Constants.QuantumSimulator =>
+                            (false, new Func<IOperationFactory>(() => new QuantumSimulator())),
+                        Constants.ToffoliSimulator =>
+                            (false, new Func<IOperationFactory>(() => new ToffoliSimulator())),
+                        _ => (true, EntryPoint.CreateDefaultCustomSimulator)
+                    };
+                    if (isCustom && simulator != EntryPoint.DefaultSimulator)
+                    {
+                        DisplayCustomSimulatorError(simulator);
+                        return 1;
+                    }
+                    await DisplayEntryPointResult(entryPoint, createSimulator);
+                    break;
+            }
+            return 0;
+        }
+
+        /// <summary>
+        /// Runs the entry point on a simulator and displays its return value.
+        /// </summary>
+        /// <param name="entryPoint">The entry point.</param>
+        /// <param name="createSimulator">A function that creates an instance of the simulator to use.</param>
+        private static async Task DisplayEntryPointResult(
+            EntryPoint entryPoint, Func<IOperationFactory> createSimulator)
+        {
+            var simulator = createSimulator();
+            try
+            {
+                var value = await entryPoint.Run(simulator);
+#pragma warning disable CS0184
+                if (!(value is QVoid))
+#pragma warning restore CS0184
+                {
+                    Console.WriteLine(value);
+                }
+            }
+            finally
+            {
+                if (simulator is IDisposable disposable)
+                {
+                    disposable.Dispose();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Returns true if the alias is available for use by the driver (that is, the alias is not already used by an
+        /// entry point option).
+        /// </summary>
+        /// <param name="alias">The alias to check.</param>
+        /// <returns>True if the alias is available for use by the driver.</returns>
+        private static bool IsAliasAvailable(string alias) =>
+            !EntryPoint.Options.SelectMany(option => option.RawAliases).Contains(alias);
+
+        /// <summary>
+        /// Returns the default value and displays a warning if the alias is shadowed by an entry point option, and
+        /// returns the original value otherwise.
+        /// </summary>
+        /// <typeparam name="T">The type of the values.</typeparam>
+        /// <param name="alias">The primary option alias corresponding to the value.</param>
+        /// <param name="value">The value of the option given on the command line.</param>
+        /// <param name="defaultValue">The default value for the option.</param>
+        /// <returns></returns>
+        private static T DefaultIfShadowed<T>(string alias, T value, T defaultValue)
+        {
+            if (IsAliasAvailable(alias))
+            {
+                return value;
+            }
+            else
+            {
+                var originalForeground = Console.ForegroundColor;
+                Console.ForegroundColor = ConsoleColor.Yellow;
+                Console.Error.WriteLine($"Warning: Option {alias} is overriden by an entry point parameter name.");
+                Console.Error.WriteLine($"         Using default value {defaultValue}.");
+                Console.ForegroundColor = originalForeground;
+                return defaultValue;
+            }
+        }
+
+        /// <summary>
+        /// Tries to create an option by removing aliases that are already in use by the entry point. If the first
+        /// alias, which is considered the primary alias, is in use, then the option is not created.
+        /// </summary>
+        /// <typeparam name="T">The type of the option's argument.</typeparam>
+        /// <param name="aliases">The option's aliases.</param>
+        /// <param name="getDefaultValue">A function that returns the option's default value.</param>
+        /// <param name="description">The option's description.</param>
+        /// <returns>A validation of the option.</returns>
+        private static Validation<Option<T>> TryCreateOption<T>(
+                IEnumerable<string> aliases, Func<T> getDefaultValue, string description = null) =>
+            IsAliasAvailable(aliases.First())
+            ? Validation<Option<T>>.Success(
+                new Option<T>(aliases.Where(IsAliasAvailable).ToArray(), getDefaultValue, description))
+            : Validation<Option<T>>.Failure();
+
+        /// <summary>
+        /// Displays an error message for using a non-default custom simulator.
+        /// </summary>
+        /// <param name="name">The name of the custom simulator.</param>
+        private static void DisplayCustomSimulatorError(string name)
+        {
+            var originalForeground = Console.ForegroundColor;
+            Console.ForegroundColor = ConsoleColor.Red;
+            Console.Error.WriteLine($"The simulator '{name}' could not be found.");
+            Console.ForegroundColor = originalForeground;
+            Console.Error.WriteLine();
+            Console.Error.WriteLine(
+                $"If '{name}' is a custom simulator, it must be set in the DefaultSimulator project property:");
+            Console.Error.WriteLine();
+            Console.Error.WriteLine("<PropertyGroup>");
+            Console.Error.WriteLine($"  <DefaultSimulator>{name}</DefaultSimulator>");
+            Console.Error.WriteLine("</PropertyGroup>");
+        }
+    }
+}
diff --git a/src/Simulation/CsharpGeneration/Resources/EntryPoint/Parsers.cs b/src/Simulation/CsharpGeneration/Resources/EntryPoint/Parsers.cs
new file mode 100644
index 00000000000..fa34503db66
--- /dev/null
+++ b/src/Simulation/CsharpGeneration/Resources/EntryPoint/Parsers.cs
@@ -0,0 +1,125 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+namespace @Namespace
+{
+    using Microsoft.Quantum.Simulation.Core;
+    using System;
+    using System.Collections.Generic;
+    using System.CommandLine.Parsing;
+    using System.Linq;
+    using System.Numerics;
+
+    /// <summary>
+    /// A delegate that parses the value and returns a validation.
+    /// </summary>
+    /// <typeparam name="T">The type parsed value.</typeparam>
+    /// <param name="value">The string to parse.</param>
+    /// <param name="optionName">The name of the option that the value was used with.</param>
+    /// <returns>A validation of the parsed value.</returns>
+    internal delegate Validation<T> TryParseValue<T>(string value, string optionName = null);
+
+    /// <summary>
+    /// Parsers for command-line arguments.
+    /// </summary>
+    internal static class Parsers
+    {
+        /// <summary>
+        /// Creates an argument parser for a many-valued argument using a parser that operates on each string value.
+        /// </summary>
+        /// <typeparam name="T">The type of the parsed value.</typeparam>
+        /// <param name="parse">The string parser.</param>
+        /// <returns>The argument parser.</returns>
+        internal static ParseArgument<IEnumerable<T>> ParseArgumentsWith<T>(TryParseValue<T> parse) => argument =>
+        {
+            var optionName = ((OptionResult)argument.Parent).Token.Value;
+            var validation = argument.Tokens.Select(token => parse(token.Value, optionName)).Sequence();
+            if (validation.IsFailure)
+            {
+                argument.ErrorMessage = validation.ErrorMessage;
+            }
+            return validation.ValueOrDefault;
+        };
+
+        /// <summary>
+        /// Creates an argument parser for a single-valued argument using a parser that operates on the string value.
+        /// </summary>
+        /// <typeparam name="T">The type of the parsed value.</typeparam>
+        /// <param name="parse">The string parser.</param>
+        /// <returns>The argument parser.</returns>
+        internal static ParseArgument<T> ParseArgumentWith<T>(TryParseValue<T> parse) => argument =>
+        {
+            var values = ParseArgumentsWith(parse)(argument);
+            return values == null ? default : values.Single();
+        };
+
+        /// <summary>
+        /// Parses a <see cref="BigInteger"/>.
+        /// </summary>
+        /// <param name="value">The string value to parse.</param>
+        /// <param name="optionName">The name of the option that the value was used with.</param>
+        /// <returns>A validation of the parsed <see cref="BigInteger"/>.</returns>
+        internal static Validation<BigInteger> TryParseBigInteger(string value, string optionName = null) =>
+            BigInteger.TryParse(value, out var result)
+            ? Validation<BigInteger>.Success(result)
+            : Validation<BigInteger>.Failure(GetArgumentErrorMessage(value, optionName, typeof(BigInteger)));
+
+        /// <summary>
+        /// Parses a <see cref="QRange"/>.
+        /// </summary>
+        /// <param name="value">The string value to parse.</param>
+        /// <param name="optionName">The name of the option that the value was used with.</param>
+        /// <returns>A validation of the parsed <see cref="QRange"/>.</returns>
+        internal static Validation<QRange> TryParseQRange(string value, string optionName = null)
+        {
+            Validation<long> tryParseLong(string longValue) =>
+                long.TryParse(longValue, out var result)
+                ? Validation<long>.Success(result)
+                : Validation<long>.Failure(GetArgumentErrorMessage(longValue, optionName, typeof(long)));
+
+            return value.Split("..").Select(tryParseLong).Sequence().Bind(values =>
+                values.Count() == 2
+                ? Validation<QRange>.Success(new QRange(values.ElementAt(0), values.ElementAt(1)))
+                : values.Count() == 3
+                ? Validation<QRange>.Success(new QRange(values.ElementAt(0), values.ElementAt(1), values.ElementAt(2)))
+                : Validation<QRange>.Failure(GetArgumentErrorMessage(value, optionName, typeof(QRange))));
+        }
+
+        /// <summary>
+        /// Parses a <see cref="QVoid"/>.
+        /// </summary>
+        /// <param name="value">The string value to parse.</param>
+        /// <param name="optionName">The name of the option that the value was used with.</param>
+        /// <returns>A validation of the parsed <see cref="QVoid"/>.</returns>
+        internal static Validation<QVoid> TryParseQVoid(string value, string optionName = null) =>
+            value.Trim() == QVoid.Instance.ToString()
+            ? Validation<QVoid>.Success(QVoid.Instance)
+            : Validation<QVoid>.Failure(GetArgumentErrorMessage(value, optionName, typeof(QVoid)));
+
+        /// <summary>
+        /// Parses a <see cref="Result"/>.
+        /// </summary>
+        /// <param name="value">The string value to parse.</param>
+        /// <param name="optionName">The name of the option that the value was used with.</param>
+        /// <returns>A validation of the parsed <see cref="Result"/>.</returns>
+        internal static Validation<Result> TryParseResult(string value, string optionName = null) =>
+            Enum.TryParse(value, ignoreCase: true, out ResultValue result)
+            ? Validation<Result>.Success(result switch
+            {
+                ResultValue.Zero => Result.Zero,
+                ResultValue.One => Result.One,
+                var invalid => throw new Exception($"Invalid result value '{invalid}'.")
+            })
+            : Validation<Result>.Failure(GetArgumentErrorMessage(value, optionName, typeof(Result)));
+
+        /// <summary>
+        /// Returns an error message string for an argument parser.
+        /// </summary>
+        /// <param name="arg">The value of the argument being parsed.</param>
+        /// <param name="optionName">The name of the option.</param>
+        /// <param name="type">The expected type of the argument.</param>
+        /// <returns>An error message string for an argument parser.</returns>
+        private static string GetArgumentErrorMessage(string arg, string optionName, Type type) =>
+            $"Cannot parse argument '{arg}' for option '{optionName}' as expected type {type}.";
+    }
+}
diff --git a/src/Simulation/CsharpGeneration/Resources/EntryPoint/Validation.cs b/src/Simulation/CsharpGeneration/Resources/EntryPoint/Validation.cs
new file mode 100644
index 00000000000..20b8eaf6571
--- /dev/null
+++ b/src/Simulation/CsharpGeneration/Resources/EntryPoint/Validation.cs
@@ -0,0 +1,86 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+namespace @Namespace
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+
+    /// <summary>
+    /// Represents either a success or a failure of a process.
+    /// </summary>
+    /// <typeparam name="T">The type of the success value.</typeparam>
+    internal struct Validation<T>
+    {
+        public bool IsSuccess { get; }
+        public bool IsFailure { get => !IsSuccess; }
+        public T Value { get => IsSuccess ? ValueOrDefault : throw new InvalidOperationException(); }
+        public T ValueOrDefault { get; }
+        public string ErrorMessage { get; }
+
+        private Validation(bool isSuccess, T value, string errorMessage)
+        {
+            IsSuccess = isSuccess;
+            ValueOrDefault = value;
+            ErrorMessage = errorMessage;
+        }
+
+        public static Validation<T> Success(T value) =>
+            new Validation<T>(true, value, default);
+
+        public static Validation<T> Failure(string errorMessage = null) =>
+            new Validation<T>(false, default, errorMessage);
+    }
+
+    /// <summary>
+    /// Extension methods for <see cref="Validation{T}"/>.
+    /// </summary>
+    internal static class ValidationExtensions
+    {
+        /// <summary>
+        /// Sequentially composes two validations, passing the value of the first validation to another
+        /// validation-producing function if the first validation is a success.
+        /// </summary>
+        /// <typeparam name="T">The type of the first validation's success value.</typeparam>
+        /// <typeparam name="U">The type of the second validation's success value.</typeparam>
+        /// <param name="validation">The first validation.</param>
+        /// <param name="bind">
+        /// A function that takes the value of the first validation and returns a second validation.
+        /// </param>
+        /// <returns>
+        /// The first validation if the first validation is a failure; otherwise, the return value of calling the bind
+        /// function on the first validation's success value.
+        /// </returns>
+        internal static Validation<U> Bind<T, U>(this Validation<T> validation, Func<T, Validation<U>> bind) =>
+            validation.IsFailure ? Validation<U>.Failure(validation.ErrorMessage) : bind(validation.Value);
+
+        /// <summary>
+        /// Converts an enumerable of validations into a validation of an enumerable.
+        /// </summary>
+        /// <typeparam name="T">The type of the validation success values.</typeparam>
+        /// <param name="validations">The validations to sequence.</param>
+        /// <returns>
+        /// A validation that contains an enumerable of the validation values if all of the validations are a success,
+        /// or the first error message if one of the validations is a failure.
+        /// </returns>
+        internal static Validation<IEnumerable<T>> Sequence<T>(this IEnumerable<Validation<T>> validations) =>
+            validations.All(validation => validation.IsSuccess)
+            ? Validation<IEnumerable<T>>.Success(validations.Select(validation => validation.Value))
+            : Validation<IEnumerable<T>>.Failure(validations.First(validation => validation.IsFailure).ErrorMessage);
+
+        /// <summary>
+        /// Calls the action on the validation value if the validation is a success.
+        /// </summary>
+        /// <typeparam name="T">The type of the validation's success value.</typeparam>
+        /// <param name="validation">The validation.</param>
+        /// <param name="onSuccess">The action to call if the validation is a success.</param>
+        internal static void Then<T>(this Validation<T> validation, Action<T> onSuccess)
+        {
+            if (validation.IsSuccess)
+            {
+                onSuccess(validation.Value);
+            }
+        }
+    }
+}
diff --git a/src/Simulation/CsharpGeneration/Resources/EntryPointDriver.cs b/src/Simulation/CsharpGeneration/Resources/EntryPointDriver.cs
deleted file mode 100644
index 672ee3b049f..00000000000
--- a/src/Simulation/CsharpGeneration/Resources/EntryPointDriver.cs
+++ /dev/null
@@ -1,394 +0,0 @@
-namespace @Namespace
-{
-    using Microsoft.Quantum.Simulation.Core;
-    using Microsoft.Quantum.Simulation.Simulators;
-    using System;
-    using System.Collections.Generic;
-    using System.Collections.Immutable;
-    using System.CommandLine;
-    using System.CommandLine.Builder;
-    using System.CommandLine.Help;
-    using System.CommandLine.Invocation;
-    using System.CommandLine.Parsing;
-    using System.Linq;
-    using System.Numerics;
-    using System.Threading.Tasks;
-
-    /// <summary>
-    /// The entry point driver is the entry point for the C# application that executes the Q# entry point.
-    /// </summary>
-    internal static class Driver
-    {
-        /// <summary>
-        /// The argument handler for the Q# Unit type.
-        /// </summary>
-        internal static Argument<QVoid> UnitArgumentHandler
-        {
-            get
-            {
-                var arg = new Argument<QVoid>(CreateArgumentParser(value =>
-                    value.Trim() == QVoid.Instance.ToString() ? (true, QVoid.Instance) : (false, default)));
-                arg.AddSuggestions(new[] { QVoid.Instance.ToString() });
-                return arg;
-            }
-        }
-
-        /// <summary>
-        /// The argument handler for the Q# Result type.
-        /// </summary>
-        internal static Argument<Result> ResultArgumentHandler
-        {
-            get
-            {
-                var arg = new Argument<Result>(CreateArgumentParser(value =>
-                    Enum.TryParse(value, ignoreCase: true, out ResultValue result) ? result switch
-                    {
-                        ResultValue.Zero => (true, Result.Zero),
-                        ResultValue.One => (true, Result.One),
-                        _ => (false, default)
-                    } : (false, default)));
-                arg.AddSuggestions(new[] { ResultValue.Zero.ToString(), ResultValue.One.ToString() });
-                return arg;
-            }
-        }
-
-        /// <summary>
-        /// The argument handler for the Q# BigInt type.
-        /// </summary>
-        internal static Argument<BigInteger> BigIntArgumentHandler => new Argument<BigInteger>(
-            CreateArgumentParser(value =>
-                BigInteger.TryParse(value, out var result) ? (true, result) : (false, default)));
-
-        /// <summary>
-        /// The argument handler for the Q# Range type.
-        /// </summary>
-        internal static Argument<QRange> RangeArgumentHandler => new Argument<QRange>(result =>
-        {
-            var option = ((OptionResult)result.Parent).Token.Value;
-            var value = result.Tokens.Single().Value;
-            var range = ParseRangeFromEnumerable(option, value, value.Split(".."));
-            if (range.IsFailure)
-            {
-                result.ErrorMessage = range.ErrorMessage;
-            }
-            return range.ValueOrDefault;
-        })
-        {
-            Arity = ArgumentArity.ExactlyOne
-        };
-
-        /// <summary>
-        /// Runs the entry point.
-        /// </summary>
-        /// <param name="args">The command-line arguments.</param>
-        /// <returns>The exit code.</returns>
-        private static async Task<int> Main(string[] args)
-        {
-            var simulate = new Command("simulate", "(default) Run the program using a local simulator.");
-            TryCreateOption(
-                Constants.SimulatorOptions,
-                () => EntryPoint.DefaultSimulator,
-                "The name of the simulator to use.").Then(option =>
-                {
-                    option.Argument.AddSuggestions(ImmutableHashSet<string>.Empty
-                        .Add(Constants.QuantumSimulator)
-                        .Add(Constants.ToffoliSimulator)
-                        .Add(Constants.ResourcesEstimator)
-                        .Add(EntryPoint.DefaultSimulator));
-                    simulate.AddOption(option);
-                });
-            simulate.Handler = CommandHandler.Create<EntryPoint, string>(Simulate);
-
-            var root = new RootCommand(EntryPoint.Summary) { simulate };
-            foreach (var option in EntryPoint.Options) { root.AddGlobalOption(option); }
-
-            // Set the simulate command as the default.
-            foreach (var option in simulate.Options) { root.AddOption(option); }
-            root.Handler = simulate.Handler;
-
-            return await new CommandLineBuilder(root)
-                .UseDefaults()
-                .UseHelpBuilder(context => new QsHelpBuilder(context.Console))
-                .Build()
-                .InvokeAsync(args);
-        }
-
-        /// <summary>
-        /// Simulates the entry point.
-        /// </summary>
-        /// <param name="entryPoint">The entry point.</param>
-        /// <param name="simulator">The simulator to use.</param>
-        /// <returns>The exit code.</returns>
-        private static async Task<int> Simulate(EntryPoint entryPoint, string simulator)
-        {
-            simulator = DefaultIfShadowed(Constants.SimulatorOptions.First(), simulator, EntryPoint.DefaultSimulator);
-            switch (simulator)
-            {
-                case Constants.ResourcesEstimator:
-                    var resourcesEstimator = new ResourcesEstimator();
-                    await entryPoint.Run(resourcesEstimator);
-                    Console.WriteLine(resourcesEstimator.ToTSV());
-                    break;
-                default:
-                    var (isCustom, createSimulator) = simulator switch
-                    {
-                        Constants.QuantumSimulator =>
-                            (false, new Func<IOperationFactory>(() => new QuantumSimulator())),
-                        Constants.ToffoliSimulator =>
-                            (false, new Func<IOperationFactory>(() => new ToffoliSimulator())),
-                        _ => (true, EntryPoint.CreateDefaultCustomSimulator)
-                    };
-                    if (isCustom && simulator != EntryPoint.DefaultSimulator)
-                    {
-                        DisplayCustomSimulatorError(simulator);
-                        return 1;
-                    }
-                    await DisplayEntryPointResult(entryPoint, createSimulator);
-                    break;
-            }
-            return 0;
-        }
-
-        /// <summary>
-        /// Runs the entry point on a simulator and displays its return value.
-        /// </summary>
-        /// <param name="entryPoint">The entry point.</param>
-        /// <param name="createSimulator">A function that creates an instance of the simulator to use.</param>
-        private static async Task DisplayEntryPointResult(
-            EntryPoint entryPoint, Func<IOperationFactory> createSimulator)
-        {
-            var simulator = createSimulator();
-            try
-            {
-                var value = await entryPoint.Run(simulator);
-#pragma warning disable CS0184
-                if (!(value is QVoid))
-#pragma warning restore CS0184
-                {
-                    Console.WriteLine(value);
-                }
-            }
-            finally
-            {
-                if (simulator is IDisposable disposable)
-                {
-                    disposable.Dispose();
-                }
-            }
-        }
-
-        /// <summary>
-        /// Returns true if the alias is available for use by the driver (that is, the alias is not already used by an
-        /// entry point option).
-        /// </summary>
-        /// <param name="alias">The alias to check.</param>
-        /// <returns>True if the alias is available for use by the driver.</returns>
-        private static bool IsAliasAvailable(string alias) =>
-            !EntryPoint.Options.SelectMany(option => option.RawAliases).Contains(alias);
-
-        /// <summary>
-        /// Returns the default value and displays a warning if the alias is shadowed by an entry point option, and
-        /// returns the original value otherwise.
-        /// </summary>
-        /// <typeparam name="T">The type of the values.</typeparam>
-        /// <param name="alias">The primary option alias corresponding to the value.</param>
-        /// <param name="value">The value of the option given on the command line.</param>
-        /// <param name="defaultValue">The default value for the option.</param>
-        /// <returns></returns>
-        private static T DefaultIfShadowed<T>(string alias, T value, T defaultValue)
-        {
-            if (IsAliasAvailable(alias))
-            {
-                return value;
-            }
-            else
-            {
-                var originalForeground = Console.ForegroundColor;
-                Console.ForegroundColor = ConsoleColor.Yellow;
-                Console.Error.WriteLine($"Warning: Option {alias} is overriden by an entry point parameter name.");
-                Console.Error.WriteLine($"         Using default value {defaultValue}.");
-                Console.ForegroundColor = originalForeground;
-                return defaultValue;
-            }
-        }
-
-        /// <summary>
-        /// Tries to create an option by removing aliases that are already in use by the entry point. If the first
-        /// alias, which is considered the primary alias, is in use, then the option is not created.
-        /// </summary>
-        /// <typeparam name="T">The type of the option's argument.</typeparam>
-        /// <param name="aliases">The option's aliases.</param>
-        /// <param name="getDefaultValue">A function that returns the option's default value.</param>
-        /// <param name="description">The option's description.</param>
-        /// <returns>The result of trying to create the option.</returns>
-        private static Result<Option<T>> TryCreateOption<T>(
-                IEnumerable<string> aliases, Func<T> getDefaultValue, string description = null) =>
-            IsAliasAvailable(aliases.First())
-            ? Result<Option<T>>.Success(
-                new Option<T>(aliases.Where(IsAliasAvailable).ToArray(), getDefaultValue, description))
-            : Result<Option<T>>.Failure();
-
-        /// <summary>
-        /// Creates an argument parser that will use a default error message if parsing fails.
-        /// </summary>
-        /// <typeparam name="T">The type of the argument.</typeparam>
-        /// <param name="parse">
-        /// A function that takes the argument as a string and returns the parsed value and a boolean to indicate
-        /// whether parsing succeeded.
-        /// </param>
-        /// <returns>An argument parser.</returns>
-        private static ParseArgument<T> CreateArgumentParser<T>(Func<string, (bool, T)> parse) => result =>
-        {
-            var (success, value) = parse(result.Tokens.Single().Value);
-            if (!success)
-            {
-                result.ErrorMessage = GetArgumentErrorMessage(
-                    ((OptionResult)result.Parent).Token.Value, result.Tokens.Single().Value, typeof(T));
-            }
-            return value;
-        };
-
-        /// <summary>
-        /// Parses a Q# range from an enumerable of strings, where the items are start and end or start, step, and end.
-        /// </summary>
-        /// <param name="option">The name of the option being parsed.</param>
-        /// <param name="arg">The argument string for the option.</param>
-        /// <param name="items">The items in the argument.</param>
-        /// <returns>The result of parsing the strings.</returns>
-        private static Result<QRange> ParseRangeFromEnumerable(string option, string arg, IEnumerable<string> items) =>
-            items.Select(item => TryParseLong(option, item)).Sequence().Bind(values =>
-                values.Count() == 2
-                ? Result<QRange>.Success(new QRange(values.ElementAt(0), values.ElementAt(1)))
-                : values.Count() == 3
-                ? Result<QRange>.Success(new QRange(values.ElementAt(0), values.ElementAt(1), values.ElementAt(2)))
-                : Result<QRange>.Failure(GetArgumentErrorMessage(option, arg, typeof(QRange))));
-
-        /// <summary>
-        /// Parses a long from a string.
-        /// </summary>
-        /// <param name="option">The name of the option being parsed.</param>
-        /// <param name="str">The string to parse.</param>
-        /// <returns>The result of parsing the string.</returns>
-        private static Result<long> TryParseLong(string option, string str) =>
-            long.TryParse(str, out var result)
-            ? Result<long>.Success(result)
-            : Result<long>.Failure(GetArgumentErrorMessage(option, str, typeof(long)));
-
-        /// <summary>
-        /// Returns an error message string for an argument parser.
-        /// </summary>
-        /// <param name="option">The name of the option.</param>
-        /// <param name="arg">The value of the argument being parsed.</param>
-        /// <param name="type">The expected type of the argument.</param>
-        /// <returns>An error message string for an argument parser.</returns>
-        private static string GetArgumentErrorMessage(string option, string arg, Type type) =>
-            $"Cannot parse argument '{arg}' for option '{option}' as expected type {type}.";
-
-        /// <summary>
-        /// Displays an error message for using a non-default custom simulator.
-        /// </summary>
-        /// <param name="name">The name of the custom simulator.</param>
-        private static void DisplayCustomSimulatorError(string name)
-        {
-            var originalForeground = Console.ForegroundColor;
-            Console.ForegroundColor = ConsoleColor.Red;
-            Console.Error.WriteLine($"The simulator '{name}' could not be found.");
-            Console.ForegroundColor = originalForeground;
-            Console.Error.WriteLine();
-            Console.Error.WriteLine(
-                $"If '{name}' is a custom simulator, it must be set in the DefaultSimulator project property:");
-            Console.Error.WriteLine();
-            Console.Error.WriteLine("<PropertyGroup>");
-            Console.Error.WriteLine($"  <DefaultSimulator>{name}</DefaultSimulator>");
-            Console.Error.WriteLine("</PropertyGroup>");
-        }
-    }
-
-    /// <summary>
-    /// A modification of the command line <see cref="HelpBuilder"/> class.
-    /// </summary>
-    internal class QsHelpBuilder : HelpBuilder
-    {
-        public QsHelpBuilder(IConsole console) : base(console) { }
-
-        protected override string ArgumentDescriptor(IArgument argument)
-        {
-            // Hide long argument descriptors.
-            var descriptor = base.ArgumentDescriptor(argument);
-            return descriptor.Length > 30 ? argument.Name : descriptor;
-        }
-    }
-
-    /// <summary>
-    /// The result of a process that can either succeed or fail.
-    /// </summary>
-    /// <typeparam name="T">The type of the result value.</typeparam>
-    internal struct Result<T>
-    {
-        public bool IsSuccess { get; }
-        public bool IsFailure { get => !IsSuccess; }
-        public T Value { get => IsSuccess ? ValueOrDefault : throw new InvalidOperationException(); }
-        public T ValueOrDefault { get; }
-        public string ErrorMessage { get; }
-
-        private Result(bool isSuccess, T value, string errorMessage)
-        {
-            IsSuccess = isSuccess;
-            ValueOrDefault = value;
-            ErrorMessage = errorMessage;
-        }
-
-        public static Result<T> Success(T value) => new Result<T>(true, value, default);
-
-        public static Result<T> Failure(string errorMessage = null) => new Result<T>(false, default, errorMessage);
-    }
-
-    /// <summary>
-    /// Extension methods for <see cref="Result{T}"/>.
-    /// </summary>
-    internal static class ResultExtensions
-    {
-        /// <summary>
-        /// Sequentially composes two results, passing the value of the first result to another result-producing
-        /// function if the first result is a success.
-        /// </summary>
-        /// <typeparam name="T">The type of the first result value.</typeparam>
-        /// <typeparam name="U">The type of the second result value.</typeparam>
-        /// <param name="result">The first result.</param>
-        /// <param name="bind">A function that takes the value of the first result and returns a second result.</param>
-        /// <returns>
-        /// The first result if the first result is a failure; otherwise, the result of calling the bind function on the
-        /// first result's value.
-        /// </returns>
-        internal static Result<U> Bind<T, U>(this Result<T> result, Func<T, Result<U>> bind) =>
-            result.IsFailure ? Result<U>.Failure(result.ErrorMessage) : bind(result.Value);
-
-        /// <summary>
-        /// Converts an enumerable of results into a result of an enumerable.
-        /// </summary>
-        /// <typeparam name="T">The type of the result values.</typeparam>
-        /// <param name="results">The results to sequence.</param>
-        /// <returns>
-        /// A result that contains an enumerable of the result values if all of the results are a success, or the first
-        /// error message if one of the results is a failure.
-        /// </returns>
-        internal static Result<IEnumerable<T>> Sequence<T>(this IEnumerable<Result<T>> results) =>
-            results.All(result => result.IsSuccess)
-            ? Result<IEnumerable<T>>.Success(results.Select(results => results.Value))
-            : Result<IEnumerable<T>>.Failure(results.First(results => results.IsFailure).ErrorMessage);
-
-        /// <summary>
-        /// Calls the action on the result value if the result is a success.
-        /// </summary>
-        /// <typeparam name="T">The type of the result value.</typeparam>
-        /// <param name="result">The result.</param>
-        /// <param name="onSuccess">The action to call if the result is a success.</param>
-        internal static void Then<T>(this Result<T> result, Action<T> onSuccess)
-        {
-            if (result.IsSuccess)
-            {
-                onSuccess(result.Value);
-            }
-        }
-    }
-}