diff --git a/src/CommandLine/Core/InstanceBuilder.cs b/src/CommandLine/Core/InstanceBuilder.cs
index fd9ac4d7..01597ac4 100644
--- a/src/CommandLine/Core/InstanceBuilder.cs
+++ b/src/CommandLine/Core/InstanceBuilder.cs
@@ -28,13 +28,15 @@ public static ParserResult<T> Build<T>(
             var typeInfo = factory.MapValueOrDefault(f => f().GetType(), typeof(T));
 
             var specProps = typeInfo.GetSpecifications(pi => SpecificationProperty.Create(
-                    Specification.FromProperty(pi), pi, Maybe.Nothing<object>()));
+                    Specification.FromProperty(pi), pi, Maybe.Nothing<object>()))
+                .Memorize();
 
             var specs = from pt in specProps select pt.Specification;
 
             var optionSpecs = specs
                 .ThrowingValidate(SpecificationGuards.Lookup)
-                .OfType<OptionSpecification>();
+                .OfType<OptionSpecification>()
+                .Memorize();
 
             Func<T> makeDefault = () =>
                 typeof(T).IsMutable()
@@ -45,18 +47,19 @@ public static ParserResult<T> Build<T>(
             Func<IEnumerable<Error>, ParserResult<T>> notParsed =
                 errs => new NotParsed<T>(makeDefault().GetType().ToTypeInfo(), errs);
 
+            var argumentsList = arguments.Memorize();
             Func<ParserResult<T>> buildUp = () =>
             {
-                var tokenizerResult = tokenizer(arguments, optionSpecs);
+                var tokenizerResult = tokenizer(argumentsList, optionSpecs);
 
-                var tokens = tokenizerResult.SucceededWith();
+                var tokens = tokenizerResult.SucceededWith().Memorize();
 
                 var partitions = TokenPartitioner.Partition(
                     tokens,
                     name => TypeLookup.FindTypeDescriptorAndSibling(name, optionSpecs, nameComparer));
-                var optionsPartition = partitions.Item1;
-                var valuesPartition = partitions.Item2;
-                var errorsPartition = partitions.Item3;
+                var optionsPartition = partitions.Item1.Memorize();
+                var valuesPartition = partitions.Item2.Memorize();
+                var errorsPartition = partitions.Item3.Memorize();
 
                 var optionSpecPropsResult =
                     OptionMapper.MapValues(
@@ -68,7 +71,7 @@ public static ParserResult<T> Build<T>(
                 var valueSpecPropsResult =
                     ValueMapper.MapValues(
                         (from pt in specProps where pt.Specification.IsValue() orderby ((ValueSpecification)pt.Specification).Index select pt),
-                        valuesPartition,
+                        valuesPartition,    
                         (vals, type, isScalar) => TypeConverter.ChangeType(vals, type, isScalar, parsingCulture, ignoreValueCase));
 
                 var missingValueErrors = from token in errorsPartition
@@ -78,7 +81,7 @@ public static ParserResult<T> Build<T>(
                                 .FromOptionSpecification());
 
                 var specPropsWithValue =
-                    optionSpecPropsResult.SucceededWith().Concat(valueSpecPropsResult.SucceededWith());
+                    optionSpecPropsResult.SucceededWith().Concat(valueSpecPropsResult.SucceededWith()).Memorize();
 
                 var setPropertyErrors = new List<Error>();                
 
@@ -130,11 +133,13 @@ join sp in specPropsWithValue on prms.Name.ToLower() equals sp.Property.Name.ToL
                 return allErrors.Except(warnings).ToParserResult(instance);
             };
 
-            var preprocessorErrors = arguments.Any()
-                ? arguments.Preprocess(PreprocessorGuards.Lookup(nameComparer))
-                : Enumerable.Empty<Error>();
+            var preprocessorErrors = (
+                    argumentsList.Any()
+                    ? argumentsList.Preprocess(PreprocessorGuards.Lookup(nameComparer))
+                    : Enumerable.Empty<Error>()
+                ).Memorize();
 
-            var result = arguments.Any()
+            var result = argumentsList.Any()
                 ? preprocessorErrors.Any()
                     ? notParsed(preprocessorErrors)
                     : buildUp()
diff --git a/src/CommandLine/Core/OptionMapper.cs b/src/CommandLine/Core/OptionMapper.cs
index 0d89b134..49f4889c 100644
--- a/src/CommandLine/Core/OptionMapper.cs
+++ b/src/CommandLine/Core/OptionMapper.cs
@@ -43,7 +43,7 @@ select Tuple.Create(
                                                 ((OptionSpecification)pt.Specification).FromOptionSpecification()))))
                             : Tuple.Create(pt, Maybe.Nothing<Error>());
                     }
-                );
+                ).Memorize();
             return Result.Succeed(
                 sequencesAndErrors.Select(se => se.Item1),
                 sequencesAndErrors.Select(se => se.Item2).OfType<Just<Error>>().Select(se => se.Value));
diff --git a/src/CommandLine/Core/TokenPartitioner.cs b/src/CommandLine/Core/TokenPartitioner.cs
index ebe6c0ca..cc1d8c26 100644
--- a/src/CommandLine/Core/TokenPartitioner.cs
+++ b/src/CommandLine/Core/TokenPartitioner.cs
@@ -11,22 +11,20 @@ namespace CommandLine.Core
     static class TokenPartitioner
     {
         public static
-            Tuple<
-                IEnumerable<KeyValuePair<string, IEnumerable<string>>>, // options
-                IEnumerable<string>,                                    // values
-                IEnumerable<Token>                                      // errors
-            > Partition(
+            Tuple<IEnumerable<KeyValuePair<string, IEnumerable<string>>>, IEnumerable<string>, IEnumerable<Token>> Partition(
                 IEnumerable<Token> tokens,
                 Func<string, Maybe<TypeDescriptor>> typeLookup)
         {
+            IEqualityComparer<Token> tokenComparer = ReferenceEqualityComparer.Default;
+
             var tokenList = tokens.Memorize();
-            var switches = Switch.Partition(tokenList, typeLookup).Memorize();
-            var scalars = Scalar.Partition(tokenList, typeLookup).Memorize();
-            var sequences = Sequence.Partition(tokenList, typeLookup).Memorize();
+            var switches = new HashSet<Token>(Switch.Partition(tokenList, typeLookup), tokenComparer);
+            var scalars = new HashSet<Token>(Scalar.Partition(tokenList, typeLookup), tokenComparer);
+            var sequences = new HashSet<Token>(Sequence.Partition(tokenList, typeLookup), tokenComparer);
             var nonOptions = tokenList
-                .Where(t => !switches.Contains(t, ReferenceEqualityComparer.Default))
-                .Where(t => !scalars.Contains(t, ReferenceEqualityComparer.Default))
-                .Where(t => !sequences.Contains(t, ReferenceEqualityComparer.Default)).Memorize();
+                .Where(t => !switches.Contains(t))
+                .Where(t => !scalars.Contains(t))
+                .Where(t => !sequences.Contains(t)).Memorize();
             var values = nonOptions.Where(v => v.IsValue()).Memorize();
             var errors = nonOptions.Except(values, (IEqualityComparer<Token>)ReferenceEqualityComparer.Default).Memorize();
 
diff --git a/src/CommandLine/Core/Tokenizer.cs b/src/CommandLine/Core/Tokenizer.cs
index e0e09fd3..fb241579 100644
--- a/src/CommandLine/Core/Tokenizer.cs
+++ b/src/CommandLine/Core/Tokenizer.cs
@@ -36,7 +36,7 @@ public static Result<IEnumerable<Token>, Error> Tokenize(
                           select token)
                             .Memorize();
 
-            var normalized = normalize(tokens);
+            var normalized = normalize(tokens).Memorize();
 
             var unkTokens = (from t in normalized where t.IsName() && nameLookup(t.Text) == NameLookupResult.NoOptionFound select t).Memorize();
 
@@ -60,12 +60,12 @@ public static Result<IEnumerable<Token>, Error> ExplodeOptionList(
             Result<IEnumerable<Token>, Error> tokenizerResult,
             Func<string, Maybe<char>> optionSequenceWithSeparatorLookup)
         {
-            var tokens = tokenizerResult.SucceededWith();
+            var tokens = tokenizerResult.SucceededWith().Memorize();
 
             var replaces = tokens.Select((t, i) =>
                 optionSequenceWithSeparatorLookup(t.Text)
                     .MapValueOrDefault(sep => Tuple.Create(i + 1, sep),
-                        Tuple.Create(-1, '\0'))).SkipWhile(x => x.Item1 < 0);
+                        Tuple.Create(-1, '\0'))).SkipWhile(x => x.Item1 < 0).Memorize();
 
             var exploded = tokens.Select((t, i) =>
                         replaces.FirstOrDefault(x => x.Item1 == i).ToMaybe()