diff --git a/src/DocoptNet/ApplicationResultAccumulator.cs b/src/DocoptNet/ApplicationResultAccumulator.cs
new file mode 100644
index 00000000..8aa3dd24
--- /dev/null
+++ b/src/DocoptNet/ApplicationResultAccumulator.cs
@@ -0,0 +1,72 @@
+#nullable enable
+
+namespace DocoptNet
+{
+    using System.Collections.Generic;
+
+    interface IApplicationResultAccumulator<T>
+    {
+        T New();
+        T Command(T state, string name, bool value);
+        T Command(T state, string name, int value);
+        T Argument(T state, string name);
+        T Argument(T state, string name, string value);
+        T Argument(T state, string name, StringList value);
+        T Option(T state, string name);
+        T Option(T state, string name, bool value);
+        T Option(T state, string name, string value);
+        T Option(T state, string name, int value);
+        T Option(T state, string name, StringList value);
+        T Error(DocoptBaseException exception);
+    }
+
+    static class ApplicationResultAccumulators
+    {
+        public static readonly IApplicationResultAccumulator<IDictionary<string, Value>> ValueDictionary = new ValueDictionaryAccumulator();
+        public static readonly IApplicationResultAccumulator<IDictionary<string, ValueObject>> ValueObjectDictionary = new ValueObjectDictionaryAccumulator();
+
+        sealed class ValueDictionaryAccumulator : IApplicationResultAccumulator<IDictionary<string, Value>>
+        {
+            public IDictionary<string, Value> New() => new Dictionary<string, Value>();
+            public IDictionary<string, Value> Command(IDictionary<string, Value> state, string name, bool value) => Adding(state, name, value);
+            public IDictionary<string, Value> Command(IDictionary<string, Value> state, string name, int value) => Adding(state, name, value);
+            public IDictionary<string, Value> Argument(IDictionary<string, Value> state, string name) => Adding(state, name, Value.None);
+            public IDictionary<string, Value> Argument(IDictionary<string, Value> state, string name, string value) => Adding(state, name, value);
+            public IDictionary<string, Value> Argument(IDictionary<string, Value> state, string name, StringList value) => Adding(state, name, value);
+            public IDictionary<string, Value> Option(IDictionary<string, Value> state, string name) => Adding(state, name, Value.None);
+            public IDictionary<string, Value> Option(IDictionary<string, Value> state, string name, bool value) => Adding(state, name, value);
+            public IDictionary<string, Value> Option(IDictionary<string, Value> state, string name, string value) => Adding(state, name, value);
+            public IDictionary<string, Value> Option(IDictionary<string, Value> state, string name, int value) => Adding(state, name, value);
+            public IDictionary<string, Value> Option(IDictionary<string, Value> state, string name, StringList value) => Adding(state, name, value);
+            public IDictionary<string, Value> Error(DocoptBaseException exception) => null!;
+
+            static IDictionary<string, Value> Adding(IDictionary<string, Value> dict, string name, Value value)
+            {
+                dict[name] = value;
+                return dict;
+            }
+        }
+
+        sealed class ValueObjectDictionaryAccumulator : IApplicationResultAccumulator<IDictionary<string, ValueObject>>
+        {
+            public IDictionary<string, ValueObject> New() => new Dictionary<string, ValueObject>();
+            public IDictionary<string, ValueObject> Command(IDictionary<string, ValueObject> state, string name, bool value) => Adding(state, name, value);
+            public IDictionary<string, ValueObject> Command(IDictionary<string, ValueObject> state, string name, int value) => Adding(state, name, value);
+            public IDictionary<string, ValueObject> Argument(IDictionary<string, ValueObject> state, string name) => Adding(state, name, null);
+            public IDictionary<string, ValueObject> Argument(IDictionary<string, ValueObject> state, string name, string value) => Adding(state, name, value);
+            public IDictionary<string, ValueObject> Argument(IDictionary<string, ValueObject> state, string name, StringList value) => Adding(state, name, value);
+            public IDictionary<string, ValueObject> Option(IDictionary<string, ValueObject> state, string name) => Adding(state, name, null);
+            public IDictionary<string, ValueObject> Option(IDictionary<string, ValueObject> state, string name, bool value) => Adding(state, name, value);
+            public IDictionary<string, ValueObject> Option(IDictionary<string, ValueObject> state, string name, string value) => Adding(state, name, value);
+            public IDictionary<string, ValueObject> Option(IDictionary<string, ValueObject> state, string name, int value) => Adding(state, name, value);
+            public IDictionary<string, ValueObject> Option(IDictionary<string, ValueObject> state, string name, StringList value) => Adding(state, name, value);
+            public IDictionary<string, ValueObject> Error(DocoptBaseException exception) => null!;
+
+            static IDictionary<string, ValueObject> Adding(IDictionary<string, ValueObject> dict, string name, object? value)
+            {
+                dict[name] = new ValueObject(value);
+                return dict;
+            }
+        }
+    }
+}
diff --git a/src/DocoptNet/Argument.cs b/src/DocoptNet/Argument.cs
index f658ecbc..7a0e0cb4 100644
--- a/src/DocoptNet/Argument.cs
+++ b/src/DocoptNet/Argument.cs
@@ -1,31 +1,36 @@
 namespace DocoptNet
 {
-    using System.Collections;
+    using System.Globalization;
 
     class Argument: LeafPattern
     {
-        public Argument(string name, ValueObject value = null) : base(name, value)
+        public Argument(string name) : base(name, Value.None)
         {
         }
 
         public Argument(string name, string value)
-            : base(name, new ValueObject(value))
+            : base(name, value)
         {
         }
 
-        public Argument(string name, ICollection coll)
-            : base(name, new ValueObject(coll))
+        public Argument(string name, string[] values)
+            : base(name, StringList.BottomTop(values))
         {
         }
 
+        /// <remarks>
+        /// This is only used by tests as a convenience. The instantiated
+        /// <see cref="Value"/> is a string representation of the integer.
+        /// </remarks>
+
         public Argument(string name, int value)
-            : base(name, new ValueObject(value))
+            : this(name, value.ToString(CultureInfo.InvariantCulture))
         {
         }
 
         public override Node ToNode()
         {
-            return new ArgumentNode(this.Name, (this.Value != null && this.Value.IsList) ? ValueType.List : ValueType.String);
+            return new ArgumentNode(this.Name, Value.IsStringList ? ValueType.List : ValueType.String);
         }
 
         public override string GenerateCode()
@@ -33,7 +38,7 @@ public override string GenerateCode()
             var s = Name.Replace("<", "").Replace(">", "").ToLowerInvariant();
             s = "Arg" + GenerateCodeHelper.ConvertToPascalCase(s);
 
-            if (Value != null && Value.IsList)
+            if (Value.IsStringList)
             {
                 return $"public ArrayList {s} {{ get {{ return _args[\"{Name}\"].AsList; }} }}";
             }
diff --git a/src/DocoptNet/Command.cs b/src/DocoptNet/Command.cs
index 31246c0a..3680f74d 100644
--- a/src/DocoptNet/Command.cs
+++ b/src/DocoptNet/Command.cs
@@ -1,8 +1,8 @@
 namespace DocoptNet
 {
-    class Command : Argument
+    class Command : LeafPattern
     {
-        public Command(string name, ValueObject value = null) : base(name, value ?? new ValueObject(false))
+        public Command(string name, bool value = false) : base(name, value ? Value.True : Value.False)
         {
         }
 
diff --git a/src/DocoptNet/Docopt.cs b/src/DocoptNet/Docopt.cs
index 6c724dab..3891a5f7 100644
--- a/src/DocoptNet/Docopt.cs
+++ b/src/DocoptNet/Docopt.cs
@@ -25,6 +25,27 @@ public IDictionary<string, ValueObject> Apply(string doc, ICollection<string> ar
         protected IDictionary<string, ValueObject> Apply(string doc, Tokens tokens,
             bool help = true,
             object version = null, bool optionsFirst = false, bool exit = false)
+        {
+            return Apply(doc, tokens, ApplicationResultAccumulators.ValueObjectDictionary, help, version, optionsFirst, exit);
+        }
+
+        internal T Apply<T>(string doc, IApplicationResultAccumulator<T> accumulator)
+        {
+            return Apply(doc, new Tokens(Enumerable.Empty<string>(), typeof (DocoptInputErrorException)), accumulator);
+        }
+
+        internal T Apply<T>(string doc, ICollection<string> argv,
+                            IApplicationResultAccumulator<T> accumulator,
+                            bool help = true, object version = null,
+                            bool optionsFirst = false, bool exit = false)
+        {
+            return Apply(doc, new Tokens(argv, typeof (DocoptInputErrorException)), accumulator, help, version, optionsFirst, exit);
+        }
+
+        internal T Apply<T>(string doc, Tokens tokens,
+                            IApplicationResultAccumulator<T> accumulator,
+                            bool help = true, object version = null,
+                            bool optionsFirst = false, bool exit = false)
         {
             try
             {
@@ -46,18 +67,33 @@ protected IDictionary<string, ValueObject> Apply(string doc, Tokens tokens,
                     optionsShortcut.Children = docOptions.Distinct().Except(patternOptions).ToList();
                 }
 
-                if (help && arguments.Any(o => o is { Name: "-h" or "--help", Value: { IsNullOrEmpty: false } }))
+                static bool IsNullOrEmptyString(object obj) => obj is null or string { Length: 0 };
+
+                if (help && arguments.Any(o => o is { Name: "-h" or "--help" } && !IsNullOrEmptyString(o.Value)))
                     OnPrintExit(doc);
 
-                if (version is not null && arguments.Any(o => o is { Name: "--version", Value: { IsNullOrEmpty: false } }))
+                if (version is not null && arguments.Any(o => o is { Name: "--version" } && !IsNullOrEmptyString(o.Value)))
                     OnPrintExit(version.ToString());
 
                 if (pattern.Fix().Match(arguments) is (true, { Count: 0 }, var collected))
                 {
-                    var dict = new Dictionary<string, ValueObject>();
-                    foreach (var p in pattern.Flat().OfType<LeafPattern>().Concat(collected))
-                        dict[p.Name] = p.Value;
-                    return dict;
+                    return pattern.Flat()
+                                  .OfType<LeafPattern>()
+                                  .Concat(collected)
+                                  .Aggregate(accumulator.New(), (state, p) => (p, p.Value.Box) switch
+                                   {
+                                       (Command , bool v       ) => accumulator.Command(state, p.Name, v),
+                                       (Command , int v        ) => accumulator.Command(state, p.Name, v),
+                                       (Argument, null         ) => accumulator.Argument(state, p.Name),
+                                       (Argument, string v     ) => accumulator.Argument(state, p.Name, v),
+                                       (Argument, StringList v ) => accumulator.Argument(state, p.Name, v.Reverse()),
+                                       (Option  , bool v       ) => accumulator.Option(state, p.Name, v),
+                                       (Option  , int v        ) => accumulator.Option(state, p.Name, v),
+                                       (Option  , string v     ) => accumulator.Option(state, p.Name, v),
+                                       (Option  , null         ) => accumulator.Option(state, p.Name),
+                                       (Option  , StringList v ) => accumulator.Option(state, p.Name, v.Reverse()),
+                                       var other => throw new NotSupportedException($"Unsupported pattern: {other}"),
+                                   });
                 }
                 throw new DocoptInputErrorException(exitUsage);
             }
@@ -68,7 +104,7 @@ protected IDictionary<string, ValueObject> Apply(string doc, Tokens tokens,
 
                 OnPrintExit(e.Message, e.ErrorCode);
 
-                return null;
+                return accumulator.Error(e);
             }
         }
 
@@ -154,7 +190,7 @@ internal static IList<LeafPattern> ParseArgv(Tokens tokens, ICollection<Option>
             {
                 if (tokens.Current() == "--")
                 {
-                    parsed.AddRange(tokens.Select(v => new Argument(null, new ValueObject(v))));
+                    parsed.AddRange(tokens.Select(v => new Argument(null, v)));
                     return parsed;
                 }
 
@@ -168,12 +204,12 @@ internal static IList<LeafPattern> ParseArgv(Tokens tokens, ICollection<Option>
                 }
                 else if (optionsFirst)
                 {
-                    parsed.AddRange(tokens.Select(v => new Argument(null, new ValueObject(v))));
+                    parsed.AddRange(tokens.Select(v => new Argument(null, v)));
                     return parsed;
                 }
                 else
                 {
-                    parsed.Add(new Argument(null, new ValueObject(tokens.Move())));
+                    parsed.Add(new Argument(null, tokens.Move()));
                 }
             }
             return parsed;
@@ -334,14 +370,14 @@ private static IEnumerable<Option> ParseShorts(Tokens tokens, ICollection<Option
                     options.Add(option);
                     if (tokens.ThrowsInputError)
                     {
-                        option = new Option(shortName, null, 0, new ValueObject(true));
+                        option = new Option(shortName, null, 0, Value.True);
                     }
                 }
                 else
                 {
                     // why is copying necessary here?
                     option = new Option(shortName, similar[0].LongName, similar[0].ArgCount, similar[0].Value);
-                    ValueObject value = null;
+                    Value? value = null;
                     if (option.ArgCount != 0)
                     {
                         if (left == "")
@@ -350,16 +386,16 @@ private static IEnumerable<Option> ParseShorts(Tokens tokens, ICollection<Option
                             {
                                 throw tokens.CreateException(shortName + " requires argument");
                             }
-                            value = new ValueObject(tokens.Move());
+                            value = tokens.Move();
                         }
                         else
                         {
-                            value = new ValueObject(left);
+                            value = left;
                             left = "";
                         }
                     }
                     if (tokens.ThrowsInputError)
-                        option.Value = value ?? new ValueObject(true);
+                        option.Value = value ?? Value.True;
                 }
                 parsed.Add(option);
             }
@@ -372,7 +408,7 @@ private static IEnumerable<Option> ParseLong(Tokens tokens, ICollection<Option>
             var (longName, eq, value) = tokens.Move().Partition("=") switch
             {
                 (var ln, "", _) => (ln, false, null),
-                var (ln, _, vs) => (ln, true, new ValueObject(vs))
+                var (ln, _, vs) => (ln, true, vs)
             };
             Debug.Assert(longName.StartsWith("--"));
             var similar = options.Where(o => o.LongName == longName).ToList();
@@ -394,7 +430,7 @@ private static IEnumerable<Option> ParseLong(Tokens tokens, ICollection<Option>
                 option = new Option(null, longName, argCount);
                 options.Add(option);
                 if (tokens.ThrowsInputError)
-                    option = new Option(null, longName, argCount, argCount != 0 ? value : new ValueObject(true));
+                    option = new Option(null, longName, argCount, value is { } v ? v : Value.True);
             }
             else
             {
@@ -410,11 +446,11 @@ private static IEnumerable<Option> ParseLong(Tokens tokens, ICollection<Option>
                     {
                         if (tokens.Current() == null || tokens.Current() == "--")
                             throw tokens.CreateException(option.LongName + " requires an argument");
-                        value = new ValueObject(tokens.Move());
+                        value = tokens.Move();
                     }
                 }
                 if (tokens.ThrowsInputError)
-                    option.Value = value ?? new ValueObject(true);
+                    option.Value = value is { } v ? v : Value.True;
             }
             return new[] {option};
         }
diff --git a/src/DocoptNet/DocoptNet.csproj b/src/DocoptNet/DocoptNet.csproj
index f6fdb401..e42c6428 100644
--- a/src/DocoptNet/DocoptNet.csproj
+++ b/src/DocoptNet/DocoptNet.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>netstandard1.5;netstandard2.0</TargetFrameworks>
+    <TargetFrameworks>netstandard2.1;netstandard2.0;netstandard1.5</TargetFrameworks>
     <DefineConstants>$(DefineConstants);DOCNETOPT_PUBLIC</DefineConstants>
     <!--
     TODO Remove the suppression of the following warnings after addressing them:
@@ -42,7 +42,7 @@
     <PackageTags>parser;command line argument;option library;syntax;shell;beautiful;posix;python;console;command-line;docopt</PackageTags>
   </PropertyGroup>
 
-  <PropertyGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
+  <PropertyGroup Condition="'$(TargetFramework)' == 'netstandard2.1' Or '$(TargetFramework)' == 'netstandard2.0'">
     <DefineConstants>$(DefineConstants);RUNTIME_SERIALIZATION</DefineConstants>
   </PropertyGroup>
 
@@ -86,6 +86,10 @@
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
+    <PackageReference Include="Nullable" Version="1.3.0">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
     <PackageReference Include="System.ValueTuple" Version="4.5.0" />
   </ItemGroup>
 
diff --git a/src/DocoptNet/LeafPattern.cs b/src/DocoptNet/LeafPattern.cs
index 1857c020..faf81c2b 100644
--- a/src/DocoptNet/LeafPattern.cs
+++ b/src/DocoptNet/LeafPattern.cs
@@ -11,7 +11,7 @@ internal abstract class LeafPattern: Pattern
     {
         private readonly string _name;
 
-        protected LeafPattern(string name, ValueObject value=null)
+        protected LeafPattern(string name, Value value = default)
         {
             _name = name;
             Value = value;
@@ -26,7 +26,7 @@ public override string Name
             get { return _name; }
         }
 
-        public ValueObject Value { get; set; }
+        public Value Value { get; set; }
 
         public override ICollection<Pattern> Flat(params Type[] types)
         {
@@ -40,7 +40,8 @@ public override ICollection<Pattern> Flat(params Type[] types)
 
         public override string ToString()
         {
-            return $"{GetType().Name}({Name}, {Value})";
+            var value = Value.TryAsStringList(out var list) ? list.Reverse() : Value;
+            return $"{GetType().Name}({Name}, {ValueObject.Format(value)})";
         }
     }
 }
diff --git a/src/DocoptNet/Option.cs b/src/DocoptNet/Option.cs
index 0f8a0842..0920c1bb 100644
--- a/src/DocoptNet/Option.cs
+++ b/src/DocoptNet/Option.cs
@@ -9,18 +9,18 @@ class Option : LeafPattern
         public string LongName { get; private set; }
         public int ArgCount { get; private set; }
 
-        public Option(string shortName = null, string longName = null, int argCount = 0, ValueObject value = null)
+        public Option(string shortName = null, string longName = null, int argCount = 0, Value? value = null)
             : base()
         {
             ShortName = shortName;
             LongName = longName;
             ArgCount = argCount;
-            var v = value ?? new ValueObject(false);
-            Value = (v.IsFalse && argCount > 0) ? null : v;
+            var v = value ?? Value.False;
+            Value = v.IsFalse && argCount > 0 ? Value.None : v;
         }
 
         public Option(string shortName, string longName, int argCount, string value)
-            : this(shortName, longName, argCount, new ValueObject(value))
+            : this(shortName, longName, argCount, (Value)value)
         {
         }
 
@@ -43,7 +43,7 @@ public override string GenerateCode()
             {
                 return $"public bool {s} {{ get {{ return _args[\"{Name}\"].IsTrue; }} }}";
             }
-            var defaultValue = Value == null ? "null" : $"\"{Value}\"";
+            var defaultValue = Value.IsNone ? "null" : $"\"{Value}\"";
             return string.Format("public string {0} {{ get {{ return null == _args[\"{1}\"] ? {2} : _args[\"{1}\"].ToString(); }} }}", s, Name, defaultValue);
         }
 
@@ -61,7 +61,7 @@ public static Option Parse(string optionDescription)
             string shortName = null;
             string longName = null;
             var argCount = 0;
-            var value = new ValueObject(false);
+            var value = Value.False;
             var (options, _, description) = optionDescription.Trim().Partition(DESC_SEPARATOR);
             foreach (var s in options.Split(" \t,=".ToCharArray(), StringSplitOptions.RemoveEmptyEntries))
             {
@@ -80,7 +80,7 @@ public static Option Parse(string optionDescription)
             {
                 var r = new Regex(@"\[default: (.*)\]", RegexOptions.IgnoreCase);
                 var m = r.Match(description);
-                value = m.Success ? new ValueObject(m.Groups[1].Value) : null;
+                value = m.Success ? m.Groups[1].Value : Value.None;
             }
             return new Option(shortName, longName, argCount, value);
         }
diff --git a/src/DocoptNet/Pattern.cs b/src/DocoptNet/Pattern.cs
index 62915e71..c27b99ba 100644
--- a/src/DocoptNet/Pattern.cs
+++ b/src/DocoptNet/Pattern.cs
@@ -1,7 +1,6 @@
 namespace DocoptNet
 {
     using System;
-    using System.Collections;
     using System.Collections.Generic;
     using System.Diagnostics;
     using System.Linq;
@@ -92,20 +91,18 @@ public Pattern FixRepeatingArguments()
                 {
                     if (e is Argument || e is Option { ArgCount: > 0 })
                     {
-                        if (e.Value == null)
+                        if (e.Value.IsNone)
                         {
-                            e.Value = new ValueObject(new ArrayList());
+                            e.Value = StringList.Empty;
                         }
-                        else if (!e.Value.IsList)
+                        else if (!e.Value.IsStringList)
                         {
-                            e.Value =
-                                new ValueObject(e.Value.ToString()
-                                                 .Split(new char[0], StringSplitOptions.RemoveEmptyEntries));
+                            e.Value = StringList.BottomTop(e.Value.ToString().Split(new char[0], StringSplitOptions.RemoveEmptyEntries));
                         }
                     }
                     if (e is Command || e is Option { ArgCount: 0 })
                     {
-                        e.Value = new ValueObject(0);
+                        e.Value = 0;
                     }
                 }
             }
diff --git a/src/DocoptNet/PatternMatcher.cs b/src/DocoptNet/PatternMatcher.cs
index 4044df8c..94ef953a 100644
--- a/src/DocoptNet/PatternMatcher.cs
+++ b/src/DocoptNet/PatternMatcher.cs
@@ -83,7 +83,7 @@ static MatchResult Match(this Pattern pattern,
                         if (left[i] is Argument { Value: { } value })
                         {
                             if (value.ToString() == command.Name)
-                                return MatchLeaf(command, i, new Command(command.Name, new ValueObject(true)));
+                                return MatchLeaf(command, i, new Command(command.Name, true));
                             break;
                         }
                     }
@@ -94,7 +94,7 @@ static MatchResult Match(this Pattern pattern,
                     for (var i = 0; i < left.Count; i++)
                     {
                         if (left[i] is Argument { Value: var value })
-                            return MatchLeaf(argument, i, new Argument(argument.Name, value));
+                            return MatchLeaf(argument, i, new Argument(argument.Name) { Value = value });
                     }
                     return new MatchResult(false, left, collected);
                 }
@@ -114,21 +114,24 @@ static MatchResult Match(this Pattern pattern,
             MatchResult MatchLeaf(LeafPattern leaf, int index, LeafPattern match)
             {
                 var left_ = left.RemoveAt(index);
-                var sameName = collected.Where(a => a.Name == leaf.Name).ToList();
-                if (leaf.Value is { IsList: true } or { IsOfTypeInt: true })
+                if (leaf is { Value: { Kind: ValueKind.StringList or ValueKind.Integer } })
                 {
-                    var increment = new ValueObject(1);
-                    if (!leaf.Value.IsOfTypeInt)
+                    var sameNames = collected.Where(a => a.Name == leaf.Name).ToList();
+                    if (sameNames.Count == 0)
                     {
-                        increment = match.Value.IsString ? new ValueObject(new [] { match.Value }) : match.Value;
+                        match.Value = leaf.Value.IsInteger ? 1
+                                    : match.Value.TryAsString(out var s) ? StringList.Empty.Push(s)
+                                    : match.Value;
                     }
-                    if (sameName.Count == 0)
+                    else
                     {
-                        match.Value = increment;
-                        return new MatchResult(true, left_, collected.Append(match));
+                        var sameName = sameNames[0];
+                        sameName.Value = sameName.Value.TryAsInteger(out var n)
+                                       ? n + 1
+                                       : ((StringList)sameName.Value).Push((string)match.Value);
+
+                        return new MatchResult(true, left_, collected);
                     }
-                    sameName[0].Value.Add(increment);
-                    return new MatchResult(true, left_, collected);
                 }
                 return new MatchResult(true, left_, collected.Append(match));
             }
diff --git a/src/DocoptNet/PublicAPI/netstandard2.1/PublicAPI.Shipped.txt b/src/DocoptNet/PublicAPI/netstandard2.1/PublicAPI.Shipped.txt
new file mode 100644
index 00000000..3a375544
--- /dev/null
+++ b/src/DocoptNet/PublicAPI/netstandard2.1/PublicAPI.Shipped.txt
@@ -0,0 +1,77 @@
+DocoptNet.ArgumentNode
+DocoptNet.ArgumentNode.ArgumentNode(string name, DocoptNet.ValueType valueType) -> void
+DocoptNet.CommandNode
+DocoptNet.CommandNode.CommandNode(string name) -> void
+DocoptNet.Docopt
+DocoptNet.Docopt.Apply(string doc) -> System.Collections.Generic.IDictionary<string, DocoptNet.ValueObject>
+DocoptNet.Docopt.Apply(string doc, DocoptNet.Tokens tokens, bool help = true, object version = null, bool optionsFirst = false, bool exit = false) -> System.Collections.Generic.IDictionary<string, DocoptNet.ValueObject>
+DocoptNet.Docopt.Apply(string doc, System.Collections.Generic.ICollection<string> argv, bool help = true, object version = null, bool optionsFirst = false, bool exit = false) -> System.Collections.Generic.IDictionary<string, DocoptNet.ValueObject>
+DocoptNet.Docopt.Docopt() -> void
+DocoptNet.Docopt.GenerateCode(string doc) -> string
+DocoptNet.Docopt.GetNodes(string doc) -> System.Collections.Generic.IEnumerable<DocoptNet.Node>
+DocoptNet.Docopt.OnPrintExit(string doc, int errorCode = 0) -> void
+DocoptNet.Docopt.PrintExit -> System.EventHandler<DocoptNet.PrintExitEventArgs>
+DocoptNet.DocoptBaseException
+DocoptNet.DocoptBaseException.DocoptBaseException() -> void
+DocoptNet.DocoptBaseException.DocoptBaseException(string message) -> void
+DocoptNet.DocoptBaseException.DocoptBaseException(string message, System.Exception inner) -> void
+DocoptNet.DocoptBaseException.DocoptBaseException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) -> void
+DocoptNet.DocoptBaseException.ErrorCode.get -> int
+DocoptNet.DocoptExitException
+DocoptNet.DocoptExitException.DocoptExitException() -> void
+DocoptNet.DocoptExitException.DocoptExitException(string message) -> void
+DocoptNet.DocoptExitException.DocoptExitException(string message, System.Exception inner) -> void
+DocoptNet.DocoptExitException.DocoptExitException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) -> void
+DocoptNet.DocoptInputErrorException
+DocoptNet.DocoptInputErrorException.DocoptInputErrorException() -> void
+DocoptNet.DocoptInputErrorException.DocoptInputErrorException(string message) -> void
+DocoptNet.DocoptInputErrorException.DocoptInputErrorException(string message, System.Exception inner) -> void
+DocoptNet.DocoptInputErrorException.DocoptInputErrorException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) -> void
+DocoptNet.DocoptLanguageErrorException
+DocoptNet.DocoptLanguageErrorException.DocoptLanguageErrorException() -> void
+DocoptNet.DocoptLanguageErrorException.DocoptLanguageErrorException(string message) -> void
+DocoptNet.DocoptLanguageErrorException.DocoptLanguageErrorException(string message, System.Exception inner) -> void
+DocoptNet.DocoptLanguageErrorException.DocoptLanguageErrorException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) -> void
+DocoptNet.Node
+DocoptNet.Node.Equals(DocoptNet.Node other) -> bool
+DocoptNet.Node.Name.get -> string
+DocoptNet.Node.Node(string name, DocoptNet.ValueType valueType) -> void
+DocoptNet.Node.ValueType.get -> DocoptNet.ValueType
+DocoptNet.OptionNode
+DocoptNet.OptionNode.OptionNode(string name, DocoptNet.ValueType valueType) -> void
+DocoptNet.PrintExitEventArgs
+DocoptNet.PrintExitEventArgs.ErrorCode.get -> int
+DocoptNet.PrintExitEventArgs.ErrorCode.set -> void
+DocoptNet.PrintExitEventArgs.Message.get -> string
+DocoptNet.PrintExitEventArgs.Message.set -> void
+DocoptNet.PrintExitEventArgs.PrintExitEventArgs(string msg, int errorCode) -> void
+DocoptNet.Tokens
+DocoptNet.Tokens.CreateException(string message) -> System.Exception
+DocoptNet.Tokens.Current() -> string
+DocoptNet.Tokens.ErrorType.get -> System.Type
+DocoptNet.Tokens.GetEnumerator() -> System.Collections.Generic.IEnumerator<string>
+DocoptNet.Tokens.Move() -> string
+DocoptNet.Tokens.ThrowsInputError.get -> bool
+DocoptNet.Tokens.Tokens(System.Collections.Generic.IEnumerable<string> source, System.Type errorType) -> void
+DocoptNet.ValueObject
+DocoptNet.ValueObject.AsInt.get -> int
+DocoptNet.ValueObject.AsList.get -> System.Collections.ArrayList
+DocoptNet.ValueObject.IsFalse.get -> bool
+DocoptNet.ValueObject.IsInt.get -> bool
+DocoptNet.ValueObject.IsList.get -> bool
+DocoptNet.ValueObject.IsNullOrEmpty.get -> bool
+DocoptNet.ValueObject.IsString.get -> bool
+DocoptNet.ValueObject.IsTrue.get -> bool
+DocoptNet.ValueObject.Value.get -> object
+DocoptNet.ValueType
+DocoptNet.ValueType.Bool = 0 -> DocoptNet.ValueType
+DocoptNet.ValueType.List = 1 -> DocoptNet.ValueType
+DocoptNet.ValueType.String = 2 -> DocoptNet.ValueType
+override DocoptNet.Node.Equals(object obj) -> bool
+override DocoptNet.Node.GetHashCode() -> int
+override DocoptNet.Node.ToString() -> string
+override DocoptNet.Tokens.ToString() -> string
+override DocoptNet.ValueObject.Equals(object obj) -> bool
+override DocoptNet.ValueObject.GetHashCode() -> int
+override DocoptNet.ValueObject.ToString() -> string
+static DocoptNet.Tokens.FromPattern(string pattern) -> DocoptNet.Tokens
diff --git a/src/DocoptNet/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt b/src/DocoptNet/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt
new file mode 100644
index 00000000..e69de29b
diff --git a/src/DocoptNet/StringList.cs b/src/DocoptNet/StringList.cs
new file mode 100644
index 00000000..44fc1624
--- /dev/null
+++ b/src/DocoptNet/StringList.cs
@@ -0,0 +1,104 @@
+#nullable enable
+
+namespace DocoptNet
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Linq;
+
+    /// <summary>
+    /// A list of strings modeled after "cons" lists and that supports value equality
+    /// based on equality of items when compared to another list.
+    /// </summary>
+
+    [DebuggerDisplay("{" + nameof(DebugDisplay) + "(),nq}")]
+    sealed class StringList : IEnumerable<string>, ICollection, IEquatable<StringList>
+    {
+        public static readonly StringList Empty = new(default!, null, 0);
+
+        readonly string _top;
+        readonly StringList? _next;
+
+        public static StringList BottomTop(params string[] items) =>
+            items.Aggregate(Empty, (stack, item) => stack.Push(item));
+
+        public static StringList TopBottom(params string[] items) =>
+            items.Reverse().Aggregate(Empty, (stack, item) => stack.Push(item));
+
+        StringList(string value, StringList next) : this(value, next, next.Count + 1) { }
+
+        StringList(string value, StringList? next, int count) =>
+            (_top, _next, Count) = (value, next, count);
+
+        public bool IsEmpty => Count == 0;
+
+        public int Count { get; }
+
+        string DebugDisplay() => Count > 1 ? $"Count = {Count}, Top = {Peek()}" : "(empty)";
+
+        public string Peek() => !IsEmpty ? _top : throw new InvalidOperationException();
+        public StringList Pop() => _next ?? Empty;
+        public StringList Push(string value) => new(value, this);
+        public StringList Reverse() => this.Aggregate(Empty, (stack, item) => stack.Push(item));
+
+        public override bool Equals(object obj) =>
+            Equals(obj as StringList);
+
+        public bool Equals(StringList? other)
+        {
+            if (ReferenceEquals(null, other))
+                return false;
+
+            if (ReferenceEquals(this, other))
+                return true;
+
+            if (Count != other.Count)
+                return false;
+
+            for (StringList a = this, b = other; !a.IsEmpty; a = a.Pop(), b = b.Pop())
+            {
+                if (a.Peek() != b.Peek())
+                    return false;
+            }
+
+            return true;
+        }
+
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                var hashCode = 0;
+                for (var current = this; !current.IsEmpty; current = current.Pop())
+                    hashCode = (hashCode * 397) ^ current.Peek().GetHashCode();
+                return hashCode;
+            }
+        }
+
+        public static bool operator ==(StringList? left, StringList? right) => Equals(left, right);
+        public static bool operator !=(StringList? left, StringList? right) => !Equals(left, right);
+
+        public IEnumerator<string> GetEnumerator()
+        {
+            for (var s = this; !s.IsEmpty; s = s.Pop())
+                yield return s._top;
+        }
+
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+        void ICollection.CopyTo(Array array, int index)
+        {
+            if (array is null) throw new ArgumentNullException(nameof(array));
+            if (array.Rank != 1) throw new ArgumentException(null, nameof(array));
+            if (index < 0 || index + Count > array.Length) throw new ArgumentOutOfRangeException(nameof(index), index, null);
+
+            foreach (var item in this)
+                array.SetValue(item, index++);
+        }
+
+        bool ICollection.IsSynchronized => false;
+        object ICollection.SyncRoot => this;
+    }
+}
diff --git a/src/DocoptNet/Value.cs b/src/DocoptNet/Value.cs
new file mode 100644
index 00000000..6167d0fd
--- /dev/null
+++ b/src/DocoptNet/Value.cs
@@ -0,0 +1,83 @@
+#nullable enable
+
+namespace DocoptNet
+{
+    using System;
+    using System.Diagnostics;
+    using System.Diagnostics.CodeAnalysis;
+
+    enum ValueKind { None, Boolean, Integer, String, StringList }
+
+    [DebuggerDisplay("{" + nameof(DebugDisplay) + "(),nq}")]
+    readonly struct Value
+    {
+        readonly int _int;     // stores: bool, int
+        readonly object? _ref; // stores: string, StringList
+
+        public static readonly Value None  = new(ValueKind.None, null);
+        public static readonly Value True  = new(ValueKind.Boolean, 1);
+        public static readonly Value False = new(ValueKind.Boolean, 0);
+
+        Value(ValueKind kind, object? value) : this(kind, 0, value) { }
+        Value(ValueKind kind, int @int, object? @ref = null) => (Kind, _int, _ref) = (kind, @int, @ref);
+
+        public ValueKind Kind { get; }
+
+        public bool IsNone       => Kind == ValueKind.None;
+        public bool IsBoolean    => Kind == ValueKind.Boolean;
+        public bool IsInteger    => Kind == ValueKind.Integer;
+        public bool IsString     => Kind == ValueKind.String;
+        public bool IsStringList => Kind == ValueKind.StringList;
+
+        public bool IsTrue  => IsBoolean && !IsFalse;
+        public bool IsFalse => IsBoolean && _int == 0;
+
+        public object? Box =>
+            Kind switch
+            {
+                ValueKind.None       => null,
+                ValueKind.Boolean    => (bool)this ? Boxed.True : Boxed.False,
+                ValueKind.Integer    => Boxed.Integer((int)this),
+                ValueKind.String     => (string)this,
+                ValueKind.StringList => (StringList)this,
+                _                    => throw new InvalidOperationException()
+            };
+
+        string DebugDisplay() => $"{Kind}: {this}";
+
+        public override string ToString() => ValueObject.Format(Box);
+
+        public static implicit operator Value(bool value) => value ? True : False;
+        public static implicit operator Value(int value) => new(ValueKind.Integer, value);
+        public static implicit operator Value(string value) => new(ValueKind.String, value);
+        public static implicit operator Value(StringList value) => new(ValueKind.StringList, value);
+
+        public bool TryAsBoolean(out bool value) { value = IsBoolean && _int != 0; return IsBoolean; }
+        public bool TryAsInteger(out int value) { value = IsInteger ? _int : default; return IsInteger; }
+        public bool TryAsString([NotNullWhen(true)]out string? value) { value = _ref is string s ? s : default; return IsString; }
+        public bool TryAsStringList([NotNullWhen(true)]out StringList? value) { value = _ref is StringList list ? list : default; return IsStringList; }
+
+        public static explicit operator bool(Value value) => value.TryAsBoolean(out var f) ? f : throw new InvalidCastException();
+        public static explicit operator int(Value value) => value.TryAsInteger(out var n) ? n : throw new InvalidCastException();
+        public static explicit operator string(Value value) => value.TryAsString(out var s) ? s : throw new InvalidCastException();
+        public static explicit operator StringList(Value value) => value.TryAsStringList(out var list) ? list : throw new InvalidCastException();
+
+        static class Boxed
+        {
+            public static readonly object True = true;
+            public static readonly object False = false;
+
+            static readonly object[] Integers;
+
+            public static object Integer(int n) => n >= 0 && n < Integers.Length ? Integers[n] : n;
+
+            static Boxed()
+            {
+                var ints = new object[5];
+                for (var i = 0; i < ints.Length; i++)
+                    ints[i] = i;
+                Integers = ints;
+            }
+        }
+    }
+}
diff --git a/src/DocoptNet/ValueObject.cs b/src/DocoptNet/ValueObject.cs
index f790f18a..264fbc05 100644
--- a/src/DocoptNet/ValueObject.cs
+++ b/src/DocoptNet/ValueObject.cs
@@ -6,13 +6,11 @@ namespace DocoptNet
 
     partial class ValueObject // TODO : IEquatable<ValueObject>
     {
-        public object Value { get; private set; }
+        public object Value { get; }
 
         internal ValueObject(object obj) =>
             Value = obj is ICollection collection ? new ArrayList(collection) : obj;
 
-        internal ValueObject() => Value = null;
-
         public bool IsNullOrEmpty => Value == null || Value.ToString().Length == 0;
         public bool IsFalse => Value as bool? == false;
         public bool IsTrue => Value as bool? == true;
@@ -23,34 +21,6 @@ internal ValueObject(object obj) =>
         public int AsInt => IsList ? 0 : Convert.ToInt32(Value);
         public ArrayList AsList => IsList ? Value as ArrayList : new ArrayList { Value };
 
-        internal void Add(ValueObject increment)
-        {
-            if (increment == null) throw new ArgumentNullException(nameof(increment));
-            if (increment.Value == null) throw new ArgumentException(nameof(increment));
-            if (Value == null) throw new InvalidOperationException();
-
-            if (increment.IsOfTypeInt)
-            {
-                if (IsList)
-                    ((ArrayList)Value).Add(increment.AsInt);
-                else
-                    Value = increment.AsInt + AsInt;
-            }
-            else
-            {
-                var list = new ArrayList();
-                if (IsList)
-                    list.AddRange(AsList);
-                else
-                    list.Add(Value);
-                if (increment.IsList)
-                    list.AddRange(increment.AsList);
-                else
-                    list.Add(increment);
-                Value = list;
-            }
-        }
-
         public override bool Equals(object obj)
         {
             return obj is ValueObject { Value: var v } other
@@ -69,8 +39,18 @@ public override int GetHashCode()
 
         public override string ToString()
         {
-            return IsList ? $"[{string.Join(", ", AsList.Cast<object>())}]"
-                 : (Value ?? string.Empty).ToString();
+            return Format(IsList ? AsList : Value);
+        }
+
+        internal static string Format(object value)
+        {
+            return value switch
+            {
+                null => string.Empty,
+                string s => s,
+                IEnumerable items => $"[{string.Join(", ", items.Cast<object>())}]",
+                _ => value.ToString()
+            };
         }
     }
 }
diff --git a/tests/DocoptNet.Tests/ApplicationResultAccumulator.cs b/tests/DocoptNet.Tests/ApplicationResultAccumulator.cs
new file mode 100644
index 00000000..fe113704
--- /dev/null
+++ b/tests/DocoptNet.Tests/ApplicationResultAccumulator.cs
@@ -0,0 +1,108 @@
+#nullable enable
+
+namespace DocoptNet.Tests
+{
+    using System.Collections.Generic;
+    using NUnit.Framework;
+
+    [TestFixture]
+    public class ApplicationResultAccumulator
+    {
+        public class ValueObjectDictionary
+        {
+            static readonly IApplicationResultAccumulator<IDictionary<string, ValueObject>> Accumulator = ApplicationResultAccumulators.ValueObjectDictionary;
+
+            [Test]
+            public void New_returns_empty_dictionary()
+            {
+                var dict = Accumulator.New();
+                Assert.That(dict, Is.Empty);
+            }
+
+            [Test]
+            public void Command_adds_entry_with_value_converted_to_object()
+            {
+                var dict = Accumulator.New();
+                dict = Accumulator.Command(dict, "command", true);
+                var value = dict["command"];
+                Assert.That(value, Is.InstanceOf<ValueObject>());
+                Assert.That(value.Value, Is.EqualTo(true));
+            }
+
+            [Test]
+            public void Argument_adds_entry_with_value_converted_to_object()
+            {
+                var dict = Accumulator.New();
+                dict = Accumulator.Argument(dict, "<argument>", "value");
+                var value = dict["<argument>"];
+                Assert.That(value, Is.InstanceOf<ValueObject>());
+                Assert.That(value.Value, Is.EqualTo("value"));
+            }
+
+            [Test]
+            public void Option_adds_entry_with_value_converted_to_object()
+            {
+                var dict = Accumulator.New();
+                dict = Accumulator.Option(dict, "--option", "value");
+                var value = dict["--option"];
+                Assert.That(value, Is.InstanceOf<ValueObject>());
+                Assert.That(value.Value, Is.EqualTo("value"));
+            }
+
+            [Test]
+            public void Error_returns_null()
+            {
+                Assert.That(Accumulator.Error(new DocoptInputErrorException()), Is.Null);
+            }
+        }
+
+        [TestFixture]
+        public class ValueDictionary
+        {
+            static readonly IApplicationResultAccumulator<IDictionary<string, Value>> Accumulator = ApplicationResultAccumulators.ValueDictionary;
+
+            [Test]
+            public void New_returns_empty_dictionary()
+            {
+                var dict = Accumulator.New();
+                Assert.That(dict, Is.Empty);
+            }
+
+            [Test]
+            public void Command_adds_entry_with_value()
+            {
+                var dict = Accumulator.New();
+                dict = Accumulator.Command(dict, "command", true);
+                var value = dict["command"];
+                Assert.That(value, Is.InstanceOf<Value>());
+                Assert.That((bool)value, Is.EqualTo(true));
+            }
+
+            [Test]
+            public void Argument_adds_entry_with_value()
+            {
+                var dict = Accumulator.New();
+                dict = Accumulator.Argument(dict, "<argument>", "value");
+                var value = dict["<argument>"];
+                Assert.That(value, Is.InstanceOf<Value>());
+                Assert.That((string)value, Is.EqualTo("value"));
+            }
+
+            [Test]
+            public void Option_adds_entry_with_value()
+            {
+                var dict = Accumulator.New();
+                dict = Accumulator.Option(dict, "--option", "value");
+                var value = dict["--option"];
+                Assert.That(value, Is.InstanceOf<Value>());
+                Assert.That((string)value, Is.EqualTo("value"));
+            }
+
+            [Test]
+            public void Error_returns_null()
+            {
+                Assert.That(Accumulator.Error(new DocoptInputErrorException()), Is.Null);
+            }
+        }
+    }
+}
diff --git a/tests/DocoptNet.Tests/ArgumentMatchTests.cs b/tests/DocoptNet.Tests/ArgumentMatchTests.cs
index c96a07e1..3d6a6b2e 100644
--- a/tests/DocoptNet.Tests/ArgumentMatchTests.cs
+++ b/tests/DocoptNet.Tests/ArgumentMatchTests.cs
@@ -10,8 +10,8 @@ public class ArgumentMatchTests
         public void Should_match_arg()
         {
             Assert.AreEqual(
-                new MatchResult(true, Leaves(), Leaves(new Argument("N", new ValueObject(9)))),
-                new Argument("N").Match(new Argument(null, new ValueObject(9)))
+                new MatchResult(true, Leaves(), Leaves(new Argument("N", 9))),
+                new Argument("N").Match(new Argument(null, 9))
                 );
         }
 
@@ -29,10 +29,10 @@ public void Should_match_arg_after_opts()
         {
             Assert.AreEqual(
                 new MatchResult(true, Leaves(new Option("-x"), new Option("-a")),
-                                Leaves(new Argument("N", new ValueObject(5)))),
+                                Leaves(new Argument("N", 5))),
                 new Argument("N").Match(new Option("-x"),
                                         new Option("-a"),
-                                        new Argument(null, new ValueObject(5)))
+                                        new Argument(null, 5))
                 );
         }
 
@@ -41,9 +41,9 @@ public void Should_match_first_arg_only()
         {
             Assert.AreEqual(
                 new MatchResult(true,
-                    Leaves(new Argument(null, new ValueObject(0))),
-                    Leaves(new Argument("N", new ValueObject(9)))),
-                new Argument("N").Match(new Argument(null, new ValueObject(9)), new Argument(null, new ValueObject(0)))
+                    Leaves(new Argument(null, 0)),
+                    Leaves(new Argument("N", 9))),
+                new Argument("N").Match(new Argument(null, 9), new Argument(null, 0))
                 );
         }
     }
diff --git a/tests/DocoptNet.Tests/ArgumentTests.cs b/tests/DocoptNet.Tests/ArgumentTests.cs
new file mode 100644
index 00000000..d0c3699c
--- /dev/null
+++ b/tests/DocoptNet.Tests/ArgumentTests.cs
@@ -0,0 +1,29 @@
+namespace DocoptNet.Tests
+{
+    using NUnit.Framework;
+
+    [TestFixture]
+    public class ArgumentTests
+    {
+        [Test]
+        public void ToString_string_value_returns_string_in_expected_format()
+        {
+            var argument = new Argument("arg", "foobar");
+            Assert.AreEqual("Argument(arg, foobar)", argument.ToString());
+        }
+
+        [Test]
+        public void ToString_null_value_returns_string_in_expected_format()
+        {
+            var argument = new Argument("arg");
+            Assert.AreEqual("Argument(arg, )", argument.ToString());
+        }
+
+        [Test]
+        public void ToString_array_value_returns_string_in_expected_format()
+        {
+            var argument = new Argument("arg", new[] { "foo", "bar", "baz" });
+            Assert.AreEqual("Argument(arg, [foo, bar, baz])", argument.ToString());
+        }
+    }
+}
diff --git a/tests/DocoptNet.Tests/CommandMatchTests.cs b/tests/DocoptNet.Tests/CommandMatchTests.cs
index df1b6637..934c38c0 100644
--- a/tests/DocoptNet.Tests/CommandMatchTests.cs
+++ b/tests/DocoptNet.Tests/CommandMatchTests.cs
@@ -12,8 +12,8 @@ public void Should_match_command()
             Assert.AreEqual(
                 new MatchResult(true,
                                 Leaves(),
-                                Leaves(new Command("c", new ValueObject(true)))),
-                new Command("c").Match(new Argument(null, new ValueObject("c")))
+                                Leaves(new Command("c", true))),
+                new Command("c").Match(new Argument(null, "c"))
                 );
         }
 
@@ -34,8 +34,8 @@ public void Should_match_command_after_options()
             Assert.AreEqual(
                 new MatchResult(true,
                                 Leaves(new Option("-x"), new Option("-a") ),
-                                Leaves(new Command("c", new ValueObject(true)) )),
-                new Command("c").Match(new Option("-x"), new Option("-a"), new Argument(null, new ValueObject("c")))
+                                Leaves(new Command("c", true) )),
+                new Command("c").Match(new Option("-x"), new Option("-a"), new Argument(null, "c"))
                 );
         }
 
@@ -45,8 +45,8 @@ public void Should_match_either_command()
             Assert.AreEqual(
                 new MatchResult(true,
                                 Leaves(),
-                                Leaves(new Command("rm", new ValueObject(true)) )),
-                new Either(new Command("add"), new Command("rm")).Match(new Argument(null, new ValueObject("rm")))
+                                Leaves(new Command("rm", true) )),
+                new Either(new Command("add"), new Command("rm")).Match(new Argument(null, "rm"))
                 );
         }
 
diff --git a/tests/DocoptNet.Tests/CommandsTests.cs b/tests/DocoptNet.Tests/CommandsTests.cs
index bef4f43e..d5fcff00 100644
--- a/tests/DocoptNet.Tests/CommandsTests.cs
+++ b/tests/DocoptNet.Tests/CommandsTests.cs
@@ -9,9 +9,9 @@ public class CommandsTests
         [Test]
         public void Required()
         {
-            var expected = new Dictionary<string, ValueObject>
+            var expected = new Dictionary<string, Value>
                 {
-                    {"add", new ValueObject(true)}
+                    {"add", true}
                 };
             var actual = new Docopt().Apply("Usage: prog add", "add");
             Assert.AreEqual(expected, actual);
@@ -20,9 +20,9 @@ public void Required()
         [Test]
         public void Optional_no_args()
         {
-            var expected = new Dictionary<string, ValueObject>
+            var expected = new Dictionary<string, Value>
                 {
-                    {"add", new ValueObject(false)}
+                    {"add", false}
                 };
             var actual = new Docopt().Apply("Usage: prog [add]", "");
             Assert.AreEqual(expected, actual);
@@ -31,9 +31,9 @@ public void Optional_no_args()
         [Test]
         public void Optional_one_arg()
         {
-            var expected = new Dictionary<string, ValueObject>
+            var expected = new Dictionary<string, Value>
                 {
-                    {"add", new ValueObject(true)}
+                    {"add", true}
                 };
             var actual = new Docopt().Apply("Usage: prog [add]", "add");
             Assert.AreEqual(expected, actual);
@@ -42,10 +42,10 @@ public void Optional_one_arg()
         [Test]
         public void Optional_either_first_specified()
         {
-            var expected = new Dictionary<string, ValueObject>
+            var expected = new Dictionary<string, Value>
                 {
-                    {"add", new ValueObject(true)},
-                    {"rm", new ValueObject(false)}
+                    {"add", true},
+                    {"rm", false}
                 };
             var actual = new Docopt().Apply("Usage: prog (add|rm)", "add");
             Assert.AreEqual(expected, actual);
@@ -54,10 +54,10 @@ public void Optional_either_first_specified()
         [Test]
         public void Optional_either_second_specified()
         {
-            var expected = new Dictionary<string, ValueObject>
+            var expected = new Dictionary<string, Value>
                 {
-                    {"add", new ValueObject(false)},
-                    {"rm", new ValueObject(true)}
+                    {"add", false},
+                    {"rm", true}
                 };
             var actual = new Docopt().Apply("Usage: prog (add|rm)", "rm");
             Assert.AreEqual(expected, actual);
@@ -66,10 +66,10 @@ public void Optional_either_second_specified()
         [Test]
         public void Required_both_specified()
         {
-            var expected = new Dictionary<string, ValueObject>
+            var expected = new Dictionary<string, Value>
                 {
-                    {"a", new ValueObject(true)},
-                    {"b", new ValueObject(true)}
+                    {"a", true},
+                    {"b", true}
                 };
             var actual = new Docopt().Apply("Usage: prog a b", "a b");
             Assert.AreEqual(expected, actual);
diff --git a/tests/DocoptNet.Tests/CountMultipleFlagsTests.cs b/tests/DocoptNet.Tests/CountMultipleFlagsTests.cs
index ff9714c1..2f1883a5 100644
--- a/tests/DocoptNet.Tests/CountMultipleFlagsTests.cs
+++ b/tests/DocoptNet.Tests/CountMultipleFlagsTests.cs
@@ -9,9 +9,9 @@ public class CountMultipleFlagsTests
         [Test]
         public void Simple_flag()
         {
-            var expected = new Dictionary<string, ValueObject>
+            var expected = new Dictionary<string, Value>
                 {
-                    {"-v", new ValueObject(true)}
+                    {"-v", true}
                 };
             var actual = new Docopt().Apply("Usage: prog [-v]", "-v");
             Assert.AreEqual(expected, actual);
@@ -20,9 +20,9 @@ public void Simple_flag()
         [Test]
         public void Flag_0()
         {
-            var expected = new Dictionary<string, ValueObject>
+            var expected = new Dictionary<string, Value>
                 {
-                    {"-v", new ValueObject(0)}
+                    {"-v", 0}
                 };
             var actual = new Docopt().Apply("Usage: prog [-vv]", "");
             Assert.AreEqual(expected, actual);
@@ -31,9 +31,9 @@ public void Flag_0()
         [Test]
         public void Flag_1()
         {
-            var expected = new Dictionary<string, ValueObject>
+            var expected = new Dictionary<string, Value>
                 {
-                    {"-v", new ValueObject(1)}
+                    {"-v", 1}
                 };
             var actual = new Docopt().Apply("Usage: prog [-vv]", "-v");
             Assert.AreEqual(expected, actual);
@@ -42,9 +42,9 @@ public void Flag_1()
         [Test]
         public void Flag_2()
         {
-            var expected = new Dictionary<string, ValueObject>
+            var expected = new Dictionary<string, Value>
                 {
-                    {"-v", new ValueObject(2)}
+                    {"-v", 2}
                 };
             var actual = new Docopt().Apply("Usage: prog [-vv]", "-vv");
             Assert.AreEqual(expected, actual);
@@ -59,9 +59,9 @@ public void Flag_too_many()
         [Test]
         public void Flag_3()
         {
-            var expected = new Dictionary<string, ValueObject>
+            var expected = new Dictionary<string, Value>
                 {
-                    {"-v", new ValueObject(3)}
+                    {"-v", 3}
                 };
             var actual = new Docopt().Apply("Usage: prog [-v | -vv | -vvv]", "-vvv");
             Assert.AreEqual(expected, actual);
@@ -70,9 +70,9 @@ public void Flag_3()
         [Test]
         public void Flag_one_or_more()
         {
-            var expected = new Dictionary<string, ValueObject>
+            var expected = new Dictionary<string, Value>
                 {
-                    {"-v", new ValueObject(6)}
+                    {"-v", 6}
                 };
             var actual = new Docopt().Apply("Usage: prog -v...", "-vvvvvv");
             Assert.AreEqual(expected, actual);
@@ -81,9 +81,9 @@ public void Flag_one_or_more()
         [Test]
         public void Flag_long_2()
         {
-            var expected = new Dictionary<string, ValueObject>
+            var expected = new Dictionary<string, Value>
                 {
-                    {"--ver", new ValueObject(2)}
+                    {"--ver", 2}
                 };
             var actual = new Docopt().Apply("Usage: prog [--ver --ver]", "--ver --ver");
             Assert.AreEqual(expected, actual);
diff --git a/tests/DocoptNet.Tests/DefaultValueForPositionalArgumentsTests.cs b/tests/DocoptNet.Tests/DefaultValueForPositionalArgumentsTests.cs
index cc2eab98..b50ed17e 100644
--- a/tests/DocoptNet.Tests/DefaultValueForPositionalArgumentsTests.cs
+++ b/tests/DocoptNet.Tests/DefaultValueForPositionalArgumentsTests.cs
@@ -9,9 +9,9 @@ public class DefaultValueForPositionalArgumentsTests
         [Test]
         public void Expect_default_value()
         {
-            var expected = new Dictionary<string, ValueObject>
+            var expected = new Dictionary<string, Value>
                 {
-                    {"--data", new ValueObject(new[] {"x"})}
+                    {"--data", StringList.TopBottom("x")}
                 };
             var actual = new Docopt().Apply("Usage: prog [--data=<data>...]\n\nOptions:\n\t-d --data=<arg>    Input data [default: x]", "");
             Assert.AreEqual(expected, actual);
@@ -20,9 +20,9 @@ public void Expect_default_value()
         [Test]
         public void Expect_default_collection()
         {
-            var expected = new Dictionary<string, ValueObject>
+            var expected = new Dictionary<string, Value>
                 {
-                    {"--data", new ValueObject(new string[] {"x", "y"})}
+                    {"--data", StringList.TopBottom("x", "y")}
                 };
             var actual = new Docopt().Apply("Usage: prog [--data=<data>...]\n\n         Options:\n\t-d --data=<arg>    Input data [default: x y]", "");
             Assert.AreEqual(expected, actual);
@@ -31,9 +31,9 @@ public void Expect_default_collection()
         [Test]
         public void Expect_one_arg()
         {
-            var expected = new Dictionary<string, ValueObject>
+            var expected = new Dictionary<string, Value>
                 {
-                    {"--data", new ValueObject(new[] {"this"})}
+                    {"--data", StringList.TopBottom("this")}
                 };
             var actual = new Docopt().Apply("Usage: prog [--data=<data>...]\n\n         Options:\n\t-d --data=<arg>    Input data [default: x y]", "--data=this");
             Assert.AreEqual(expected, actual);
diff --git a/tests/DocoptNet.Tests/DocoptTests.cs b/tests/DocoptNet.Tests/DocoptTests.cs
index 5a9796f2..531dfb57 100644
--- a/tests/DocoptNet.Tests/DocoptTests.cs
+++ b/tests/DocoptNet.Tests/DocoptTests.cs
@@ -47,10 +47,10 @@ public void Test_issue_106_exit()
         [Test]
         public void Test_issue_40_same_prefix()
         {
-            var expected = new Dictionary<string, ValueObject>
+            var expected = new Dictionary<string, Value>
                 {
-                    {"--aabb", new ValueObject(false)},
-                    {"--aa", new ValueObject(true)}
+                    {"--aabb", false},
+                    {"--aa", true}
                 };
             var actual = new Docopt().Apply("usage: prog --aabb | --aa", "--aa");
             Assert.AreEqual(expected, actual);
@@ -59,10 +59,10 @@ public void Test_issue_40_same_prefix()
         [Test]
         public void Match_arg_only()
         {
-            var expected = new Dictionary<string, ValueObject>
+            var expected = new Dictionary<string, Value>
                 {
-                    {"-v", new ValueObject(false)},
-                    {"A", new ValueObject("arg")}
+                    {"-v", false},
+                    {"A", "arg"}
                 };
             var actual = new Docopt().Apply(@"Usage: prog [-v] A
 
@@ -73,10 +73,10 @@ public void Match_arg_only()
         [Test]
         public void Match_opt_and_arg()
         {
-            var expected = new Dictionary<string, ValueObject>
+            var expected = new Dictionary<string, Value>
                 {
-                    {"-v", new ValueObject(true)},
-                    {"A", new ValueObject("arg")}
+                    {"-v", true},
+                    {"A", "arg"}
                 };
             var actual = new Docopt().Apply(@"Usage: prog [-v] A
 
@@ -98,15 +98,15 @@ prog INPUT OUTPUT
         [Test]
         public void Match_one_opt_with_arg()
         {
-            var expected = new Dictionary<string, ValueObject>
+            var expected = new Dictionary<string, Value>
                 {
-                    {"-v", new ValueObject(true)},
-                    {"-q", new ValueObject(false)},
-                    {"-r", new ValueObject(false)},
-                    {"--help", new ValueObject(false)},
-                    {"FILE", new ValueObject("file.py")},
-                    {"INPUT", null},
-                    {"OUTPUT", null}
+                    {"-v", true},
+                    {"-q", false},
+                    {"-r", false},
+                    {"--help", false},
+                    {"FILE", "file.py"},
+                    {"INPUT", default},
+                    {"OUTPUT", default}
                 };
             var actual = new Docopt().Apply(DOC, "-v file.py");
             Assert.AreEqual(expected, actual);
@@ -115,15 +115,15 @@ public void Match_one_opt_with_arg()
         [Test]
         public void Match_one_opt_only()
         {
-            var expected = new Dictionary<string, ValueObject>
+            var expected = new Dictionary<string, Value>
                 {
-                    {"-v", new ValueObject(true)},
-                    {"-q", new ValueObject(false)},
-                    {"-r", new ValueObject(false)},
-                    {"--help", new ValueObject(false)},
-                    {"FILE", null},
-                    {"INPUT", null},
-                    {"OUTPUT", null}
+                    {"-v", true},
+                    {"-q", false},
+                    {"-r", false},
+                    {"--help", false},
+                    {"FILE", default},
+                    {"INPUT", default},
+                    {"OUTPUT", default}
                 };
             var actual = new Docopt().Apply(DOC, "-v");
             Assert.AreEqual(expected, actual);
@@ -176,9 +176,9 @@ public void Display_help()
         [Test]
         public void Test_issue_59_assign_empty_string_to_long()
         {
-            var expected = new Dictionary<string, ValueObject>
+            var expected = new Dictionary<string, Value>
                 {
-                    {"--long", new ValueObject("")}
+                    {"--long", ""}
                 };
             var actual = new Docopt().Apply("usage: prog --long=<a>", "--long=");
             Assert.AreEqual(expected, actual);
@@ -187,11 +187,11 @@ public void Test_issue_59_assign_empty_string_to_long()
         [Test]
         public void Test_issue_59_assign_empty_string_to_short()
         {
-            var expected = new Dictionary<string, ValueObject>
+            var expected = new Dictionary<string, Value>
                 {
-                    {"-l", new ValueObject("")}
+                    {"-l", ""}
                 };
-            var actual = new Docopt().Apply("usage: prog -l <a>\noptions: -l <a>", new[] {"-l", ""});
+            var actual = new Docopt().Apply("usage: prog -l <a>\noptions: -l <a>", Args.Argv("-l", ""));
             Assert.AreEqual(expected, actual);
         }
 
diff --git a/tests/DocoptNet.Tests/Extensions.cs b/tests/DocoptNet.Tests/Extensions.cs
index c022568e..28e779df 100644
--- a/tests/DocoptNet.Tests/Extensions.cs
+++ b/tests/DocoptNet.Tests/Extensions.cs
@@ -10,17 +10,37 @@ public static MatchResult Match(this Pattern pattern, params LeafPattern[] left)
             return PatternMatcher.Match(pattern, left.AsReadOnly());
         }
 
-        public static IDictionary<string, ValueObject> Apply(this Docopt docopt,
-                                                             string doc, string cmdLine,
-                                                             bool help = true,
-                                                             object version = null,
-                                                             bool optionsFirst = false,
-                                                             bool exit = false)
+        public static IDictionary<string, Value> Apply(this Docopt docopt,
+                                                       string doc, string cmdLine,
+                                                       bool help = true,
+                                                       object version = null,
+                                                       bool optionsFirst = false,
+                                                       bool exit = false)
         {
+            return docopt.Apply(doc, Args.Parse(cmdLine), help, version, optionsFirst, exit);
+        }
+
+        public static IDictionary<string, Value> Apply(this Docopt docopt,
+                                                       string doc, Args argv,
+                                                       bool help = true,
+                                                       object version = null,
+                                                       bool optionsFirst = false,
+                                                       bool exit = false)
+        {
+            return docopt.Apply(doc, argv.List, ApplicationResultAccumulators.ValueDictionary, help, version, optionsFirst, exit);
+        }
+    }
+
+    sealed class Args
+    {
+        public static Args Argv(params string[] args) => new(args);
+
+        public static Args Parse(string cmdLine) =>
             // A very naive way to split a command line into individual
             // arguments but good enough for the test cases so far:
-            var argv = cmdLine.Split((char[])null, StringSplitOptions.RemoveEmptyEntries);
-            return docopt.Apply(doc, argv, help, version, optionsFirst, exit);
-        }
+            new(cmdLine.Split((char[])null, StringSplitOptions.RemoveEmptyEntries));
+
+        public Args(IList<string> list) => List = list;
+        public IList<string> List { get; }
     }
 }
diff --git a/tests/DocoptNet.Tests/LanguageAgnosticTests.cs b/tests/DocoptNet.Tests/LanguageAgnosticTests.cs
index 88f61dbc..b30fee26 100644
--- a/tests/DocoptNet.Tests/LanguageAgnosticTests.cs
+++ b/tests/DocoptNet.Tests/LanguageAgnosticTests.cs
@@ -24,21 +24,7 @@ public void Test(string doc, string cmdLine, string expected)
                 var arguments = new Docopt().Apply(doc, cmdLine);
                 var dict = new Dictionary<string, object>();
                 foreach (var argument in arguments)
-                {
-                    if (argument.Value == null)
-                        dict[argument.Key] = null;
-                    else if (argument.Value.IsList)
-                    {
-                        var l = new ArrayList();
-                        foreach (var item in argument.Value.AsList)
-                        {
-                            l.Add(item is ValueObject { Value: var v } ? v : item);
-                        }
-                        dict[argument.Key] = l;
-                    }
-                    else
-                        dict[argument.Key] = argument.Value.Value;
-                }
+                    dict[argument.Key] = argument.Value.Box;
                 actual = JsonConvert.SerializeObject(dict);
             }
             catch (Exception)
diff --git a/tests/DocoptNet.Tests/ListArgumentMatchTests.cs b/tests/DocoptNet.Tests/ListArgumentMatchTests.cs
index 894ae092..6a944d80 100644
--- a/tests/DocoptNet.Tests/ListArgumentMatchTests.cs
+++ b/tests/DocoptNet.Tests/ListArgumentMatchTests.cs
@@ -12,7 +12,7 @@ public void Should_match_required_two_args_into_a_list()
             Assert.AreEqual(
                 new MatchResult(true,
                                 Leaves(),
-                                Leaves(new Argument("N", new [] { "1", "2"}) )),
+                                Leaves(new Argument("N", new[] { "1", "2"}) )),
                 new Required(new Argument("N"), new Argument("N")).Fix().Match(new Argument(null, "1"), new Argument(null, "2"))
                 );
         }
diff --git a/tests/DocoptNet.Tests/OneOrMoreMatchTests.cs b/tests/DocoptNet.Tests/OneOrMoreMatchTests.cs
index b948c3db..d7d0db76 100644
--- a/tests/DocoptNet.Tests/OneOrMoreMatchTests.cs
+++ b/tests/DocoptNet.Tests/OneOrMoreMatchTests.cs
@@ -12,8 +12,8 @@ public void Should_match_arg()
             Assert.AreEqual(
                 new MatchResult(true,
                                 Leaves(),
-                                Leaves(new Argument("N", new ValueObject(9)))),
-                new OneOrMore(new Argument("N")).Match(new Argument(null, new ValueObject(9)))
+                                Leaves(new Argument("N", 9))),
+                new OneOrMore(new Argument("N")).Match(new Argument(null, 9))
                 );
         }
 
@@ -46,8 +46,8 @@ public void Should_match_all_args()
             Assert.AreEqual(
                 new MatchResult(true,
                                 Leaves(),
-                                Leaves(new Argument("N", new ValueObject(9)), new Argument("N", new ValueObject(8)))),
-                new OneOrMore(new Argument("N")).Match(new Argument(null, new ValueObject(9)), new Argument(null, new ValueObject(8)))
+                                Leaves(new Argument("N", 9), new Argument("N", 8))),
+                new OneOrMore(new Argument("N")).Match(new Argument(null, 9), new Argument(null, 8))
                 );
         }
 
@@ -57,8 +57,8 @@ public void Should_not_match_unknown_opt()
             Assert.AreEqual(
                 new MatchResult(true,
                                 Leaves(new Option("-x")),
-                                Leaves(new Argument("N", new ValueObject(9)), new Argument("N", new ValueObject(8)))),
-                new OneOrMore(new Argument("N")).Match(new Argument(null, new ValueObject(9)), new Option("-x"), new Argument(null, new ValueObject(8)))
+                                Leaves(new Argument("N", 9), new Argument("N", 8))),
+                new OneOrMore(new Argument("N")).Match(new Argument(null, 9), new Option("-x"), new Argument(null, 8))
                 );
         }
 
@@ -67,10 +67,10 @@ public void Should_not_match_unknown_arg()
         {
             Assert.AreEqual(
                 new MatchResult(true,
-                                Leaves(new Argument(null, new ValueObject(8))),
+                                Leaves(new Argument(null, 8)),
                                 Leaves(new Option("-a"), new Option("-a"))
                     ),
-                new OneOrMore(new Option("-a")).Match(new Option("-a"), new Argument(null, new ValueObject(8)), new Option("-a"))
+                new OneOrMore(new Option("-a")).Match(new Option("-a"), new Argument(null, 8), new Option("-a"))
                 );
         }
 
@@ -79,9 +79,9 @@ public void Should_not_match_unknown_opt_and_arg()
         {
             Assert.AreEqual(
                 new MatchResult(false,
-                                Leaves(new Argument(null, new ValueObject(98)), new Option("-x")),
+                                Leaves(new Argument(null, 98), new Option("-x")),
                                 Leaves()),
-                new OneOrMore(new Option("-a")).Match(new Argument(null, new ValueObject(98)), new Option("-x"))
+                new OneOrMore(new Option("-a")).Match(new Argument(null, 98), new Option("-x"))
                 );
         }
 
@@ -91,10 +91,10 @@ public void Should_match_all_opt_and_args()
             Assert.AreEqual(
                 new MatchResult(true,
                                 Leaves(new Option("-x")),
-                                Leaves(new Option("-a"), new Argument("N", new ValueObject(1)),
-                                       new Option("-a"), new Argument("N", new ValueObject(2)))
+                                Leaves(new Option("-a"), new Argument("N", 1),
+                                       new Option("-a"), new Argument("N", 2))
                     ),
-                new OneOrMore(new Required(new Option("-a"), new Argument("N"))).Match(new Option("-a"), new Argument(null, new ValueObject(1)), new Option("-x"), new Option("-a"), new Argument(null, new ValueObject(2)))
+                new OneOrMore(new Required(new Option("-a"), new Argument("N"))).Match(new Option("-a"), new Argument(null, 1), new Option("-x"), new Option("-a"), new Argument(null, 2))
                 );
         }
 
@@ -104,9 +104,9 @@ public void Should_match_optional_arg()
             Assert.AreEqual(
                 new MatchResult(true,
                                 Leaves(),
-                                Leaves(new Argument("N", new ValueObject(9)))
+                                Leaves(new Argument("N", 9))
                     ),
-                new OneOrMore(new Optional(new Argument("N"))).Match(new Argument(null, new ValueObject(9)))
+                new OneOrMore(new Optional(new Argument("N"))).Match(new Argument(null, 9))
                 );
         }
     }
diff --git a/tests/DocoptNet.Tests/OptionMatchTests.cs b/tests/DocoptNet.Tests/OptionMatchTests.cs
index 8eb3929d..aee8e995 100644
--- a/tests/DocoptNet.Tests/OptionMatchTests.cs
+++ b/tests/DocoptNet.Tests/OptionMatchTests.cs
@@ -9,8 +9,8 @@ public class OptionMatchTests
         [Test]
         public void Test_option_match_opt_matched()
         {
-            var expected = new MatchResult(true, Leaves(), Leaves(new Option("-a", value: new ValueObject(true))));
-            var actual = new Option("-a").Match(new Option("-a", value: new ValueObject(true)));
+            var expected = new MatchResult(true, Leaves(), Leaves(new Option("-a", value: Value.True)));
+            var actual = new Option("-a").Match(new Option("-a", value: Value.True));
             Assert.AreEqual(expected, actual);
         }
 
@@ -46,10 +46,10 @@ public void Test_option_match_same_opt_one_with_value()
         {
             var expected = new MatchResult(true,
                                            Leaves(new Option("-a")),
-                                           Leaves(new Option("-a", value: new ValueObject(true)))
+                                           Leaves(new Option("-a", value: Value.True))
                 );
             var actual =
-                new Option("-a").Match(new Option("-a", value: new ValueObject(true)), new Option("-a"));
+                new Option("-a").Match(new Option("-a", value: Value.True), new Option("-a"));
             Assert.AreEqual(expected, actual);
         }
     }
diff --git a/tests/DocoptNet.Tests/OptionalMatchTests.cs b/tests/DocoptNet.Tests/OptionalMatchTests.cs
index 6032fd76..a39fecf9 100644
--- a/tests/DocoptNet.Tests/OptionalMatchTests.cs
+++ b/tests/DocoptNet.Tests/OptionalMatchTests.cs
@@ -68,8 +68,8 @@ public void Should_match_optional_arg()
             Assert.AreEqual(
                 new MatchResult(true,
                                 Leaves(),
-                                Leaves(new Argument("N", new ValueObject(9)) )),
-                new Optional(new Argument("N")).Match(new Argument(null, new ValueObject(9)))
+                                Leaves(new Argument("N", 9) )),
+                new Optional(new Argument("N")).Match(new Argument(null, 9))
                 );
         }
 
diff --git a/tests/DocoptNet.Tests/OptionsFirstTests.cs b/tests/DocoptNet.Tests/OptionsFirstTests.cs
index 1bda31e6..1057198f 100644
--- a/tests/DocoptNet.Tests/OptionsFirstTests.cs
+++ b/tests/DocoptNet.Tests/OptionsFirstTests.cs
@@ -9,10 +9,10 @@ public class OptionsFirstTests
         [Test]
         public void Match_opt_first()
         {
-            var expected = new Dictionary<string, ValueObject>
+            var expected = new Dictionary<string, Value>
                 {
-                    {"--opt", new ValueObject(true)},
-                    {"<args>", new ValueObject(new[]{"this", "that"})}
+                    {"--opt", true},
+                    {"<args>", StringList.TopBottom("this", "that")}
                 };
             var actual = new Docopt().Apply("usage: prog [--opt] [<args>...]", "--opt this that");
             Assert.AreEqual(expected, actual);
@@ -21,10 +21,10 @@ public void Match_opt_first()
         [Test]
         public void Match_args_first()
         {
-            var expected = new Dictionary<string, ValueObject>
+            var expected = new Dictionary<string, Value>
                 {
-                    {"--opt", new ValueObject(true)},
-                    {"<args>", new ValueObject(new[]{"this", "that"})}
+                    {"--opt", true},
+                    {"<args>", StringList.TopBottom("this", "that")}
                 };
             var actual = new Docopt().Apply("usage: prog [--opt] [<args>...]", "this that --opt");
             Assert.AreEqual(expected, actual);
@@ -33,10 +33,10 @@ public void Match_args_first()
         [Test]
         public void Check_options_first()
         {
-            var expected = new Dictionary<string, ValueObject>
+            var expected = new Dictionary<string, Value>
                 {
-                    {"--opt", new ValueObject(false)},
-                    {"<args>", new ValueObject(new[]{"this", "that", "--opt"})}
+                    {"--opt", false},
+                    {"<args>", StringList.TopBottom("this", "that", "--opt")}
                 };
             var actual = new Docopt().Apply("usage: prog [--opt] [<args>...]", "this that --opt", optionsFirst: true);
             Assert.AreEqual(expected, actual);
diff --git a/tests/DocoptNet.Tests/ParseArgvTests.cs b/tests/DocoptNet.Tests/ParseArgvTests.cs
index 64ace073..b63b7652 100644
--- a/tests/DocoptNet.Tests/ParseArgvTests.cs
+++ b/tests/DocoptNet.Tests/ParseArgvTests.cs
@@ -23,7 +23,7 @@ public void Test_parse_argv_empty()
         [Test]
         public void Test_parse_argv_one_opt()
         {
-            Assert.AreEqual(new[] {new Option("-h", null, 0, new ValueObject(true))},
+            Assert.AreEqual(new[] {new Option("-h", null, 0, Value.True)},
                             Docopt.ParseArgv(TS("-h"), _options));
         }
 
@@ -32,8 +32,8 @@ public void Test_parse_argv_short_and_long()
         {
             Assert.AreEqual(new[]
                 {
-                    new Option("-h", null, 0, new ValueObject(true)),
-                    new Option("-v", "--verbose", 0, new ValueObject(true))
+                    new Option("-h", null, 0, Value.True),
+                    new Option("-v", "--verbose", 0, Value.True)
                 },
                             Docopt.ParseArgv(TS("-h --verbose"), _options));
         }
@@ -43,7 +43,7 @@ public void Test_parse_argv_opt_with_arg()
         {
             Assert.AreEqual(new[]
                 {
-                    new Option("-h", null, 0, new ValueObject(true)),
+                    new Option("-h", null, 0, Value.True),
                     new Option("-f", "--file", 1, "f.txt")
                 },
                             Docopt.ParseArgv(TS("-h --file f.txt"), _options));
@@ -55,7 +55,7 @@ public void Test_parse_argv_with_arg()
             Assert.AreEqual(
                 new Pattern[]
                     {
-                        new Option("-h", null, 0, new ValueObject(true)),
+                        new Option("-h", null, 0, Value.True),
                         new Option("-f", "--file", 1, "f.txt"),
                         new Argument(null, "arg")
                     },
@@ -68,7 +68,7 @@ public void Test_parse_argv_two_args()
             Assert.AreEqual(
                 new Pattern[]
                     {
-                        new Option("-h", null, 0, new ValueObject(true)),
+                        new Option("-h", null, 0, Value.True),
                         new Option("-f", "--file", 1, "f.txt"),
                         new Argument(null, "arg"),
                         new Argument(null, "arg2")
@@ -82,7 +82,7 @@ public void Test_parse_argv_with_double_dash()
             Assert.AreEqual(
                 new Pattern[]
                     {
-                        new Option("-h", null, 0, new ValueObject(true)),
+                        new Option("-h", null, 0, Value.True),
                         new Argument(null, "arg"),
                         new Argument(null, "--"),
                         new Argument(null, "-v")
diff --git a/tests/DocoptNet.Tests/PatternFixRepeatingArgumentsTests.cs b/tests/DocoptNet.Tests/PatternFixRepeatingArgumentsTests.cs
index 9c03fa1e..daf1243c 100644
--- a/tests/DocoptNet.Tests/PatternFixRepeatingArgumentsTests.cs
+++ b/tests/DocoptNet.Tests/PatternFixRepeatingArgumentsTests.cs
@@ -1,6 +1,6 @@
 namespace DocoptNet.Tests
 {
-    using System.Collections;
+    using System;
     using NUnit.Framework;
 
     [TestFixture]
@@ -28,7 +28,7 @@ public void Should_fix_arg()
         public void Should_fix_required_args()
         {
             Assert.AreEqual(
-                new Required(new Argument("N", new ArrayList()), new Argument("N", new ArrayList())),
+                new Required(new Argument("N", Array.Empty<string>()), new Argument("N", Array.Empty<string>())),
                 new Required(new Argument("N"), new Argument("N")).FixRepeatingArguments()
                 );
         }
@@ -37,8 +37,8 @@ public void Should_fix_required_args()
         public void Should_fix_either_args()
         {
             Assert.AreEqual(
-                new Either(new Argument("N", new ArrayList()),
-                           new OneOrMore(new Argument("N", new ArrayList()))),
+                new Either(new Argument("N", Array.Empty<string>()),
+                           new OneOrMore(new Argument("N", Array.Empty<string>()))),
                 new Either(new Argument("N"), new OneOrMore(new Argument("N"))).Fix()
                 );
         }
diff --git a/tests/DocoptNet.Tests/StringListTests.cs b/tests/DocoptNet.Tests/StringListTests.cs
new file mode 100644
index 00000000..82b2759a
--- /dev/null
+++ b/tests/DocoptNet.Tests/StringListTests.cs
@@ -0,0 +1,161 @@
+#nullable enable
+
+namespace DocoptNet.Tests
+{
+    using System;
+    using System.Collections;
+    using System.Linq;
+    using NUnit.Framework;
+
+    [TestFixture]
+    public class StringListTests
+    {
+        [Test]
+        public void TopBottom()
+        {
+            var items = new[] { "foo", "bar", "baz" };
+            var list = StringList.TopBottom(items);
+            Assert.That(list, Is.EqualTo(items));
+        }
+
+        [Test]
+        public void BottomTop()
+        {
+            var list = StringList.BottomTop("foo", "bar", "baz");
+            Assert.That(list, Is.EqualTo(new[] { "baz", "bar", "foo" }));
+        }
+
+        [Test]
+        public void Peek_returns_top_item()
+        {
+            var list = StringList.TopBottom("foo", "bar", "baz");
+            Assert.That(list.Peek(), Is.EqualTo("foo"));
+        }
+
+        [Test]
+        public void Peek_throws_when_empty()
+        {
+            Assert.Throws<InvalidOperationException>(() => StringList.Empty.Peek());
+        }
+
+        [Test]
+        public void Pop_returns_new_list_with_top_item_removed_without_modifying_original()
+        {
+            var list1 = StringList.TopBottom("foo", "bar", "baz");
+            var list2 = list1.Pop();
+            Assert.That(list2, Is.Not.SameAs(list1));
+            Assert.That(list1, Is.EqualTo(new[] { "foo", "bar", "baz" }));
+            Assert.That(list2, Is.EqualTo(new[] { "bar", "baz" }));
+        }
+
+        [Test]
+        public void Push_returns_new_list_with_item_prepended_without_modifying_original()
+        {
+            var list1 = StringList.TopBottom("bar", "baz");
+            var list2 = list1.Push("foo");
+            Assert.That(list2, Is.Not.SameAs(list1));
+            Assert.That(list1, Is.EqualTo(new[] { "bar", "baz" }));
+            Assert.That(list2, Is.EqualTo(new[] { "foo", "bar", "baz" }));
+        }
+
+        [Test]
+        public void Count_is_zero_for_empty()
+        {
+            Assert.That(StringList.Empty.Count, Is.Zero);
+        }
+
+        [Test]
+        public void Count_returns_item_count()
+        {
+            var list = StringList.TopBottom("foo", "bar", "baz");
+            Assert.That(list.Count, Is.EqualTo(3));
+        }
+
+        [Test]
+        public void Reverse_returns_new_list_with_reversed_item_order_without_modifying_original()
+        {
+            var list1 = StringList.TopBottom("foo", "bar", "baz");
+            var list2 = list1.Reverse();
+            Assert.That(list2, Is.Not.SameAs(list1));
+            Assert.That(list1, Is.EqualTo(new[] { "foo", "bar", "baz" }));
+            Assert.That(list2, Is.EqualTo(new[] { "baz", "bar", "foo" }));
+        }
+
+        [TestCase(3, 0, new[] { "foo", "bar", "baz" })]
+        [TestCase(5, 0, new[] { "foo", "bar", "baz", null, null })]
+        [TestCase(5, 1, new[] { null, "foo", "bar", "baz", null })]
+        [TestCase(5, 2, new[] { null, null, "foo", "bar", "baz" })]
+        public void CopyTo_copies_to_give_array_index(int length, int index, string[] expected)
+        {
+            ICollection list = StringList.TopBottom("foo", "bar", "baz");
+            var array = new string[length];
+            list.CopyTo(array, index);
+            Assert.That(array, Is.EqualTo(expected));
+        }
+
+        [Test]
+        public void CopyTo_throws_for_null_array()
+        {
+            ICollection list = StringList.Empty;
+            var e = Assert.Throws<ArgumentNullException>(() => list.CopyTo(null!, 0));
+            Assert.That(e.ParamName, Is.EqualTo("array"));
+        }
+
+        [Test]
+        public void CopyTo_throws_for_multi_dimensional_array()
+        {
+            ICollection list = StringList.Empty;
+            var e = Assert.Throws<ArgumentException>(() => list.CopyTo(new string[0 , 0], 0));
+            Assert.That(e.ParamName, Is.EqualTo("array"));
+        }
+
+        [Test]
+        public void CopyTo_throws_for_negative_index()
+        {
+            ICollection list = StringList.Empty;
+            var e = Assert.Throws<ArgumentOutOfRangeException>(() => list.CopyTo(Array.Empty<string>(), -1));
+            Assert.That(e.ParamName, Is.EqualTo("index"));
+        }
+
+        [TestCase(1, 0)]
+        [TestCase(2, 0)]
+        [TestCase(5, 5)]
+        [TestCase(5, 4)]
+        [TestCase(5, 3)]
+        public void CopyTo_throws_if_array_is_too_small(int length, int index)
+        {
+            ICollection list = StringList.TopBottom("foo", "bar", "baz");
+            var array = new string[length];
+            var e = Assert.Throws<ArgumentOutOfRangeException>(() => list.CopyTo(array, index));
+            Assert.That(e.ParamName, Is.EqualTo("index"));
+        }
+
+        [Test]
+        public void Equality_when_items_compare_equal()
+        {
+            var items = new[] { "foo", "bar", "baz" };
+            var list1 = StringList.TopBottom(items);
+            var list2 = StringList.TopBottom(items.Select(s => new string(s.ToCharArray())).ToArray());
+            Assert.That(list1 == list2, Is.True);
+            Assert.That(list1 != list2, Is.False);
+        }
+
+        [Test]
+        public void Equality_when_lengths_are_different()
+        {
+            var list1 = StringList.TopBottom("bar", "baz");
+            var list2 = list1.Push("foo");
+            Assert.That(list1 == list2, Is.False);
+            Assert.That(list1 != list2, Is.True);
+        }
+
+        [Test]
+        public void Equality_when_items_dont_compare_equal()
+        {
+            var list1 = StringList.TopBottom("foo", "bar", "baz");
+            var list2 = StringList.TopBottom("foo", "BAR", "baz");
+            Assert.That(list1 == list2, Is.False);
+            Assert.That(list1 != list2, Is.True);
+        }
+    }
+}
diff --git a/tests/DocoptNet.Tests/SyntaxTests.cs b/tests/DocoptNet.Tests/SyntaxTests.cs
index d53510b2..f83850d0 100644
--- a/tests/DocoptNet.Tests/SyntaxTests.cs
+++ b/tests/DocoptNet.Tests/SyntaxTests.cs
@@ -25,11 +25,11 @@ public void Missing_opening_paren()
         [Test]
         public void Detect_double_dash()
         {
-            var expected = new Dictionary<string, ValueObject>
+            var expected = new Dictionary<string, Value>
                 {
-                    {"-o", new ValueObject(false)},
-                    {"<arg>", new ValueObject("-o")},
-                    {"--", new ValueObject(true)}
+                    {"-o", false},
+                    {"<arg>", "-o"},
+                    {"--", true}
                 };
             var actual = new Docopt().Apply("usage: prog [-o] [--] <arg>\nOptions: -o", "-- -o");
             Assert.AreEqual(expected, actual);
@@ -38,11 +38,11 @@ public void Detect_double_dash()
         [Test]
         public void No_double_dash()
         {
-            var expected = new Dictionary<string, ValueObject>
+            var expected = new Dictionary<string, Value>
                 {
-                    {"-o", new ValueObject(true)},
-                    {"<arg>", new ValueObject("1")},
-                    {"--", new ValueObject(false)}
+                    {"-o", true},
+                    {"<arg>", "1"},
+                    {"--", false}
                 };
             var actual = new Docopt().Apply("usage: prog [-o] [--] <arg>\nOptions: -o", "-o 1");
             Assert.AreEqual(expected, actual);
diff --git a/tests/DocoptNet.Tests/ValueObjectTests.cs b/tests/DocoptNet.Tests/ValueObjectTests.cs
index ec486782..f642922f 100644
--- a/tests/DocoptNet.Tests/ValueObjectTests.cs
+++ b/tests/DocoptNet.Tests/ValueObjectTests.cs
@@ -290,5 +290,27 @@ public void AsList_string_evaluates_to_single_element_collection()
             var systemUnderTest = new ValueObject(expected);
             CollectionAssert.AreEqual(new [] { expected }, systemUnderTest.AsList, "AsList should evalute to a collection containing only the wrapped object.");
         }
+
+        [Test]
+        public void ToString_string_returns_string()
+        {
+            const string expected = "foobar";
+            var systemUnderTest = new ValueObject(expected);
+            Assert.AreEqual(expected, systemUnderTest.ToString());
+        }
+
+        [Test]
+        public void ToString_null_returns_empty()
+        {
+            var systemUnderTest = new ValueObject(null);
+            Assert.AreEqual(string.Empty, systemUnderTest.ToString());
+        }
+
+        [Test]
+        public void ToString_array_returns_bracketed_csv()
+        {
+            var systemUnderTest = new ValueObject(new ArrayList { "foo", "bar", "baz" });
+            Assert.AreEqual("[foo, bar, baz]", systemUnderTest.ToString());
+        }
     }
 }
diff --git a/tests/DocoptNet.Tests/ValueTests.cs b/tests/DocoptNet.Tests/ValueTests.cs
new file mode 100644
index 00000000..eed86b1e
--- /dev/null
+++ b/tests/DocoptNet.Tests/ValueTests.cs
@@ -0,0 +1,716 @@
+#nullable enable
+
+namespace DocoptNet.Tests
+{
+    using System;
+    using System.Globalization;
+    using NUnit.Framework;
+
+    [TestFixture]
+    public class ValueTests
+    {
+        [Test]
+        public void Default_value_is_none()
+        {
+            var value = default(Value);
+            Assert.That(value.Kind, Is.EqualTo(ValueKind.None));
+        }
+
+        [TestFixture]
+        public class None
+        {
+            static Value Value => Value.None;
+
+            [Test]
+            public void Kind_returns_None()
+            {
+                Assert.That(Value.Kind, Is.EqualTo(ValueKind.None));
+            }
+
+            [Test]
+            public void IsNone_returns_true()
+            {
+                Assert.That(Value.IsNone, Is.True);
+            }
+
+            [Test]
+            public void IsBoolean_returns_false()
+            {
+                Assert.That(Value.IsBoolean, Is.False);
+            }
+
+            [Test]
+            public void IsTrue_returns_false()
+            {
+                Assert.That(Value.IsTrue, Is.False);
+            }
+
+            [Test]
+            public void IsFalse_returns_false()
+            {
+                Assert.That(Value.IsFalse, Is.False);
+            }
+
+            [Test]
+            public void IsInteger_returns_false()
+            {
+                Assert.That(Value.IsInteger, Is.False);
+            }
+
+            [Test]
+            public void IsString_returns_false()
+            {
+                Assert.That(Value.IsString, Is.False);
+            }
+
+            [Test]
+            public void IsStringList_returns_false()
+            {
+                Assert.That(Value.IsStringList, Is.False);
+            }
+
+            [Test]
+            public void ToString_returns_empty()
+            {
+                Assert.That(Value.ToString(), Is.Empty);
+            }
+
+            [Test]
+            public void Box_returns_null()
+            {
+                Assert.That(Value.Box, Is.Null);
+            }
+
+            [Test]
+            public void TryAsBoolean_returns_false()
+            {
+                Assert.That(Value.TryAsBoolean(out _), Is.False);
+            }
+
+            [Test]
+            public void TryAsInteger_returns_false()
+            {
+                Assert.That(Value.TryAsInteger(out _), Is.False);
+            }
+
+            [Test]
+            public void TryAsString_returns_false()
+            {
+                Assert.That(Value.TryAsString(out _), Is.False);
+            }
+
+            [Test]
+            public void TryAsStringList_returns_false()
+            {
+                Assert.That(Value.TryAsStringList(out _), Is.False);
+            }
+
+            [Test]
+            public void Boolean_cast_throws()
+            {
+                Assert.Throws<InvalidCastException>(() => _ = (bool)Value);
+            }
+
+            [Test]
+            public void Integer_cast_throws()
+            {
+                Assert.Throws<InvalidCastException>(() => _ = (int)Value);
+            }
+
+            [Test]
+            public void String_cast_throws()
+            {
+                Assert.Throws<InvalidCastException>(() => _ = (string)Value);
+            }
+
+            [Test]
+            public void StringList_cast_throws()
+            {
+                Assert.Throws<InvalidCastException>(() => _ = (DocoptNet.StringList)Value);
+            }
+        }
+
+        [TestFixture]
+        public class True
+        {
+            static Value Value => true;
+
+            [Test]
+            public void Kind_returns_Boolean()
+            {
+                Assert.That(Value.Kind, Is.EqualTo(ValueKind.Boolean));
+            }
+
+            [Test]
+            public void IsNone_returns_true()
+            {
+                Assert.That(Value.IsNone, Is.False);
+            }
+
+            [Test]
+            public void IsBoolean_returns_true()
+            {
+                Assert.That(Value.IsBoolean, Is.True);
+            }
+
+            [Test]
+            public void IsTrue_returns_true()
+            {
+                Assert.That(Value.IsTrue, Is.True);
+            }
+
+            [Test]
+            public void IsFalse_returns_false()
+            {
+                Assert.That(Value.IsFalse, Is.False);
+            }
+
+            [Test]
+            public void IsInteger_returns_false()
+            {
+                Assert.That(Value.IsInteger, Is.False);
+            }
+
+            [Test]
+            public void IsString_returns_false()
+            {
+                Assert.That(Value.IsString, Is.False);
+            }
+
+            [Test]
+            public void IsStringList_returns_false()
+            {
+                Assert.That(Value.IsStringList, Is.False);
+            }
+
+            [Test]
+            public void ToString_returns_string_representation()
+            {
+                Assert.That(Value.ToString(), Is.EqualTo("True"));
+            }
+
+            [Test]
+            public void Box_returns_true()
+            {
+                Assert.That(Value.Box, Is.True);
+            }
+
+            [Test]
+            public void TryAsBoolean_returns_true_with_output_true()
+            {
+                var result = Value.TryAsBoolean(out var value);
+                Assert.That(result, Is.True);
+                Assert.That(value, Is.True);
+            }
+
+            [Test]
+            public void TryAsInteger_returns_false()
+            {
+                Assert.That(Value.TryAsInteger(out _), Is.False);
+            }
+
+            [Test]
+            public void TryAsString_returns_false()
+            {
+                Assert.That(Value.TryAsString(out _), Is.False);
+            }
+
+            [Test]
+            public void TryAsStringList_returns_false()
+            {
+                Assert.That(Value.TryAsStringList(out _), Is.False);
+            }
+
+            [Test]
+            public void Boolean_cast_returns_true()
+            {
+                Assert.That((bool)Value, Is.True);
+            }
+
+            [Test]
+            public void Integer_cast_throws()
+            {
+                Assert.Throws<InvalidCastException>(() => _ = (int)Value);
+            }
+
+            [Test]
+            public void String_cast_throws()
+            {
+                Assert.Throws<InvalidCastException>(() => _ = (string)Value);
+            }
+
+            [Test]
+            public void StringList_cast_throws()
+            {
+                Assert.Throws<InvalidCastException>(() => _ = (DocoptNet.StringList)Value);
+            }
+        }
+
+        [TestFixture]
+        public class False
+        {
+            static Value Value => false;
+
+            [Test]
+            public void Kind_returns_Boolean()
+            {
+                Assert.That(Value.Kind, Is.EqualTo(ValueKind.Boolean));
+            }
+
+            [Test]
+            public void IsNone_returns_true()
+            {
+                Assert.That(Value.IsNone, Is.False);
+            }
+
+            [Test]
+            public void IsBoolean_returns_true()
+            {
+                Assert.That(Value.IsBoolean, Is.True);
+            }
+
+            [Test]
+            public void IsTrue_returns_false()
+            {
+                Assert.That(Value.IsTrue, Is.False);
+            }
+
+            [Test]
+            public void IsFalse_returns_true()
+            {
+                Assert.That(Value.IsFalse, Is.True);
+            }
+
+            [Test]
+            public void IsInteger_returns_false()
+            {
+                Assert.That(Value.IsInteger, Is.False);
+            }
+
+            [Test]
+            public void IsString_returns_false()
+            {
+                Assert.That(Value.IsString, Is.False);
+            }
+
+            [Test]
+            public void IsStringList_returns_false()
+            {
+                Assert.That(Value.IsStringList, Is.False);
+            }
+
+            [Test]
+            public void ToString_returns_string_representation()
+            {
+                Assert.That(Value.ToString(), Is.EqualTo("False"));
+            }
+
+            [Test]
+            public void Box_returns_false()
+            {
+                Assert.That(Value.Box, Is.False);
+            }
+
+            [Test]
+            public void TryAsBoolean_returns_true_with_output_false()
+            {
+                var result = Value.TryAsBoolean(out var value);
+                Assert.That(result, Is.True);
+                Assert.That(value, Is.False);
+            }
+
+            [Test]
+            public void TryAsInteger_returns_false()
+            {
+                Assert.That(Value.TryAsInteger(out _), Is.False);
+            }
+
+            [Test]
+            public void TryAsString_returns_false()
+            {
+                Assert.That(Value.TryAsString(out _), Is.False);
+            }
+
+            [Test]
+            public void TryAsStringList_returns_false()
+            {
+                Assert.That(Value.TryAsStringList(out _), Is.False);
+            }
+
+            [Test]
+            public void Boolean_cast_returns_false()
+            {
+                Assert.That((bool)Value, Is.False);
+            }
+
+            [Test]
+            public void Integer_cast_throws()
+            {
+                Assert.Throws<InvalidCastException>(() => _ = (int)Value);
+            }
+
+            [Test]
+            public void String_cast_throws()
+            {
+                Assert.Throws<InvalidCastException>(() => _ = (string)Value);
+            }
+
+            [Test]
+            public void StringList_cast_throws()
+            {
+                Assert.Throws<InvalidCastException>(() => _ = (DocoptNet.StringList)Value);
+            }
+        }
+
+        [TestFixture]
+        public class Integer
+        {
+            const int UnderlyingValue = 42;
+            static Value Value => UnderlyingValue;
+
+            [Test]
+            public void Kind_returns_Integer()
+            {
+                Assert.That(Value.Kind, Is.EqualTo(ValueKind.Integer));
+            }
+
+            [Test]
+            public void IsNone_returns_true()
+            {
+                Assert.That(Value.IsNone, Is.False);
+            }
+
+            [Test]
+            public void IsBoolean_returns_false()
+            {
+                Assert.That(Value.IsBoolean, Is.False);
+            }
+
+            [Test]
+            public void IsTrue_returns_false()
+            {
+                Assert.That(Value.IsTrue, Is.False);
+            }
+
+            [Test]
+            public void IsFalse_returns_false()
+            {
+                Assert.That(Value.IsFalse, Is.False);
+            }
+
+            [Test]
+            public void IsInteger_returns_true()
+            {
+                Assert.That(Value.IsInteger, Is.True);
+            }
+
+            [Test]
+            public void IsString_returns_false()
+            {
+                Assert.That(Value.IsString, Is.False);
+            }
+
+            [Test]
+            public void IsStringList_returns_false()
+            {
+                Assert.That(Value.IsStringList, Is.False);
+            }
+
+            [Test]
+            public void ToString_returns_string_representation()
+            {
+                Assert.That(Value.ToString(), Is.EqualTo(UnderlyingValue.ToString(CultureInfo.InvariantCulture)));
+            }
+
+            [Test]
+            public void Box_returns_underlying_value()
+            {
+                Assert.That(Value.Box, Is.EqualTo(UnderlyingValue));
+            }
+
+            [Test]
+            public void TryAsBoolean_returns_true_with_output_false()
+            {
+                Assert.That(Value.TryAsBoolean(out _), Is.False);
+            }
+
+            [Test]
+            public void TryAsInteger_returns_true_with_output_as_underlying_value()
+            {
+                var result = Value.TryAsInteger(out var value);
+                Assert.That(result, Is.True);
+                Assert.That(value, Is.EqualTo(UnderlyingValue));
+            }
+
+            [Test]
+            public void TryAsString_returns_false()
+            {
+                Assert.That(Value.TryAsString(out _), Is.False);
+            }
+
+            [Test]
+            public void TryAsStringList_returns_false()
+            {
+                Assert.That(Value.TryAsStringList(out _), Is.False);
+            }
+
+            [Test]
+            public void Boolean_cast_throws()
+            {
+                Assert.Throws<InvalidCastException>(() => _ = (bool)Value);
+            }
+
+            [Test]
+            public void Integer_cast_returns_underlying_value()
+            {
+                Assert.That((int)Value, Is.EqualTo(UnderlyingValue));
+            }
+
+            [Test]
+            public void String_cast_throws()
+            {
+                Assert.Throws<InvalidCastException>(() => _ = (string)Value);
+            }
+
+            [Test]
+            public void StringList_cast_throws()
+            {
+                Assert.Throws<InvalidCastException>(() => _ = (DocoptNet.StringList)Value);
+            }
+        }
+
+        [TestFixture]
+        public class String
+        {
+            const string UnderlyingValue = "foobar";
+            static Value Value => UnderlyingValue;
+
+            [Test]
+            public void Kind_returns_String()
+            {
+                Assert.That(Value.Kind, Is.EqualTo(ValueKind.String));
+            }
+
+            [Test]
+            public void IsNone_returns_true()
+            {
+                Assert.That(Value.IsNone, Is.False);
+            }
+
+            [Test]
+            public void IsBoolean_returns_false()
+            {
+                Assert.That(Value.IsBoolean, Is.False);
+            }
+
+            [Test]
+            public void IsTrue_returns_false()
+            {
+                Assert.That(Value.IsTrue, Is.False);
+            }
+
+            [Test]
+            public void IsFalse_returns_false()
+            {
+                Assert.That(Value.IsFalse, Is.False);
+            }
+
+            [Test]
+            public void IsInteger_returns_false()
+            {
+                Assert.That(Value.IsInteger, Is.False);
+            }
+
+            [Test]
+            public void IsString_returns_true()
+            {
+                Assert.That(Value.IsString, Is.True);
+            }
+
+            [Test]
+            public void IsStringList_returns_false()
+            {
+                Assert.That(Value.IsStringList, Is.False);
+            }
+
+            [Test]
+            public void ToString_returns_string_representation()
+            {
+                Assert.That(Value.ToString(), Is.EqualTo(UnderlyingValue));
+            }
+
+            [Test]
+            public void Box_returns_underlying_value()
+            {
+                Assert.That(Value.Box, Is.EqualTo(UnderlyingValue));
+            }
+
+            [Test]
+            public void TryAsBoolean_returns_true_with_output_false()
+            {
+                Assert.That(Value.TryAsBoolean(out _), Is.False);
+            }
+
+            [Test]
+            public void TryAsInteger_returns_false()
+            {
+                Assert.That(Value.TryAsInteger(out _), Is.False);
+            }
+
+            [Test]
+            public void TryAsString_returns_true_with_output_as_underlying_value()
+            {
+                var result = Value.TryAsString(out var value);
+                Assert.That(result, Is.True);
+                Assert.That(value, Is.EqualTo(UnderlyingValue));
+            }
+
+            [Test]
+            public void TryAsStringList_returns_false()
+            {
+                Assert.That(Value.TryAsStringList(out _), Is.False);
+            }
+
+            [Test]
+            public void Boolean_cast_throws()
+            {
+                Assert.Throws<InvalidCastException>(() => _ = (bool)Value);
+            }
+
+            [Test]
+            public void Integer_cast_throws()
+            {
+                Assert.Throws<InvalidCastException>(() => _ = (int)Value);
+            }
+
+            [Test]
+            public void String_cast_throws()
+            {
+                Assert.That((string)Value, Is.EqualTo(UnderlyingValue));
+            }
+
+            [Test]
+            public void StringList_cast_throws()
+            {
+                Assert.Throws<InvalidCastException>(() => _ = (DocoptNet.StringList)Value);
+            }
+        }
+
+        public class StringList
+        {
+            static readonly DocoptNet.StringList UnderlyingValue = DocoptNet.StringList.TopBottom("foo", "bar", "baz");
+
+            static Value Value => UnderlyingValue;
+
+            [Test]
+            public void Kind_returns_String()
+            {
+                Assert.That(Value.Kind, Is.EqualTo(ValueKind.StringList));
+            }
+
+            [Test]
+            public void IsNone_returns_true()
+            {
+                Assert.That(Value.IsNone, Is.False);
+            }
+
+            [Test]
+            public void IsBoolean_returns_false()
+            {
+                Assert.That(Value.IsBoolean, Is.False);
+            }
+
+            [Test]
+            public void IsTrue_returns_false()
+            {
+                Assert.That(Value.IsTrue, Is.False);
+            }
+
+            [Test]
+            public void IsFalse_returns_false()
+            {
+                Assert.That(Value.IsFalse, Is.False);
+            }
+
+            [Test]
+            public void IsInteger_returns_false()
+            {
+                Assert.That(Value.IsInteger, Is.False);
+            }
+
+            [Test]
+            public void IsString_returns_false()
+            {
+                Assert.That(Value.IsString, Is.False);
+            }
+
+            [Test]
+            public void IsStringList_returns_true()
+            {
+                Assert.That(Value.IsStringList, Is.True);
+            }
+
+            [Test]
+            public void ToString_returns_string_representation()
+            {
+                Assert.That(Value.ToString(), Is.EqualTo("[foo, bar, baz]"));
+            }
+
+            [Test]
+            public void Box_returns_underlying_value()
+            {
+                Assert.That(Value.Box, Is.EqualTo(UnderlyingValue));
+            }
+
+            [Test]
+            public void TryAsBoolean_returns_true_with_output_false()
+            {
+                Assert.That(Value.TryAsBoolean(out _), Is.False);
+            }
+
+            [Test]
+            public void TryAsInteger_returns_false()
+            {
+                Assert.That(Value.TryAsInteger(out _), Is.False);
+            }
+
+            [Test]
+            public void TryAsString_returns_false()
+            {
+                Assert.That(Value.TryAsString(out _), Is.False);
+            }
+
+            [Test]
+            public void TryAsStringList_returns_true_with_output_as_underlying_value()
+            {
+                var result = Value.TryAsStringList(out var value);
+                Assert.That(result, Is.True);
+                Assert.That(value, Is.SameAs(UnderlyingValue));
+            }
+
+            [Test]
+            public void Boolean_cast_throws()
+            {
+                Assert.Throws<InvalidCastException>(() => _ = (bool)Value);
+            }
+
+            [Test]
+            public void Integer_cast_throws()
+            {
+                Assert.Throws<InvalidCastException>(() => _ = (int)Value);
+            }
+
+            [Test]
+            public void String_cast_throws()
+            {
+                Assert.Throws<InvalidCastException>(() => _ = (string)Value);
+            }
+
+            [Test]
+            public void StringList_cast_returns_underlying_value()
+            {
+                Assert.That((DocoptNet.StringList)Value, Is.SameAs(UnderlyingValue));
+            }
+        }
+    }
+}