Introduce the Results<TResult1, TResult2, TResultN> union types (#40986)

Fixes #40672

AspNetCore.sln

@@ -1694,6 +1694,8 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "BuildAfterTargetingPack", "
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "BuildAfterTargetingPack", "src\BuildAfterTargetingPack\BuildAfterTargetingPack.csproj", "{8FED7E65-A7DD-4F13-8980-BF03E77B6C85}"
 EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ResultsOfTGenerator", "src\Http\Http.Results\tools\ResultsOfTGenerator\ResultsOfTGenerator.csproj", "{9716D0D0-2251-44DD-8596-67D253EEF41C}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -10135,6 +10137,22 @@ Global
 		{8FED7E65-A7DD-4F13-8980-BF03E77B6C85}.Release|x64.Build.0 = Release|Any CPU
 		{8FED7E65-A7DD-4F13-8980-BF03E77B6C85}.Release|x86.ActiveCfg = Release|Any CPU
 		{8FED7E65-A7DD-4F13-8980-BF03E77B6C85}.Release|x86.Build.0 = Release|Any CPU
+		{9716D0D0-2251-44DD-8596-67D253EEF41C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{9716D0D0-2251-44DD-8596-67D253EEF41C}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{9716D0D0-2251-44DD-8596-67D253EEF41C}.Debug|arm64.ActiveCfg = Debug|Any CPU
+		{9716D0D0-2251-44DD-8596-67D253EEF41C}.Debug|arm64.Build.0 = Debug|Any CPU
+		{9716D0D0-2251-44DD-8596-67D253EEF41C}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{9716D0D0-2251-44DD-8596-67D253EEF41C}.Debug|x64.Build.0 = Debug|Any CPU
+		{9716D0D0-2251-44DD-8596-67D253EEF41C}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{9716D0D0-2251-44DD-8596-67D253EEF41C}.Debug|x86.Build.0 = Debug|Any CPU
+		{9716D0D0-2251-44DD-8596-67D253EEF41C}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{9716D0D0-2251-44DD-8596-67D253EEF41C}.Release|Any CPU.Build.0 = Release|Any CPU
+		{9716D0D0-2251-44DD-8596-67D253EEF41C}.Release|arm64.ActiveCfg = Release|Any CPU
+		{9716D0D0-2251-44DD-8596-67D253EEF41C}.Release|arm64.Build.0 = Release|Any CPU
+		{9716D0D0-2251-44DD-8596-67D253EEF41C}.Release|x64.ActiveCfg = Release|Any CPU
+		{9716D0D0-2251-44DD-8596-67D253EEF41C}.Release|x64.Build.0 = Release|Any CPU
+		{9716D0D0-2251-44DD-8596-67D253EEF41C}.Release|x86.ActiveCfg = Release|Any CPU
+		{9716D0D0-2251-44DD-8596-67D253EEF41C}.Release|x86.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -10974,6 +10992,7 @@ Global
 		{B7DAA48B-8E5E-4A5D-9FEB-E6D49AE76A04} = {41BB7BA4-AC08-4E9A-83EA-6D587A5B951C}
 		{489020F2-80D9-4468-A5D3-07E785837A5D} = {017429CC-C5FB-48B4-9C46-034E29EE2F06}
 		{8FED7E65-A7DD-4F13-8980-BF03E77B6C85} = {489020F2-80D9-4468-A5D3-07E785837A5D}
+		{9716D0D0-2251-44DD-8596-67D253EEF41C} = {323C3EB6-1D15-4B3D-918D-699D7F64DED9}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {3E8720B3-DBDD-498C-B383-2CC32A054E8F}

src/Http/Http.Results/README.md

@@ -0,0 +1,13 @@
+# ASP.NET Core Http.Results
+
+Http.Results contains the in-framework implementations of the `IResult` interface returned from Minimal APIs route handler delegates, e.g. `OkHttpResult`, `NoContentHttpResult`, etc.
+
+## Development Setup
+
+The `Results<TResult1, TResult2, TResultN>` union types are generated. Modify and run the [ResultsOfTGenerator](tools/ResultsOfTGenerator/) tool to generate an updated `ResultsOfT.cs` class file.
+
+Run the following command in `src\Http\Http.Results\tools\ResultsOfTGenerator`:
+
+```
+dotnet run
+```

src/Http/Http.Results/src/PublicAPI.Unshipped.txt

@@ -114,6 +114,41 @@ Microsoft.AspNetCore.Http.RedirectToRouteHttpResult.Permanent.get -> bool
 Microsoft.AspNetCore.Http.RedirectToRouteHttpResult.PreserveMethod.get -> bool
 Microsoft.AspNetCore.Http.RedirectToRouteHttpResult.RouteName.get -> string?
 Microsoft.AspNetCore.Http.RedirectToRouteHttpResult.RouteValues.get -> Microsoft.AspNetCore.Routing.RouteValueDictionary?
+Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>
+Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>.ExecuteAsync(Microsoft.AspNetCore.Http.HttpContext! httpContext) -> System.Threading.Tasks.Task!
+Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>.Result.get -> Microsoft.AspNetCore.Http.IResult!
+Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4, TResult5>
+Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4, TResult5>.ExecuteAsync(Microsoft.AspNetCore.Http.HttpContext! httpContext) -> System.Threading.Tasks.Task!
+Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4, TResult5>.Result.get -> Microsoft.AspNetCore.Http.IResult!
+Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4>
+Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4>.ExecuteAsync(Microsoft.AspNetCore.Http.HttpContext! httpContext) -> System.Threading.Tasks.Task!
+Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4>.Result.get -> Microsoft.AspNetCore.Http.IResult!
+Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3>
+Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3>.ExecuteAsync(Microsoft.AspNetCore.Http.HttpContext! httpContext) -> System.Threading.Tasks.Task!
+Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3>.Result.get -> Microsoft.AspNetCore.Http.IResult!
+Microsoft.AspNetCore.Http.Results<TResult1, TResult2>
+Microsoft.AspNetCore.Http.Results<TResult1, TResult2>.ExecuteAsync(Microsoft.AspNetCore.Http.HttpContext! httpContext) -> System.Threading.Tasks.Task!
+Microsoft.AspNetCore.Http.Results<TResult1, TResult2>.Result.get -> Microsoft.AspNetCore.Http.IResult!
+static Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>.implicit operator Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>!(TResult1 result) -> Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>!
+static Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>.implicit operator Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>!(TResult2 result) -> Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>!
+static Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>.implicit operator Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>!(TResult3 result) -> Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>!
+static Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>.implicit operator Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>!(TResult4 result) -> Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>!
+static Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>.implicit operator Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>!(TResult5 result) -> Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>!
+static Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>.implicit operator Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>!(TResult6 result) -> Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>!
+static Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4, TResult5>.implicit operator Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4, TResult5>!(TResult1 result) -> Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4, TResult5>!
+static Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4, TResult5>.implicit operator Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4, TResult5>!(TResult2 result) -> Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4, TResult5>!
+static Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4, TResult5>.implicit operator Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4, TResult5>!(TResult3 result) -> Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4, TResult5>!
+static Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4, TResult5>.implicit operator Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4, TResult5>!(TResult4 result) -> Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4, TResult5>!
+static Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4, TResult5>.implicit operator Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4, TResult5>!(TResult5 result) -> Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4, TResult5>!
+static Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4>.implicit operator Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4>!(TResult1 result) -> Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4>!
+static Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4>.implicit operator Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4>!(TResult2 result) -> Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4>!
+static Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4>.implicit operator Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4>!(TResult3 result) -> Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4>!
+static Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4>.implicit operator Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4>!(TResult4 result) -> Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3, TResult4>!
+static Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3>.implicit operator Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3>!(TResult1 result) -> Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3>!
+static Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3>.implicit operator Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3>!(TResult2 result) -> Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3>!
+static Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3>.implicit operator Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3>!(TResult3 result) -> Microsoft.AspNetCore.Http.Results<TResult1, TResult2, TResult3>!
+static Microsoft.AspNetCore.Http.Results<TResult1, TResult2>.implicit operator Microsoft.AspNetCore.Http.Results<TResult1, TResult2>!(TResult1 result) -> Microsoft.AspNetCore.Http.Results<TResult1, TResult2>!
+static Microsoft.AspNetCore.Http.Results<TResult1, TResult2>.implicit operator Microsoft.AspNetCore.Http.Results<TResult1, TResult2>!(TResult2 result) -> Microsoft.AspNetCore.Http.Results<TResult1, TResult2>!
 Microsoft.AspNetCore.Http.SignInHttpResult
 Microsoft.AspNetCore.Http.SignInHttpResult.AuthenticationScheme.get -> string?
 Microsoft.AspNetCore.Http.SignInHttpResult.ExecuteAsync(Microsoft.AspNetCore.Http.HttpContext! httpContext) -> System.Threading.Tasks.Task!

src/Http/Http.Results/src/ResultsOfT.cs

@@ -0,0 +1,345 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+// This file is generated by a tool. See: src/Http/Http.Results/tools/ResultsOfTGenerator
+namespace Microsoft.AspNetCore.Http;
+
+/// <summary>
+/// An <see cref="IResult"/> that could be one of two different <see cref="IResult"/> types. On execution will
+/// execute the underlying <see cref="IResult"/> instance that was actually returned by the HTTP endpoint.
+/// </summary>
+/// <remarks>
+/// An instance of this type cannot be created explicitly. Use the implicit cast operators to create an instance
+/// from an instance of one of the declared type arguments, e.g.
+/// <code>Results&lt;OkObjectHttpResult, ProblemHttpResult&gt; result = Results.Ok();</code>
+/// </remarks>
+/// <typeparam name="TResult1">The first result type.</typeparam>
+/// <typeparam name="TResult2">The second result type.</typeparam>
+public sealed class Results<TResult1, TResult2> : IResult
+    where TResult1 : IResult
+    where TResult2 : IResult
+{
+    // Use implicit cast operators to create an instance
+    private Results(IResult activeResult)
+    {
+        Result = activeResult;
+    }
+
+    /// <summary>
+    /// Gets the actual <see cref="IResult"/> returned by the <see cref="Endpoint"/> route handler delegate.
+    /// </summary>
+    public IResult Result { get; }
+
+    /// <inheritdoc/>
+    public Task ExecuteAsync(HttpContext httpContext)
+    {
+        ArgumentNullException.ThrowIfNull(httpContext, nameof(httpContext));
+
+        if (Result is null)
+        {
+            throw new InvalidOperationException("The IResult assigned to the Result property must not be null.");
+        }
+
+        return Result.ExecuteAsync(httpContext);
+    }
+
+    /// <summary>
+    /// Converts the <typeparamref name="TResult1"/> to a <see cref="Results{TResult1, TResult2}" />.
+    /// </summary>
+    /// <param name="result">The result.</param>
+    public static implicit operator Results<TResult1, TResult2>(TResult1 result) => new(result);
+
+    /// <summary>
+    /// Converts the <typeparamref name="TResult2"/> to a <see cref="Results{TResult1, TResult2}" />.
+    /// </summary>
+    /// <param name="result">The result.</param>
+    public static implicit operator Results<TResult1, TResult2>(TResult2 result) => new(result);
+}
+
+/// <summary>
+/// An <see cref="IResult"/> that could be one of three different <see cref="IResult"/> types. On execution will
+/// execute the underlying <see cref="IResult"/> instance that was actually returned by the HTTP endpoint.
+/// </summary>
+/// <remarks>
+/// An instance of this type cannot be created explicitly. Use the implicit cast operators to create an instance
+/// from an instance of one of the declared type arguments, e.g.
+/// <code>Results&lt;OkObjectHttpResult, ProblemHttpResult&gt; result = Results.Ok();</code>
+/// </remarks>
+/// <typeparam name="TResult1">The first result type.</typeparam>
+/// <typeparam name="TResult2">The second result type.</typeparam>
+/// <typeparam name="TResult3">The third result type.</typeparam>
+public sealed class Results<TResult1, TResult2, TResult3> : IResult
+    where TResult1 : IResult
+    where TResult2 : IResult
+    where TResult3 : IResult
+{
+    // Use implicit cast operators to create an instance
+    private Results(IResult activeResult)
+    {
+        Result = activeResult;
+    }
+
+    /// <summary>
+    /// Gets the actual <see cref="IResult"/> returned by the <see cref="Endpoint"/> route handler delegate.
+    /// </summary>
+    public IResult Result { get; }
+
+    /// <inheritdoc/>
+    public Task ExecuteAsync(HttpContext httpContext)
+    {
+        ArgumentNullException.ThrowIfNull(httpContext, nameof(httpContext));
+
+        if (Result is null)
+        {
+            throw new InvalidOperationException("The IResult assigned to the Result property must not be null.");
+        }
+
+        return Result.ExecuteAsync(httpContext);
+    }
+
+    /// <summary>
+    /// Converts the <typeparamref name="TResult1"/> to a <see cref="Results{TResult1, TResult2, TResult3}" />.
+    /// </summary>
+    /// <param name="result">The result.</param>
+    public static implicit operator Results<TResult1, TResult2, TResult3>(TResult1 result) => new(result);
+
+    /// <summary>
+    /// Converts the <typeparamref name="TResult2"/> to a <see cref="Results{TResult1, TResult2, TResult3}" />.
+    /// </summary>
+    /// <param name="result">The result.</param>
+    public static implicit operator Results<TResult1, TResult2, TResult3>(TResult2 result) => new(result);
+
+    /// <summary>
+    /// Converts the <typeparamref name="TResult3"/> to a <see cref="Results{TResult1, TResult2, TResult3}" />.
+    /// </summary>
+    /// <param name="result">The result.</param>
+    public static implicit operator Results<TResult1, TResult2, TResult3>(TResult3 result) => new(result);
+}
+
+/// <summary>
+/// An <see cref="IResult"/> that could be one of four different <see cref="IResult"/> types. On execution will
+/// execute the underlying <see cref="IResult"/> instance that was actually returned by the HTTP endpoint.
+/// </summary>
+/// <remarks>
+/// An instance of this type cannot be created explicitly. Use the implicit cast operators to create an instance
+/// from an instance of one of the declared type arguments, e.g.
+/// <code>Results&lt;OkObjectHttpResult, ProblemHttpResult&gt; result = Results.Ok();</code>
+/// </remarks>
+/// <typeparam name="TResult1">The first result type.</typeparam>
+/// <typeparam name="TResult2">The second result type.</typeparam>
+/// <typeparam name="TResult3">The third result type.</typeparam>
+/// <typeparam name="TResult4">The fourth result type.</typeparam>
+public sealed class Results<TResult1, TResult2, TResult3, TResult4> : IResult
+    where TResult1 : IResult
+    where TResult2 : IResult
+    where TResult3 : IResult
+    where TResult4 : IResult
+{
+    // Use implicit cast operators to create an instance
+    private Results(IResult activeResult)
+    {
+        Result = activeResult;
+    }
+
+    /// <summary>
+    /// Gets the actual <see cref="IResult"/> returned by the <see cref="Endpoint"/> route handler delegate.
+    /// </summary>
+    public IResult Result { get; }
+
+    /// <inheritdoc/>
+    public Task ExecuteAsync(HttpContext httpContext)
+    {
+        ArgumentNullException.ThrowIfNull(httpContext, nameof(httpContext));
+
+        if (Result is null)
+        {
+            throw new InvalidOperationException("The IResult assigned to the Result property must not be null.");
+        }
+
+        return Result.ExecuteAsync(httpContext);
+    }
+
+    /// <summary>
+    /// Converts the <typeparamref name="TResult1"/> to a <see cref="Results{TResult1, TResult2, TResult3, TResult4}" />.
+    /// </summary>
+    /// <param name="result">The result.</param>
+    public static implicit operator Results<TResult1, TResult2, TResult3, TResult4>(TResult1 result) => new(result);
+
+    /// <summary>
+    /// Converts the <typeparamref name="TResult2"/> to a <see cref="Results{TResult1, TResult2, TResult3, TResult4}" />.
+    /// </summary>
+    /// <param name="result">The result.</param>
+    public static implicit operator Results<TResult1, TResult2, TResult3, TResult4>(TResult2 result) => new(result);
+
+    /// <summary>
+    /// Converts the <typeparamref name="TResult3"/> to a <see cref="Results{TResult1, TResult2, TResult3, TResult4}" />.
+    /// </summary>
+    /// <param name="result">The result.</param>
+    public static implicit operator Results<TResult1, TResult2, TResult3, TResult4>(TResult3 result) => new(result);
+
+    /// <summary>
+    /// Converts the <typeparamref name="TResult4"/> to a <see cref="Results{TResult1, TResult2, TResult3, TResult4}" />.
+    /// </summary>
+    /// <param name="result">The result.</param>
+    public static implicit operator Results<TResult1, TResult2, TResult3, TResult4>(TResult4 result) => new(result);
+}
+
+/// <summary>
+/// An <see cref="IResult"/> that could be one of five different <see cref="IResult"/> types. On execution will
+/// execute the underlying <see cref="IResult"/> instance that was actually returned by the HTTP endpoint.
+/// </summary>
+/// <remarks>
+/// An instance of this type cannot be created explicitly. Use the implicit cast operators to create an instance
+/// from an instance of one of the declared type arguments, e.g.
+/// <code>Results&lt;OkObjectHttpResult, ProblemHttpResult&gt; result = Results.Ok();</code>
+/// </remarks>
+/// <typeparam name="TResult1">The first result type.</typeparam>
+/// <typeparam name="TResult2">The second result type.</typeparam>
+/// <typeparam name="TResult3">The third result type.</typeparam>
+/// <typeparam name="TResult4">The fourth result type.</typeparam>
+/// <typeparam name="TResult5">The fifth result type.</typeparam>
+public sealed class Results<TResult1, TResult2, TResult3, TResult4, TResult5> : IResult
+    where TResult1 : IResult
+    where TResult2 : IResult
+    where TResult3 : IResult
+    where TResult4 : IResult
+    where TResult5 : IResult
+{
+    // Use implicit cast operators to create an instance
+    private Results(IResult activeResult)
+    {
+        Result = activeResult;
+    }
+
+    /// <summary>
+    /// Gets the actual <see cref="IResult"/> returned by the <see cref="Endpoint"/> route handler delegate.
+    /// </summary>
+    public IResult Result { get; }
+
+    /// <inheritdoc/>
+    public Task ExecuteAsync(HttpContext httpContext)
+    {
+        ArgumentNullException.ThrowIfNull(httpContext, nameof(httpContext));
+
+        if (Result is null)
+        {
+            throw new InvalidOperationException("The IResult assigned to the Result property must not be null.");
+        }
+
+        return Result.ExecuteAsync(httpContext);
+    }
+
+    /// <summary>
+    /// Converts the <typeparamref name="TResult1"/> to a <see cref="Results{TResult1, TResult2, TResult3, TResult4, TResult5}" />.
+    /// </summary>
+    /// <param name="result">The result.</param>
+    public static implicit operator Results<TResult1, TResult2, TResult3, TResult4, TResult5>(TResult1 result) => new(result);
+
+    /// <summary>
+    /// Converts the <typeparamref name="TResult2"/> to a <see cref="Results{TResult1, TResult2, TResult3, TResult4, TResult5}" />.
+    /// </summary>
+    /// <param name="result">The result.</param>
+    public static implicit operator Results<TResult1, TResult2, TResult3, TResult4, TResult5>(TResult2 result) => new(result);
+
+    /// <summary>
+    /// Converts the <typeparamref name="TResult3"/> to a <see cref="Results{TResult1, TResult2, TResult3, TResult4, TResult5}" />.
+    /// </summary>
+    /// <param name="result">The result.</param>
+    public static implicit operator Results<TResult1, TResult2, TResult3, TResult4, TResult5>(TResult3 result) => new(result);
+
+    /// <summary>
+    /// Converts the <typeparamref name="TResult4"/> to a <see cref="Results{TResult1, TResult2, TResult3, TResult4, TResult5}" />.
+    /// </summary>
+    /// <param name="result">The result.</param>
+    public static implicit operator Results<TResult1, TResult2, TResult3, TResult4, TResult5>(TResult4 result) => new(result);
+
+    /// <summary>
+    /// Converts the <typeparamref name="TResult5"/> to a <see cref="Results{TResult1, TResult2, TResult3, TResult4, TResult5}" />.
+    /// </summary>
+    /// <param name="result">The result.</param>
+    public static implicit operator Results<TResult1, TResult2, TResult3, TResult4, TResult5>(TResult5 result) => new(result);
+}
+
+/// <summary>
+/// An <see cref="IResult"/> that could be one of six different <see cref="IResult"/> types. On execution will
+/// execute the underlying <see cref="IResult"/> instance that was actually returned by the HTTP endpoint.
+/// </summary>
+/// <remarks>
+/// An instance of this type cannot be created explicitly. Use the implicit cast operators to create an instance
+/// from an instance of one of the declared type arguments, e.g.
+/// <code>Results&lt;OkObjectHttpResult, ProblemHttpResult&gt; result = Results.Ok();</code>
+/// </remarks>
+/// <typeparam name="TResult1">The first result type.</typeparam>
+/// <typeparam name="TResult2">The second result type.</typeparam>
+/// <typeparam name="TResult3">The third result type.</typeparam>
+/// <typeparam name="TResult4">The fourth result type.</typeparam>
+/// <typeparam name="TResult5">The fifth result type.</typeparam>
+/// <typeparam name="TResult6">The sixth result type.</typeparam>
+public sealed class Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6> : IResult
+    where TResult1 : IResult
+    where TResult2 : IResult
+    where TResult3 : IResult
+    where TResult4 : IResult
+    where TResult5 : IResult
+    where TResult6 : IResult
+{
+    // Use implicit cast operators to create an instance
+    private Results(IResult activeResult)
+    {
+        Result = activeResult;
+    }
+
+    /// <summary>
+    /// Gets the actual <see cref="IResult"/> returned by the <see cref="Endpoint"/> route handler delegate.
+    /// </summary>
+    public IResult Result { get; }
+
+    /// <inheritdoc/>
+    public Task ExecuteAsync(HttpContext httpContext)
+    {
+        ArgumentNullException.ThrowIfNull(httpContext, nameof(httpContext));
+
+        if (Result is null)
+        {
+            throw new InvalidOperationException("The IResult assigned to the Result property must not be null.");
+        }
+
+        return Result.ExecuteAsync(httpContext);
+    }
+
+    /// <summary>
+    /// Converts the <typeparamref name="TResult1"/> to a <see cref="Results{TResult1, TResult2, TResult3, TResult4, TResult5, TResult6}" />.
+    /// </summary>
+    /// <param name="result">The result.</param>
+    public static implicit operator Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>(TResult1 result) => new(result);
+
+    /// <summary>
+    /// Converts the <typeparamref name="TResult2"/> to a <see cref="Results{TResult1, TResult2, TResult3, TResult4, TResult5, TResult6}" />.
+    /// </summary>
+    /// <param name="result">The result.</param>
+    public static implicit operator Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>(TResult2 result) => new(result);
+
+    /// <summary>
+    /// Converts the <typeparamref name="TResult3"/> to a <see cref="Results{TResult1, TResult2, TResult3, TResult4, TResult5, TResult6}" />.
+    /// </summary>
+    /// <param name="result">The result.</param>
+    public static implicit operator Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>(TResult3 result) => new(result);
+
+    /// <summary>
+    /// Converts the <typeparamref name="TResult4"/> to a <see cref="Results{TResult1, TResult2, TResult3, TResult4, TResult5, TResult6}" />.
+    /// </summary>
+    /// <param name="result">The result.</param>
+    public static implicit operator Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>(TResult4 result) => new(result);
+
+    /// <summary>
+    /// Converts the <typeparamref name="TResult5"/> to a <see cref="Results{TResult1, TResult2, TResult3, TResult4, TResult5, TResult6}" />.
+    /// </summary>
+    /// <param name="result">The result.</param>
+    public static implicit operator Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>(TResult5 result) => new(result);
+
+    /// <summary>
+    /// Converts the <typeparamref name="TResult6"/> to a <see cref="Results{TResult1, TResult2, TResult3, TResult4, TResult5, TResult6}" />.
+    /// </summary>
+    /// <param name="result">The result.</param>
+    public static implicit operator Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>(TResult6 result) => new(result);
+}

src/Http/Http.Results/test/Microsoft.AspNetCore.Http.Results.Tests.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <TargetFramework>$(DefaultNetCoreTargetFramework)</TargetFramework>
@@ -9,7 +9,12 @@
     <Reference Include="Microsoft.AspNetCore.Http.Results" />
     <Reference Include="Microsoft.Extensions.DependencyInjection" />
 
+    <ProjectReference Include="..\tools\ResultsOfTGenerator\ResultsOfTGenerator.csproj" />
+
     <Compile Include="$(SharedSourceRoot)ResultsTests\*.cs" LinkBase="Shared" />
+
+    <Content Include="..\src\ResultsOfT.cs" LinkBase="Shared\GeneratedContent" CopyToOutputDirectory="PreserveNewest" />
+    <Compile Update="ResultsOfTTests.Generated.cs" Link="Shared\GeneratedContent\%(RecursiveDir)%(Filename)%(Extension)" CopyToOutputDirectory="PreserveNewest" />
   </ItemGroup>
 
 </Project>

src/Http/Http.Results/test/ResultsOfTTests.Generated.cs

@@ -0,0 +1,1764 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+// This file is generated by a tool. See: src/Http/Http.Results/tools/ResultsOfTGenerator
+namespace Microsoft.AspNetCore.Http.Result;
+
+using System.Threading.Tasks;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
+
+public partial class ResultsOfTTests
+{
+    [Theory]
+    [InlineData(1, typeof(ChecksumResult1))]
+    [InlineData(2, typeof(ChecksumResult2))]
+    public void ResultsOfTResult1TResult2_Result_IsAssignedResult(int input, Type expectedResultType)
+    {
+        // Arrange
+        Results<ChecksumResult1, ChecksumResult2> MyApi(int id)
+        {
+            return id switch
+            {
+                1 => new ChecksumResult1(),
+                _ => new ChecksumResult2()
+            };
+        }
+
+        // Act
+        var result = MyApi(input);
+
+        // Assert
+        Assert.IsType(expectedResultType, result.Result);
+    }
+
+    [Theory]
+    [InlineData(1)]
+    [InlineData(2)]
+    public async Task ResultsOfTResult1TResult2_ExecuteResult_ExecutesAssignedResult(int input)
+    {
+        // Arrange
+        Results<ChecksumResult1, ChecksumResult2> MyApi(int checksum)
+        {
+            return checksum switch
+            {
+                1 => new ChecksumResult1(checksum),
+                _ => new ChecksumResult2(checksum)
+            };
+        }
+        var httpContext = GetHttpContext();
+
+        // Act
+        var result = MyApi(input);
+        await result.ExecuteAsync(httpContext);
+
+        // Assert
+        Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);
+    }
+
+    [Fact]
+    public void ResultsOfTResult1TResult2_Throws_ArgumentNullException_WhenHttpContextIsNull()
+    {
+        // Arrange
+        Results<ChecksumResult1, NoContentHttpResult> MyApi()
+        {
+            return new ChecksumResult1(1);
+        }
+        HttpContext httpContext = null;
+        
+        // Act & Assert
+        var result = MyApi();
+        
+        Assert.ThrowsAsync<ArgumentNullException>(async () =>
+        {
+            await result.ExecuteAsync(httpContext);
+        });
+    }
+    
+    [Fact]
+    public void ResultsOfTResult1TResult2_Throws_InvalidOperationException_WhenResultIsNull()
+    {
+        // Arrange
+        Results<ChecksumResult1, NoContentHttpResult> MyApi()
+        {
+            return new ChecksumResult1(1);
+        }
+        var httpContext = GetHttpContext();
+        
+        // Act & Assert
+        var result = MyApi();
+        
+        Assert.ThrowsAsync<InvalidOperationException>(async () =>
+        {
+            await result.ExecuteAsync(httpContext);
+        });
+    }
+    
+    [Theory]
+    [InlineData(1, typeof(ChecksumResult1))]
+    [InlineData(2, typeof(ChecksumResult2))]
+    public async Task ResultsOfTResult1TResult2_AcceptsIResult_AsFirstTypeArg(int input, Type expectedResultType)
+    {
+        // Arrange
+        Results<IResult, ChecksumResult2> MyApi(int id)
+        {
+            return id switch
+            {
+                1 => new ChecksumResult1(1),
+                _ => new ChecksumResult2(2)
+            };
+        }
+        var httpContext = GetHttpContext();
+
+        // Act
+        var result = MyApi(input);
+        await result.ExecuteAsync(httpContext);
+        
+        // Assert
+        Assert.IsType(expectedResultType, result.Result);
+        Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);
+    }
+    
+    [Theory]
+    [InlineData(1, typeof(ChecksumResult1))]
+    [InlineData(2, typeof(ChecksumResult2))]
+    public async Task ResultsOfTResult1TResult2_AcceptsIResult_AsSecondTypeArg(int input, Type expectedResultType)
+    {
+        // Arrange
+        Results<ChecksumResult1, IResult> MyApi(int id)
+        {
+            return id switch
+            {
+                1 => new ChecksumResult1(1),
+                _ => new ChecksumResult2(2)
+            };
+        }
+        var httpContext = GetHttpContext();
+
+        // Act
+        var result = MyApi(input);
+        await result.ExecuteAsync(httpContext);
+        
+        // Assert
+        Assert.IsType(expectedResultType, result.Result);
+        Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);
+    }
+    
+    [Theory]
+    [InlineData(1, typeof(Results<ChecksumResult1, ChecksumResult2>))]
+    [InlineData(2, typeof(Results<ChecksumResult1, ChecksumResult2>))]
+    [InlineData(3, typeof(ChecksumResult3))]
+    public async Task ResultsOfTResult1TResult2_AcceptsNestedResultsOfT_AsFirstTypeArg(int input, Type expectedResultType)
+    {
+        // Arrange
+        Results<Results<ChecksumResult1, ChecksumResult2>, ChecksumResult3> MyApi(int id)
+        {
+            return id switch
+            {
+                1 => (Results<ChecksumResult1, ChecksumResult2>)new ChecksumResult1(1),
+                2 => (Results<ChecksumResult1, ChecksumResult2>)new ChecksumResult2(2),
+                _ => new ChecksumResult3(3)
+            };
+        }
+        var httpContext = GetHttpContext();
+
+        // Act
+        var result = MyApi(input);
+        await result.ExecuteAsync(httpContext);
+        
+        // Assert
+        Assert.IsType(expectedResultType, result.Result);
+        Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);
+    }
+    
+    [Theory]
+    [InlineData(1, typeof(Results<ChecksumResult1, ChecksumResult2>))]
+    [InlineData(2, typeof(Results<ChecksumResult1, ChecksumResult2>))]
+    [InlineData(3, typeof(ChecksumResult3))]
+    public async Task ResultsOfTResult1TResult2_AcceptsNestedResultsOfT_AsSecondTypeArg(int input, Type expectedResultType)
+    {
+        // Arrange
+        Results<Results<ChecksumResult1, ChecksumResult2>, ChecksumResult3> MyApi(int id)
+        {
+            return id switch
+            {
+                1 => (Results<ChecksumResult1, ChecksumResult2>)new ChecksumResult1(1),
+                2 => (Results<ChecksumResult1, ChecksumResult2>)new ChecksumResult2(2),
+                _ => new ChecksumResult3(3)
+            };
+        }
+        var httpContext = GetHttpContext();
+
+        // Act
+        var result = MyApi(input);
+        await result.ExecuteAsync(httpContext);
+        
+        // Assert
+        Assert.IsType(expectedResultType, result.Result);
+        Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);
+    }
+    
+    [Theory]
+    [InlineData(1, typeof(ChecksumResult1))]
+    [InlineData(2, typeof(ChecksumResult2))]
+    [InlineData(3, typeof(ChecksumResult3))]
+    public void ResultsOfTResult1TResult2TResult3_Result_IsAssignedResult(int input, Type expectedResultType)
+    {
+        // Arrange
+        Results<ChecksumResult1, ChecksumResult2, ChecksumResult3> MyApi(int id)
+        {
+            return id switch
+            {
+                1 => new ChecksumResult1(),
+                2 => new ChecksumResult2(),
+                _ => new ChecksumResult3()
+            };
+        }
+
+        // Act
+        var result = MyApi(input);
+
+        // Assert
+        Assert.IsType(expectedResultType, result.Result);
+    }
+
+    [Theory]
+    [InlineData(1)]
+    [InlineData(2)]
+    [InlineData(3)]
+    public async Task ResultsOfTResult1TResult2TResult3_ExecuteResult_ExecutesAssignedResult(int input)
+    {
+        // Arrange
+        Results<ChecksumResult1, ChecksumResult2, ChecksumResult3> MyApi(int checksum)
+        {
+            return checksum switch
+            {
+                1 => new ChecksumResult1(checksum),
+                2 => new ChecksumResult2(checksum),
+                _ => new ChecksumResult3(checksum)
+            };
+        }
+        var httpContext = GetHttpContext();
+
+        // Act
+        var result = MyApi(input);
+        await result.ExecuteAsync(httpContext);
+
+        // Assert
+        Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);
+    }
+
+    [Fact]
+    public void ResultsOfTResult1TResult2TResult3_Throws_ArgumentNullException_WhenHttpContextIsNull()
+    {
+        // Arrange
+        Results<ChecksumResult1, NoContentHttpResult> MyApi()
+        {
+            return new ChecksumResult1(1);
+        }
+        HttpContext httpContext = null;
+        
+        // Act & Assert
+        var result = MyApi();
+        
+        Assert.ThrowsAsync<ArgumentNullException>(async () =>
+        {
+            await result.ExecuteAsync(httpContext);
+        });
+    }
+    
+    [Fact]
+    public void ResultsOfTResult1TResult2TResult3_Throws_InvalidOperationException_WhenResultIsNull()
+    {
+        // Arrange
+        Results<ChecksumResult1, NoContentHttpResult> MyApi()
+        {
+            return new ChecksumResult1(1);
+        }
+        var httpContext = GetHttpContext();
+        
+        // Act & Assert
+        var result = MyApi();
+        
+        Assert.ThrowsAsync<InvalidOperationException>(async () =>
+        {
+            await result.ExecuteAsync(httpContext);
+        });
+    }
+    
+    [Theory]
+    [InlineData(1, typeof(ChecksumResult1))]
+    [InlineData(2, typeof(ChecksumResult2))]
+    [InlineData(3, typeof(ChecksumResult3))]
+    public async Task ResultsOfTResult1TResult2TResult3_AcceptsIResult_AsFirstTypeArg(int input, Type expectedResultType)
+    {
+        // Arrange
+        Results<IResult, ChecksumResult2, ChecksumResult3> MyApi(int id)
+        {
+            return id switch
+            {
+                1 => new ChecksumResult1(1),
+                2 => new ChecksumResult2(2),
+                _ => new ChecksumResult3(3)
+            };
+        }
+        var httpContext = GetHttpContext();
+
+        // Act
+        var result = MyApi(input);
+        await result.ExecuteAsync(httpContext);
+        
+        // Assert
+        Assert.IsType(expectedResultType, result.Result);
+        Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);
+    }
+    
+    [Theory]
+    [InlineData(1, typeof(ChecksumResult1))]
+    [InlineData(2, typeof(ChecksumResult2))]
+    [InlineData(3, typeof(ChecksumResult3))]
+    public async Task ResultsOfTResult1TResult2TResult3_AcceptsIResult_AsSecondTypeArg(int input, Type expectedResultType)
+    {
+        // Arrange
+        Results<ChecksumResult1, IResult, ChecksumResult3> MyApi(int id)
+        {
+            return id switch
+            {
+                1 => new ChecksumResult1(1),
+                2 => new ChecksumResult2(2),
+                _ => new ChecksumResult3(3)
+            };
+        }
+        var httpContext = GetHttpContext();
+
+        // Act
+        var result = MyApi(input);
+        await result.ExecuteAsync(httpContext);
+        
+        // Assert
+        Assert.IsType(expectedResultType, result.Result);
+        Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);
+    }
+    
+    [Theory]
+    [InlineData(1, typeof(ChecksumResult1))]
+    [InlineData(2, typeof(ChecksumResult2))]
+    [InlineData(3, typeof(ChecksumResult3))]
+    public async Task ResultsOfTResult1TResult2TResult3_AcceptsIResult_AsThirdTypeArg(int input, Type expectedResultType)
+    {
+        // Arrange
+        Results<ChecksumResult1, ChecksumResult2, IResult> MyApi(int id)
+        {
+            return id switch
+            {
+                1 => new ChecksumResult1(1),
+                2 => new ChecksumResult2(2),
+                _ => new ChecksumResult3(3)
+            };
+        }
+        var httpContext = GetHttpContext();
+
+        // Act
+        var result = MyApi(input);
+        await result.ExecuteAsync(httpContext);
+        
+        // Assert
+        Assert.IsType(expectedResultType, result.Result);
+        Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);
+    }
+    
+    [Theory]
+    [InlineData(1, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3>))]
+    [InlineData(2, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3>))]
+    [InlineData(3, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3>))]
+    [InlineData(4, typeof(ChecksumResult4))]
+    public async Task ResultsOfTResult1TResult2TResult3_AcceptsNestedResultsOfT_AsFirstTypeArg(int input, Type expectedResultType)
+    {
+        // Arrange
+        Results<Results<ChecksumResult1, ChecksumResult2, ChecksumResult3>, ChecksumResult4> MyApi(int id)
+        {
+            return id switch
+            {
+                1 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3>)new ChecksumResult1(1),
+                2 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3>)new ChecksumResult2(2),
+                3 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3>)new ChecksumResult3(3),
+                _ => new ChecksumResult4(4)
+            };
+        }
+        var httpContext = GetHttpContext();
+
+        // Act
+        var result = MyApi(input);
+        await result.ExecuteAsync(httpContext);
+        
+        // Assert
+        Assert.IsType(expectedResultType, result.Result);
+        Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);
+    }
+    
+    [Theory]
+    [InlineData(1, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3>))]
+    [InlineData(2, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3>))]
+    [InlineData(3, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3>))]
+    [InlineData(4, typeof(ChecksumResult4))]
+    public async Task ResultsOfTResult1TResult2TResult3_AcceptsNestedResultsOfT_AsSecondTypeArg(int input, Type expectedResultType)
+    {
+        // Arrange
+        Results<Results<ChecksumResult1, ChecksumResult2, ChecksumResult3>, ChecksumResult4> MyApi(int id)
+        {
+            return id switch
+            {
+                1 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3>)new ChecksumResult1(1),
+                2 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3>)new ChecksumResult2(2),
+                3 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3>)new ChecksumResult3(3),
+                _ => new ChecksumResult4(4)
+            };
+        }
+        var httpContext = GetHttpContext();
+
+        // Act
+        var result = MyApi(input);
+        await result.ExecuteAsync(httpContext);
+        
+        // Assert
+        Assert.IsType(expectedResultType, result.Result);
+        Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);
+    }
+    
+    [Theory]
+    [InlineData(1, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3>))]
+    [InlineData(2, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3>))]
+    [InlineData(3, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3>))]
+    [InlineData(4, typeof(ChecksumResult4))]
+    public async Task ResultsOfTResult1TResult2TResult3_AcceptsNestedResultsOfT_AsThirdTypeArg(int input, Type expectedResultType)
+    {
+        // Arrange
+        Results<Results<ChecksumResult1, ChecksumResult2, ChecksumResult3>, ChecksumResult4> MyApi(int id)
+        {
+            return id switch
+            {
+                1 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3>)new ChecksumResult1(1),
+                2 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3>)new ChecksumResult2(2),
+                3 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3>)new ChecksumResult3(3),
+                _ => new ChecksumResult4(4)
+            };
+        }
+        var httpContext = GetHttpContext();
+
+        // Act
+        var result = MyApi(input);
+        await result.ExecuteAsync(httpContext);
+        
+        // Assert
+        Assert.IsType(expectedResultType, result.Result);
+        Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);
+    }
+    
+    [Theory]
+    [InlineData(1, typeof(ChecksumResult1))]
+    [InlineData(2, typeof(ChecksumResult2))]
+    [InlineData(3, typeof(ChecksumResult3))]
+    [InlineData(4, typeof(ChecksumResult4))]
+    public void ResultsOfTResult1TResult2TResult3TResult4_Result_IsAssignedResult(int input, Type expectedResultType)
+    {
+        // Arrange
+        Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4> MyApi(int id)
+        {
+            return id switch
+            {
+                1 => new ChecksumResult1(),
+                2 => new ChecksumResult2(),
+                3 => new ChecksumResult3(),
+                _ => new ChecksumResult4()
+            };
+        }
+
+        // Act
+        var result = MyApi(input);
+
+        // Assert
+        Assert.IsType(expectedResultType, result.Result);
+    }
+
+    [Theory]
+    [InlineData(1)]
+    [InlineData(2)]
+    [InlineData(3)]
+    [InlineData(4)]
+    public async Task ResultsOfTResult1TResult2TResult3TResult4_ExecuteResult_ExecutesAssignedResult(int input)
+    {
+        // Arrange
+        Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4> MyApi(int checksum)
+        {
+            return checksum switch
+            {
+                1 => new ChecksumResult1(checksum),
+                2 => new ChecksumResult2(checksum),
+                3 => new ChecksumResult3(checksum),
+                _ => new ChecksumResult4(checksum)
+            };
+        }
+        var httpContext = GetHttpContext();
+
+        // Act
+        var result = MyApi(input);
+        await result.ExecuteAsync(httpContext);
+
+        // Assert
+        Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);
+    }
+
+    [Fact]
+    public void ResultsOfTResult1TResult2TResult3TResult4_Throws_ArgumentNullException_WhenHttpContextIsNull()
+    {
+        // Arrange
+        Results<ChecksumResult1, NoContentHttpResult> MyApi()
+        {
+            return new ChecksumResult1(1);
+        }
+        HttpContext httpContext = null;
+        
+        // Act & Assert
+        var result = MyApi();
+        
+        Assert.ThrowsAsync<ArgumentNullException>(async () =>
+        {
+            await result.ExecuteAsync(httpContext);
+        });
+    }
+    
+    [Fact]
+    public void ResultsOfTResult1TResult2TResult3TResult4_Throws_InvalidOperationException_WhenResultIsNull()
+    {
+        // Arrange
+        Results<ChecksumResult1, NoContentHttpResult> MyApi()
+        {
+            return new ChecksumResult1(1);
+        }
+        var httpContext = GetHttpContext();
+        
+        // Act & Assert
+        var result = MyApi();
+        
+        Assert.ThrowsAsync<InvalidOperationException>(async () =>
+        {
+            await result.ExecuteAsync(httpContext);
+        });
+    }
+    
+    [Theory]
+    [InlineData(1, typeof(ChecksumResult1))]
+    [InlineData(2, typeof(ChecksumResult2))]
+    [InlineData(3, typeof(ChecksumResult3))]
+    [InlineData(4, typeof(ChecksumResult4))]
+    public async Task ResultsOfTResult1TResult2TResult3TResult4_AcceptsIResult_AsFirstTypeArg(int input, Type expectedResultType)
+    {
+        // Arrange
+        Results<IResult, ChecksumResult2, ChecksumResult3, ChecksumResult4> MyApi(int id)
+        {
+            return id switch
+            {
+                1 => new ChecksumResult1(1),
+                2 => new ChecksumResult2(2),
+                3 => new ChecksumResult3(3),
+                _ => new ChecksumResult4(4)
+            };
+        }
+        var httpContext = GetHttpContext();
+
+        // Act
+        var result = MyApi(input);
+        await result.ExecuteAsync(httpContext);
+        
+        // Assert
+        Assert.IsType(expectedResultType, result.Result);
+        Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);
+    }
+    
+    [Theory]
+    [InlineData(1, typeof(ChecksumResult1))]
+    [InlineData(2, typeof(ChecksumResult2))]
+    [InlineData(3, typeof(ChecksumResult3))]
+    [InlineData(4, typeof(ChecksumResult4))]
+    public async Task ResultsOfTResult1TResult2TResult3TResult4_AcceptsIResult_AsSecondTypeArg(int input, Type expectedResultType)
+    {
+        // Arrange
+        Results<ChecksumResult1, IResult, ChecksumResult3, ChecksumResult4> MyApi(int id)
+        {
+            return id switch
+            {
+                1 => new ChecksumResult1(1),
+                2 => new ChecksumResult2(2),
+                3 => new ChecksumResult3(3),
+                _ => new ChecksumResult4(4)
+            };
+        }
+        var httpContext = GetHttpContext();
+
+        // Act
+        var result = MyApi(input);
+        await result.ExecuteAsync(httpContext);
+        
+        // Assert
+        Assert.IsType(expectedResultType, result.Result);
+        Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);
+    }
+    
+    [Theory]
+    [InlineData(1, typeof(ChecksumResult1))]
+    [InlineData(2, typeof(ChecksumResult2))]
+    [InlineData(3, typeof(ChecksumResult3))]
+    [InlineData(4, typeof(ChecksumResult4))]
+    public async Task ResultsOfTResult1TResult2TResult3TResult4_AcceptsIResult_AsThirdTypeArg(int input, Type expectedResultType)
+    {
+        // Arrange
+        Results<ChecksumResult1, ChecksumResult2, IResult, ChecksumResult4> MyApi(int id)
+        {
+            return id switch
+            {
+                1 => new ChecksumResult1(1),
+                2 => new ChecksumResult2(2),
+                3 => new ChecksumResult3(3),
+                _ => new ChecksumResult4(4)
+            };
+        }
+        var httpContext = GetHttpContext();
+
+        // Act
+        var result = MyApi(input);
+        await result.ExecuteAsync(httpContext);
+        
+        // Assert
+        Assert.IsType(expectedResultType, result.Result);
+        Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);
+    }
+    
+    [Theory]
+    [InlineData(1, typeof(ChecksumResult1))]
+    [InlineData(2, typeof(ChecksumResult2))]
+    [InlineData(3, typeof(ChecksumResult3))]
+    [InlineData(4, typeof(ChecksumResult4))]
+    public async Task ResultsOfTResult1TResult2TResult3TResult4_AcceptsIResult_AsFourthTypeArg(int input, Type expectedResultType)
+    {
+        // Arrange
+        Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, IResult> MyApi(int id)
+        {
+            return id switch
+            {
+                1 => new ChecksumResult1(1),
+                2 => new ChecksumResult2(2),
+                3 => new ChecksumResult3(3),
+                _ => new ChecksumResult4(4)
+            };
+        }
+        var httpContext = GetHttpContext();
+
+        // Act
+        var result = MyApi(input);
+        await result.ExecuteAsync(httpContext);
+        
+        // Assert
+        Assert.IsType(expectedResultType, result.Result);
+        Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);
+    }
+    
+    [Theory]
+    [InlineData(1, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4>))]
+    [InlineData(2, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4>))]
+    [InlineData(3, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4>))]
+    [InlineData(4, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4>))]
+    [InlineData(5, typeof(ChecksumResult5))]
+    public async Task ResultsOfTResult1TResult2TResult3TResult4_AcceptsNestedResultsOfT_AsFirstTypeArg(int input, Type expectedResultType)
+    {
+        // Arrange
+        Results<Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4>, ChecksumResult5> MyApi(int id)
+        {
+            return id switch
+            {
+                1 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4>)new ChecksumResult1(1),
+                2 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4>)new ChecksumResult2(2),
+                3 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4>)new ChecksumResult3(3),
+                4 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4>)new ChecksumResult4(4),
+                _ => new ChecksumResult5(5)
+            };
+        }
+        var httpContext = GetHttpContext();
+
+        // Act
+        var result = MyApi(input);
+        await result.ExecuteAsync(httpContext);
+        
+        // Assert
+        Assert.IsType(expectedResultType, result.Result);
+        Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);
+    }
+    
+    [Theory]
+    [InlineData(1, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4>))]
+    [InlineData(2, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4>))]
+    [InlineData(3, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4>))]
+    [InlineData(4, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4>))]
+    [InlineData(5, typeof(ChecksumResult5))]
+    public async Task ResultsOfTResult1TResult2TResult3TResult4_AcceptsNestedResultsOfT_AsSecondTypeArg(int input, Type expectedResultType)
+    {
+        // Arrange
+        Results<Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4>, ChecksumResult5> MyApi(int id)
+        {
+            return id switch
+            {
+                1 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4>)new ChecksumResult1(1),
+                2 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4>)new ChecksumResult2(2),
+                3 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4>)new ChecksumResult3(3),
+                4 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4>)new ChecksumResult4(4),
+                _ => new ChecksumResult5(5)
+            };
+        }
+        var httpContext = GetHttpContext();
+
+        // Act
+        var result = MyApi(input);
+        await result.ExecuteAsync(httpContext);
+        
+        // Assert
+        Assert.IsType(expectedResultType, result.Result);
+        Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);
+    }
+    
+    [Theory]
+    [InlineData(1, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4>))]
+    [InlineData(2, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4>))]
+    [InlineData(3, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4>))]
+    [InlineData(4, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4>))]
+    [InlineData(5, typeof(ChecksumResult5))]
+    public async Task ResultsOfTResult1TResult2TResult3TResult4_AcceptsNestedResultsOfT_AsThirdTypeArg(int input, Type expectedResultType)
+    {
+        // Arrange
+        Results<Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4>, ChecksumResult5> MyApi(int id)
+        {
+            return id switch
+            {
+                1 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4>)new ChecksumResult1(1),
+                2 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4>)new ChecksumResult2(2),
+                3 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4>)new ChecksumResult3(3),
+                4 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4>)new ChecksumResult4(4),
+                _ => new ChecksumResult5(5)
+            };
+        }
+        var httpContext = GetHttpContext();
+
+        // Act
+        var result = MyApi(input);
+        await result.ExecuteAsync(httpContext);
+        
+        // Assert
+        Assert.IsType(expectedResultType, result.Result);
+        Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);
+    }
+    
+    [Theory]
+    [InlineData(1, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4>))]
+    [InlineData(2, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4>))]
+    [InlineData(3, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4>))]
+    [InlineData(4, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4>))]
+    [InlineData(5, typeof(ChecksumResult5))]
+    public async Task ResultsOfTResult1TResult2TResult3TResult4_AcceptsNestedResultsOfT_AsFourthTypeArg(int input, Type expectedResultType)
+    {
+        // Arrange
+        Results<Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4>, ChecksumResult5> MyApi(int id)
+        {
+            return id switch
+            {
+                1 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4>)new ChecksumResult1(1),
+                2 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4>)new ChecksumResult2(2),
+                3 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4>)new ChecksumResult3(3),
+                4 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4>)new ChecksumResult4(4),
+                _ => new ChecksumResult5(5)
+            };
+        }
+        var httpContext = GetHttpContext();
+
+        // Act
+        var result = MyApi(input);
+        await result.ExecuteAsync(httpContext);
+        
+        // Assert
+        Assert.IsType(expectedResultType, result.Result);
+        Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);
+    }
+    
+    [Theory]
+    [InlineData(1, typeof(ChecksumResult1))]
+    [InlineData(2, typeof(ChecksumResult2))]
+    [InlineData(3, typeof(ChecksumResult3))]
+    [InlineData(4, typeof(ChecksumResult4))]
+    [InlineData(5, typeof(ChecksumResult5))]
+    public void ResultsOfTResult1TResult2TResult3TResult4TResult5_Result_IsAssignedResult(int input, Type expectedResultType)
+    {
+        // Arrange
+        Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5> MyApi(int id)
+        {
+            return id switch
+            {
+                1 => new ChecksumResult1(),
+                2 => new ChecksumResult2(),
+                3 => new ChecksumResult3(),
+                4 => new ChecksumResult4(),
+                _ => new ChecksumResult5()
+            };
+        }
+
+        // Act
+        var result = MyApi(input);
+
+        // Assert
+        Assert.IsType(expectedResultType, result.Result);
+    }
+
+    [Theory]
+    [InlineData(1)]
+    [InlineData(2)]
+    [InlineData(3)]
+    [InlineData(4)]
+    [InlineData(5)]
+    public async Task ResultsOfTResult1TResult2TResult3TResult4TResult5_ExecuteResult_ExecutesAssignedResult(int input)
+    {
+        // Arrange
+        Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5> MyApi(int checksum)
+        {
+            return checksum switch
+            {
+                1 => new ChecksumResult1(checksum),
+                2 => new ChecksumResult2(checksum),
+                3 => new ChecksumResult3(checksum),
+                4 => new ChecksumResult4(checksum),
+                _ => new ChecksumResult5(checksum)
+            };
+        }
+        var httpContext = GetHttpContext();
+
+        // Act
+        var result = MyApi(input);
+        await result.ExecuteAsync(httpContext);
+
+        // Assert
+        Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);
+    }
+
+    [Fact]
+    public void ResultsOfTResult1TResult2TResult3TResult4TResult5_Throws_ArgumentNullException_WhenHttpContextIsNull()
+    {
+        // Arrange
+        Results<ChecksumResult1, NoContentHttpResult> MyApi()
+        {
+            return new ChecksumResult1(1);
+        }
+        HttpContext httpContext = null;
+        
+        // Act & Assert
+        var result = MyApi();
+        
+        Assert.ThrowsAsync<ArgumentNullException>(async () =>
+        {
+            await result.ExecuteAsync(httpContext);
+        });
+    }
+    
+    [Fact]
+    public void ResultsOfTResult1TResult2TResult3TResult4TResult5_Throws_InvalidOperationException_WhenResultIsNull()
+    {
+        // Arrange
+        Results<ChecksumResult1, NoContentHttpResult> MyApi()
+        {
+            return new ChecksumResult1(1);
+        }
+        var httpContext = GetHttpContext();
+        
+        // Act & Assert
+        var result = MyApi();
+        
+        Assert.ThrowsAsync<InvalidOperationException>(async () =>
+        {
+            await result.ExecuteAsync(httpContext);
+        });
+    }
+    
+    [Theory]
+    [InlineData(1, typeof(ChecksumResult1))]
+    [InlineData(2, typeof(ChecksumResult2))]
+    [InlineData(3, typeof(ChecksumResult3))]
+    [InlineData(4, typeof(ChecksumResult4))]
+    [InlineData(5, typeof(ChecksumResult5))]
+    public async Task ResultsOfTResult1TResult2TResult3TResult4TResult5_AcceptsIResult_AsFirstTypeArg(int input, Type expectedResultType)
+    {
+        // Arrange
+        Results<IResult, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5> MyApi(int id)
+        {
+            return id switch
+            {
+                1 => new ChecksumResult1(1),
+                2 => new ChecksumResult2(2),
+                3 => new ChecksumResult3(3),
+                4 => new ChecksumResult4(4),
+                _ => new ChecksumResult5(5)
+            };
+        }
+        var httpContext = GetHttpContext();
+
+        // Act
+        var result = MyApi(input);
+        await result.ExecuteAsync(httpContext);
+        
+        // Assert
+        Assert.IsType(expectedResultType, result.Result);
+        Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);
+    }
+    
+    [Theory]
+    [InlineData(1, typeof(ChecksumResult1))]
+    [InlineData(2, typeof(ChecksumResult2))]
+    [InlineData(3, typeof(ChecksumResult3))]
+    [InlineData(4, typeof(ChecksumResult4))]
+    [InlineData(5, typeof(ChecksumResult5))]
+    public async Task ResultsOfTResult1TResult2TResult3TResult4TResult5_AcceptsIResult_AsSecondTypeArg(int input, Type expectedResultType)
+    {
+        // Arrange
+        Results<ChecksumResult1, IResult, ChecksumResult3, ChecksumResult4, ChecksumResult5> MyApi(int id)
+        {
+            return id switch
+            {
+                1 => new ChecksumResult1(1),
+                2 => new ChecksumResult2(2),
+                3 => new ChecksumResult3(3),
+                4 => new ChecksumResult4(4),
+                _ => new ChecksumResult5(5)
+            };
+        }
+        var httpContext = GetHttpContext();
+
+        // Act
+        var result = MyApi(input);
+        await result.ExecuteAsync(httpContext);
+        
+        // Assert
+        Assert.IsType(expectedResultType, result.Result);
+        Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);
+    }
+    
+    [Theory]
+    [InlineData(1, typeof(ChecksumResult1))]
+    [InlineData(2, typeof(ChecksumResult2))]
+    [InlineData(3, typeof(ChecksumResult3))]
+    [InlineData(4, typeof(ChecksumResult4))]
+    [InlineData(5, typeof(ChecksumResult5))]
+    public async Task ResultsOfTResult1TResult2TResult3TResult4TResult5_AcceptsIResult_AsThirdTypeArg(int input, Type expectedResultType)
+    {
+        // Arrange
+        Results<ChecksumResult1, ChecksumResult2, IResult, ChecksumResult4, ChecksumResult5> MyApi(int id)
+        {
+            return id switch
+            {
+                1 => new ChecksumResult1(1),
+                2 => new ChecksumResult2(2),
+                3 => new ChecksumResult3(3),
+                4 => new ChecksumResult4(4),
+                _ => new ChecksumResult5(5)
+            };
+        }
+        var httpContext = GetHttpContext();
+
+        // Act
+        var result = MyApi(input);
+        await result.ExecuteAsync(httpContext);
+        
+        // Assert
+        Assert.IsType(expectedResultType, result.Result);
+        Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);
+    }
+    
+    [Theory]
+    [InlineData(1, typeof(ChecksumResult1))]
+    [InlineData(2, typeof(ChecksumResult2))]
+    [InlineData(3, typeof(ChecksumResult3))]
+    [InlineData(4, typeof(ChecksumResult4))]
+    [InlineData(5, typeof(ChecksumResult5))]
+    public async Task ResultsOfTResult1TResult2TResult3TResult4TResult5_AcceptsIResult_AsFourthTypeArg(int input, Type expectedResultType)
+    {
+        // Arrange
+        Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, IResult, ChecksumResult5> MyApi(int id)
+        {
+            return id switch
+            {
+                1 => new ChecksumResult1(1),
+                2 => new ChecksumResult2(2),
+                3 => new ChecksumResult3(3),
+                4 => new ChecksumResult4(4),
+                _ => new ChecksumResult5(5)
+            };
+        }
+        var httpContext = GetHttpContext();
+
+        // Act
+        var result = MyApi(input);
+        await result.ExecuteAsync(httpContext);
+        
+        // Assert
+        Assert.IsType(expectedResultType, result.Result);
+        Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);
+    }
+    
+    [Theory]
+    [InlineData(1, typeof(ChecksumResult1))]
+    [InlineData(2, typeof(ChecksumResult2))]
+    [InlineData(3, typeof(ChecksumResult3))]
+    [InlineData(4, typeof(ChecksumResult4))]
+    [InlineData(5, typeof(ChecksumResult5))]
+    public async Task ResultsOfTResult1TResult2TResult3TResult4TResult5_AcceptsIResult_AsFifthTypeArg(int input, Type expectedResultType)
+    {
+        // Arrange
+        Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, IResult> MyApi(int id)
+        {
+            return id switch
+            {
+                1 => new ChecksumResult1(1),
+                2 => new ChecksumResult2(2),
+                3 => new ChecksumResult3(3),
+                4 => new ChecksumResult4(4),
+                _ => new ChecksumResult5(5)
+            };
+        }
+        var httpContext = GetHttpContext();
+
+        // Act
+        var result = MyApi(input);
+        await result.ExecuteAsync(httpContext);
+        
+        // Assert
+        Assert.IsType(expectedResultType, result.Result);
+        Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);
+    }
+    
+    [Theory]
+    [InlineData(1, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>))]
+    [InlineData(2, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>))]
+    [InlineData(3, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>))]
+    [InlineData(4, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>))]
+    [InlineData(5, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>))]
+    [InlineData(6, typeof(ChecksumResult6))]
+    public async Task ResultsOfTResult1TResult2TResult3TResult4TResult5_AcceptsNestedResultsOfT_AsFirstTypeArg(int input, Type expectedResultType)
+    {
+        // Arrange
+        Results<Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>, ChecksumResult6> MyApi(int id)
+        {
+            return id switch
+            {
+                1 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>)new ChecksumResult1(1),
+                2 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>)new ChecksumResult2(2),
+                3 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>)new ChecksumResult3(3),
+                4 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>)new ChecksumResult4(4),
+                5 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>)new ChecksumResult5(5),
+                _ => new ChecksumResult6(6)
+            };
+        }
+        var httpContext = GetHttpContext();
+
+        // Act
+        var result = MyApi(input);
+        await result.ExecuteAsync(httpContext);
+        
+        // Assert
+        Assert.IsType(expectedResultType, result.Result);
+        Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);
+    }
+    
+    [Theory]
+    [InlineData(1, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>))]
+    [InlineData(2, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>))]
+    [InlineData(3, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>))]
+    [InlineData(4, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>))]
+    [InlineData(5, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>))]
+    [InlineData(6, typeof(ChecksumResult6))]
+    public async Task ResultsOfTResult1TResult2TResult3TResult4TResult5_AcceptsNestedResultsOfT_AsSecondTypeArg(int input, Type expectedResultType)
+    {
+        // Arrange
+        Results<Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>, ChecksumResult6> MyApi(int id)
+        {
+            return id switch
+            {
+                1 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>)new ChecksumResult1(1),
+                2 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>)new ChecksumResult2(2),
+                3 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>)new ChecksumResult3(3),
+                4 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>)new ChecksumResult4(4),
+                5 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>)new ChecksumResult5(5),
+                _ => new ChecksumResult6(6)
+            };
+        }
+        var httpContext = GetHttpContext();
+
+        // Act
+        var result = MyApi(input);
+        await result.ExecuteAsync(httpContext);
+        
+        // Assert
+        Assert.IsType(expectedResultType, result.Result);
+        Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);
+    }
+    
+    [Theory]
+    [InlineData(1, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>))]
+    [InlineData(2, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>))]
+    [InlineData(3, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>))]
+    [InlineData(4, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>))]
+    [InlineData(5, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>))]
+    [InlineData(6, typeof(ChecksumResult6))]
+    public async Task ResultsOfTResult1TResult2TResult3TResult4TResult5_AcceptsNestedResultsOfT_AsThirdTypeArg(int input, Type expectedResultType)
+    {
+        // Arrange
+        Results<Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>, ChecksumResult6> MyApi(int id)
+        {
+            return id switch
+            {
+                1 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>)new ChecksumResult1(1),
+                2 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>)new ChecksumResult2(2),
+                3 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>)new ChecksumResult3(3),
+                4 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>)new ChecksumResult4(4),
+                5 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>)new ChecksumResult5(5),
+                _ => new ChecksumResult6(6)
+            };
+        }
+        var httpContext = GetHttpContext();
+
+        // Act
+        var result = MyApi(input);
+        await result.ExecuteAsync(httpContext);
+        
+        // Assert
+        Assert.IsType(expectedResultType, result.Result);
+        Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);
+    }
+    
+    [Theory]
+    [InlineData(1, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>))]
+    [InlineData(2, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>))]
+    [InlineData(3, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>))]
+    [InlineData(4, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>))]
+    [InlineData(5, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>))]
+    [InlineData(6, typeof(ChecksumResult6))]
+    public async Task ResultsOfTResult1TResult2TResult3TResult4TResult5_AcceptsNestedResultsOfT_AsFourthTypeArg(int input, Type expectedResultType)
+    {
+        // Arrange
+        Results<Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>, ChecksumResult6> MyApi(int id)
+        {
+            return id switch
+            {
+                1 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>)new ChecksumResult1(1),
+                2 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>)new ChecksumResult2(2),
+                3 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>)new ChecksumResult3(3),
+                4 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>)new ChecksumResult4(4),
+                5 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>)new ChecksumResult5(5),
+                _ => new ChecksumResult6(6)
+            };
+        }
+        var httpContext = GetHttpContext();
+
+        // Act
+        var result = MyApi(input);
+        await result.ExecuteAsync(httpContext);
+        
+        // Assert
+        Assert.IsType(expectedResultType, result.Result);
+        Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);
+    }
+    
+    [Theory]
+    [InlineData(1, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>))]
+    [InlineData(2, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>))]
+    [InlineData(3, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>))]
+    [InlineData(4, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>))]
+    [InlineData(5, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>))]
+    [InlineData(6, typeof(ChecksumResult6))]
+    public async Task ResultsOfTResult1TResult2TResult3TResult4TResult5_AcceptsNestedResultsOfT_AsFifthTypeArg(int input, Type expectedResultType)
+    {
+        // Arrange
+        Results<Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>, ChecksumResult6> MyApi(int id)
+        {
+            return id switch
+            {
+                1 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>)new ChecksumResult1(1),
+                2 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>)new ChecksumResult2(2),
+                3 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>)new ChecksumResult3(3),
+                4 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>)new ChecksumResult4(4),
+                5 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5>)new ChecksumResult5(5),
+                _ => new ChecksumResult6(6)
+            };
+        }
+        var httpContext = GetHttpContext();
+
+        // Act
+        var result = MyApi(input);
+        await result.ExecuteAsync(httpContext);
+        
+        // Assert
+        Assert.IsType(expectedResultType, result.Result);
+        Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);
+    }
+    
+    [Theory]
+    [InlineData(1, typeof(ChecksumResult1))]
+    [InlineData(2, typeof(ChecksumResult2))]
+    [InlineData(3, typeof(ChecksumResult3))]
+    [InlineData(4, typeof(ChecksumResult4))]
+    [InlineData(5, typeof(ChecksumResult5))]
+    [InlineData(6, typeof(ChecksumResult6))]
+    public void ResultsOfTResult1TResult2TResult3TResult4TResult5TResult6_Result_IsAssignedResult(int input, Type expectedResultType)
+    {
+        // Arrange
+        Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6> MyApi(int id)
+        {
+            return id switch
+            {
+                1 => new ChecksumResult1(),
+                2 => new ChecksumResult2(),
+                3 => new ChecksumResult3(),
+                4 => new ChecksumResult4(),
+                5 => new ChecksumResult5(),
+                _ => new ChecksumResult6()
+            };
+        }
+
+        // Act
+        var result = MyApi(input);
+
+        // Assert
+        Assert.IsType(expectedResultType, result.Result);
+    }
+
+    [Theory]
+    [InlineData(1)]
+    [InlineData(2)]
+    [InlineData(3)]
+    [InlineData(4)]
+    [InlineData(5)]
+    [InlineData(6)]
+    public async Task ResultsOfTResult1TResult2TResult3TResult4TResult5TResult6_ExecuteResult_ExecutesAssignedResult(int input)
+    {
+        // Arrange
+        Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6> MyApi(int checksum)
+        {
+            return checksum switch
+            {
+                1 => new ChecksumResult1(checksum),
+                2 => new ChecksumResult2(checksum),
+                3 => new ChecksumResult3(checksum),
+                4 => new ChecksumResult4(checksum),
+                5 => new ChecksumResult5(checksum),
+                _ => new ChecksumResult6(checksum)
+            };
+        }
+        var httpContext = GetHttpContext();
+
+        // Act
+        var result = MyApi(input);
+        await result.ExecuteAsync(httpContext);
+
+        // Assert
+        Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);
+    }
+
+    [Fact]
+    public void ResultsOfTResult1TResult2TResult3TResult4TResult5TResult6_Throws_ArgumentNullException_WhenHttpContextIsNull()
+    {
+        // Arrange
+        Results<ChecksumResult1, NoContentHttpResult> MyApi()
+        {
+            return new ChecksumResult1(1);
+        }
+        HttpContext httpContext = null;
+        
+        // Act & Assert
+        var result = MyApi();
+        
+        Assert.ThrowsAsync<ArgumentNullException>(async () =>
+        {
+            await result.ExecuteAsync(httpContext);
+        });
+    }
+    
+    [Fact]
+    public void ResultsOfTResult1TResult2TResult3TResult4TResult5TResult6_Throws_InvalidOperationException_WhenResultIsNull()
+    {
+        // Arrange
+        Results<ChecksumResult1, NoContentHttpResult> MyApi()
+        {
+            return new ChecksumResult1(1);
+        }
+        var httpContext = GetHttpContext();
+        
+        // Act & Assert
+        var result = MyApi();
+        
+        Assert.ThrowsAsync<InvalidOperationException>(async () =>
+        {
+            await result.ExecuteAsync(httpContext);
+        });
+    }
+    
+    [Theory]
+    [InlineData(1, typeof(ChecksumResult1))]
+    [InlineData(2, typeof(ChecksumResult2))]
+    [InlineData(3, typeof(ChecksumResult3))]
+    [InlineData(4, typeof(ChecksumResult4))]
+    [InlineData(5, typeof(ChecksumResult5))]
+    [InlineData(6, typeof(ChecksumResult6))]
+    public async Task ResultsOfTResult1TResult2TResult3TResult4TResult5TResult6_AcceptsIResult_AsFirstTypeArg(int input, Type expectedResultType)
+    {
+        // Arrange
+        Results<IResult, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6> MyApi(int id)
+        {
+            return id switch
+            {
+                1 => new ChecksumResult1(1),
+                2 => new ChecksumResult2(2),
+                3 => new ChecksumResult3(3),
+                4 => new ChecksumResult4(4),
+                5 => new ChecksumResult5(5),
+                _ => new ChecksumResult6(6)
+            };
+        }
+        var httpContext = GetHttpContext();
+
+        // Act
+        var result = MyApi(input);
+        await result.ExecuteAsync(httpContext);
+        
+        // Assert
+        Assert.IsType(expectedResultType, result.Result);
+        Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);
+    }
+    
+    [Theory]
+    [InlineData(1, typeof(ChecksumResult1))]
+    [InlineData(2, typeof(ChecksumResult2))]
+    [InlineData(3, typeof(ChecksumResult3))]
+    [InlineData(4, typeof(ChecksumResult4))]
+    [InlineData(5, typeof(ChecksumResult5))]
+    [InlineData(6, typeof(ChecksumResult6))]
+    public async Task ResultsOfTResult1TResult2TResult3TResult4TResult5TResult6_AcceptsIResult_AsSecondTypeArg(int input, Type expectedResultType)
+    {
+        // Arrange
+        Results<ChecksumResult1, IResult, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6> MyApi(int id)
+        {
+            return id switch
+            {
+                1 => new ChecksumResult1(1),
+                2 => new ChecksumResult2(2),
+                3 => new ChecksumResult3(3),
+                4 => new ChecksumResult4(4),
+                5 => new ChecksumResult5(5),
+                _ => new ChecksumResult6(6)
+            };
+        }
+        var httpContext = GetHttpContext();
+
+        // Act
+        var result = MyApi(input);
+        await result.ExecuteAsync(httpContext);
+        
+        // Assert
+        Assert.IsType(expectedResultType, result.Result);
+        Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);
+    }
+    
+    [Theory]
+    [InlineData(1, typeof(ChecksumResult1))]
+    [InlineData(2, typeof(ChecksumResult2))]
+    [InlineData(3, typeof(ChecksumResult3))]
+    [InlineData(4, typeof(ChecksumResult4))]
+    [InlineData(5, typeof(ChecksumResult5))]
+    [InlineData(6, typeof(ChecksumResult6))]
+    public async Task ResultsOfTResult1TResult2TResult3TResult4TResult5TResult6_AcceptsIResult_AsThirdTypeArg(int input, Type expectedResultType)
+    {
+        // Arrange
+        Results<ChecksumResult1, ChecksumResult2, IResult, ChecksumResult4, ChecksumResult5, ChecksumResult6> MyApi(int id)
+        {
+            return id switch
+            {
+                1 => new ChecksumResult1(1),
+                2 => new ChecksumResult2(2),
+                3 => new ChecksumResult3(3),
+                4 => new ChecksumResult4(4),
+                5 => new ChecksumResult5(5),
+                _ => new ChecksumResult6(6)
+            };
+        }
+        var httpContext = GetHttpContext();
+
+        // Act
+        var result = MyApi(input);
+        await result.ExecuteAsync(httpContext);
+        
+        // Assert
+        Assert.IsType(expectedResultType, result.Result);
+        Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);
+    }
+    
+    [Theory]
+    [InlineData(1, typeof(ChecksumResult1))]
+    [InlineData(2, typeof(ChecksumResult2))]
+    [InlineData(3, typeof(ChecksumResult3))]
+    [InlineData(4, typeof(ChecksumResult4))]
+    [InlineData(5, typeof(ChecksumResult5))]
+    [InlineData(6, typeof(ChecksumResult6))]
+    public async Task ResultsOfTResult1TResult2TResult3TResult4TResult5TResult6_AcceptsIResult_AsFourthTypeArg(int input, Type expectedResultType)
+    {
+        // Arrange
+        Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, IResult, ChecksumResult5, ChecksumResult6> MyApi(int id)
+        {
+            return id switch
+            {
+                1 => new ChecksumResult1(1),
+                2 => new ChecksumResult2(2),
+                3 => new ChecksumResult3(3),
+                4 => new ChecksumResult4(4),
+                5 => new ChecksumResult5(5),
+                _ => new ChecksumResult6(6)
+            };
+        }
+        var httpContext = GetHttpContext();
+
+        // Act
+        var result = MyApi(input);
+        await result.ExecuteAsync(httpContext);
+        
+        // Assert
+        Assert.IsType(expectedResultType, result.Result);
+        Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);
+    }
+    
+    [Theory]
+    [InlineData(1, typeof(ChecksumResult1))]
+    [InlineData(2, typeof(ChecksumResult2))]
+    [InlineData(3, typeof(ChecksumResult3))]
+    [InlineData(4, typeof(ChecksumResult4))]
+    [InlineData(5, typeof(ChecksumResult5))]
+    [InlineData(6, typeof(ChecksumResult6))]
+    public async Task ResultsOfTResult1TResult2TResult3TResult4TResult5TResult6_AcceptsIResult_AsFifthTypeArg(int input, Type expectedResultType)
+    {
+        // Arrange
+        Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, IResult, ChecksumResult6> MyApi(int id)
+        {
+            return id switch
+            {
+                1 => new ChecksumResult1(1),
+                2 => new ChecksumResult2(2),
+                3 => new ChecksumResult3(3),
+                4 => new ChecksumResult4(4),
+                5 => new ChecksumResult5(5),
+                _ => new ChecksumResult6(6)
+            };
+        }
+        var httpContext = GetHttpContext();
+
+        // Act
+        var result = MyApi(input);
+        await result.ExecuteAsync(httpContext);
+        
+        // Assert
+        Assert.IsType(expectedResultType, result.Result);
+        Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);
+    }
+    
+    [Theory]
+    [InlineData(1, typeof(ChecksumResult1))]
+    [InlineData(2, typeof(ChecksumResult2))]
+    [InlineData(3, typeof(ChecksumResult3))]
+    [InlineData(4, typeof(ChecksumResult4))]
+    [InlineData(5, typeof(ChecksumResult5))]
+    [InlineData(6, typeof(ChecksumResult6))]
+    public async Task ResultsOfTResult1TResult2TResult3TResult4TResult5TResult6_AcceptsIResult_AsSixthTypeArg(int input, Type expectedResultType)
+    {
+        // Arrange
+        Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, IResult> MyApi(int id)
+        {
+            return id switch
+            {
+                1 => new ChecksumResult1(1),
+                2 => new ChecksumResult2(2),
+                3 => new ChecksumResult3(3),
+                4 => new ChecksumResult4(4),
+                5 => new ChecksumResult5(5),
+                _ => new ChecksumResult6(6)
+            };
+        }
+        var httpContext = GetHttpContext();
+
+        // Act
+        var result = MyApi(input);
+        await result.ExecuteAsync(httpContext);
+        
+        // Assert
+        Assert.IsType(expectedResultType, result.Result);
+        Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);
+    }
+    
+    [Theory]
+    [InlineData(1, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>))]
+    [InlineData(2, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>))]
+    [InlineData(3, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>))]
+    [InlineData(4, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>))]
+    [InlineData(5, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>))]
+    [InlineData(6, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>))]
+    [InlineData(7, typeof(ChecksumResult7))]
+    public async Task ResultsOfTResult1TResult2TResult3TResult4TResult5TResult6_AcceptsNestedResultsOfT_AsFirstTypeArg(int input, Type expectedResultType)
+    {
+        // Arrange
+        Results<Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>, ChecksumResult7> MyApi(int id)
+        {
+            return id switch
+            {
+                1 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>)new ChecksumResult1(1),
+                2 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>)new ChecksumResult2(2),
+                3 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>)new ChecksumResult3(3),
+                4 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>)new ChecksumResult4(4),
+                5 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>)new ChecksumResult5(5),
+                6 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>)new ChecksumResult6(6),
+                _ => new ChecksumResult7(7)
+            };
+        }
+        var httpContext = GetHttpContext();
+
+        // Act
+        var result = MyApi(input);
+        await result.ExecuteAsync(httpContext);
+        
+        // Assert
+        Assert.IsType(expectedResultType, result.Result);
+        Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);
+    }
+    
+    [Theory]
+    [InlineData(1, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>))]
+    [InlineData(2, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>))]
+    [InlineData(3, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>))]
+    [InlineData(4, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>))]
+    [InlineData(5, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>))]
+    [InlineData(6, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>))]
+    [InlineData(7, typeof(ChecksumResult7))]
+    public async Task ResultsOfTResult1TResult2TResult3TResult4TResult5TResult6_AcceptsNestedResultsOfT_AsSecondTypeArg(int input, Type expectedResultType)
+    {
+        // Arrange
+        Results<Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>, ChecksumResult7> MyApi(int id)
+        {
+            return id switch
+            {
+                1 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>)new ChecksumResult1(1),
+                2 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>)new ChecksumResult2(2),
+                3 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>)new ChecksumResult3(3),
+                4 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>)new ChecksumResult4(4),
+                5 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>)new ChecksumResult5(5),
+                6 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>)new ChecksumResult6(6),
+                _ => new ChecksumResult7(7)
+            };
+        }
+        var httpContext = GetHttpContext();
+
+        // Act
+        var result = MyApi(input);
+        await result.ExecuteAsync(httpContext);
+        
+        // Assert
+        Assert.IsType(expectedResultType, result.Result);
+        Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);
+    }
+    
+    [Theory]
+    [InlineData(1, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>))]
+    [InlineData(2, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>))]
+    [InlineData(3, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>))]
+    [InlineData(4, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>))]
+    [InlineData(5, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>))]
+    [InlineData(6, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>))]
+    [InlineData(7, typeof(ChecksumResult7))]
+    public async Task ResultsOfTResult1TResult2TResult3TResult4TResult5TResult6_AcceptsNestedResultsOfT_AsThirdTypeArg(int input, Type expectedResultType)
+    {
+        // Arrange
+        Results<Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>, ChecksumResult7> MyApi(int id)
+        {
+            return id switch
+            {
+                1 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>)new ChecksumResult1(1),
+                2 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>)new ChecksumResult2(2),
+                3 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>)new ChecksumResult3(3),
+                4 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>)new ChecksumResult4(4),
+                5 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>)new ChecksumResult5(5),
+                6 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>)new ChecksumResult6(6),
+                _ => new ChecksumResult7(7)
+            };
+        }
+        var httpContext = GetHttpContext();
+
+        // Act
+        var result = MyApi(input);
+        await result.ExecuteAsync(httpContext);
+        
+        // Assert
+        Assert.IsType(expectedResultType, result.Result);
+        Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);
+    }
+    
+    [Theory]
+    [InlineData(1, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>))]
+    [InlineData(2, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>))]
+    [InlineData(3, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>))]
+    [InlineData(4, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>))]
+    [InlineData(5, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>))]
+    [InlineData(6, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>))]
+    [InlineData(7, typeof(ChecksumResult7))]
+    public async Task ResultsOfTResult1TResult2TResult3TResult4TResult5TResult6_AcceptsNestedResultsOfT_AsFourthTypeArg(int input, Type expectedResultType)
+    {
+        // Arrange
+        Results<Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>, ChecksumResult7> MyApi(int id)
+        {
+            return id switch
+            {
+                1 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>)new ChecksumResult1(1),
+                2 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>)new ChecksumResult2(2),
+                3 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>)new ChecksumResult3(3),
+                4 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>)new ChecksumResult4(4),
+                5 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>)new ChecksumResult5(5),
+                6 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>)new ChecksumResult6(6),
+                _ => new ChecksumResult7(7)
+            };
+        }
+        var httpContext = GetHttpContext();
+
+        // Act
+        var result = MyApi(input);
+        await result.ExecuteAsync(httpContext);
+        
+        // Assert
+        Assert.IsType(expectedResultType, result.Result);
+        Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);
+    }
+    
+    [Theory]
+    [InlineData(1, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>))]
+    [InlineData(2, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>))]
+    [InlineData(3, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>))]
+    [InlineData(4, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>))]
+    [InlineData(5, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>))]
+    [InlineData(6, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>))]
+    [InlineData(7, typeof(ChecksumResult7))]
+    public async Task ResultsOfTResult1TResult2TResult3TResult4TResult5TResult6_AcceptsNestedResultsOfT_AsFifthTypeArg(int input, Type expectedResultType)
+    {
+        // Arrange
+        Results<Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>, ChecksumResult7> MyApi(int id)
+        {
+            return id switch
+            {
+                1 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>)new ChecksumResult1(1),
+                2 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>)new ChecksumResult2(2),
+                3 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>)new ChecksumResult3(3),
+                4 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>)new ChecksumResult4(4),
+                5 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>)new ChecksumResult5(5),
+                6 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>)new ChecksumResult6(6),
+                _ => new ChecksumResult7(7)
+            };
+        }
+        var httpContext = GetHttpContext();
+
+        // Act
+        var result = MyApi(input);
+        await result.ExecuteAsync(httpContext);
+        
+        // Assert
+        Assert.IsType(expectedResultType, result.Result);
+        Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);
+    }
+    
+    [Theory]
+    [InlineData(1, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>))]
+    [InlineData(2, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>))]
+    [InlineData(3, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>))]
+    [InlineData(4, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>))]
+    [InlineData(5, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>))]
+    [InlineData(6, typeof(Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>))]
+    [InlineData(7, typeof(ChecksumResult7))]
+    public async Task ResultsOfTResult1TResult2TResult3TResult4TResult5TResult6_AcceptsNestedResultsOfT_AsSixthTypeArg(int input, Type expectedResultType)
+    {
+        // Arrange
+        Results<Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>, ChecksumResult7> MyApi(int id)
+        {
+            return id switch
+            {
+                1 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>)new ChecksumResult1(1),
+                2 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>)new ChecksumResult2(2),
+                3 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>)new ChecksumResult3(3),
+                4 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>)new ChecksumResult4(4),
+                5 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>)new ChecksumResult5(5),
+                6 => (Results<ChecksumResult1, ChecksumResult2, ChecksumResult3, ChecksumResult4, ChecksumResult5, ChecksumResult6>)new ChecksumResult6(6),
+                _ => new ChecksumResult7(7)
+            };
+        }
+        var httpContext = GetHttpContext();
+
+        // Act
+        var result = MyApi(input);
+        await result.ExecuteAsync(httpContext);
+        
+        // Assert
+        Assert.IsType(expectedResultType, result.Result);
+        Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);
+    }
+    
+    abstract class ChecksumResult : IResult
+    {
+        public ChecksumResult(int checksum = 0)
+        {
+            Checksum = checksum;
+        }
+
+        public int Checksum { get; }
+
+        public Task ExecuteAsync(HttpContext httpContext)
+        {
+            httpContext.Items[nameof(ChecksumResult.Checksum)] = Checksum;
+            return Task.CompletedTask;
+        }
+    }
+
+    class ChecksumResult1 : ChecksumResult
+    {
+        public ChecksumResult1(int checksum = 0) : base(checksum) { }
+    }
+
+    class ChecksumResult2 : ChecksumResult
+    {
+        public ChecksumResult2(int checksum = 0) : base(checksum) { }
+    }
+
+    class ChecksumResult3 : ChecksumResult
+    {
+        public ChecksumResult3(int checksum = 0) : base(checksum) { }
+    }
+
+    class ChecksumResult4 : ChecksumResult
+    {
+        public ChecksumResult4(int checksum = 0) : base(checksum) { }
+    }
+
+    class ChecksumResult5 : ChecksumResult
+    {
+        public ChecksumResult5(int checksum = 0) : base(checksum) { }
+    }
+
+    class ChecksumResult6 : ChecksumResult
+    {
+        public ChecksumResult6(int checksum = 0) : base(checksum) { }
+    }
+    class ChecksumResult7 : ChecksumResult
+    {
+        public ChecksumResult7(int checksum = 0) : base(checksum) { }
+    }
+
+}

src/Http/Http.Results/test/ResultsOfTTests.cs

@@ -0,0 +1,86 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.AspNetCore.Http.Result;
+
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
+using Xunit.Abstractions;
+
+public partial class ResultsOfTTests
+{
+    private readonly ITestOutputHelper _output;
+
+    public ResultsOfTTests(ITestOutputHelper output)
+    {
+        _output = output;
+    }
+
+    [Fact]
+    public void GeneratedCodeIsUpToDate()
+    {
+        // This assumes the output is in the repo artifacts directory
+        var resultsOfTGeneratedPath = Path.Combine(AppContext.BaseDirectory, "Shared", "GeneratedContent", "ResultsOfT.cs");
+        var testsGeneratedPath = Path.Combine(AppContext.BaseDirectory, "Shared", "GeneratedContent", "ResultsOfTTests.Generated.cs");
+
+        var testResultsOfTGeneratedPath = Path.GetTempFileName();
+        var testTestsGeneratedPath = Path.GetTempFileName();
+
+        try
+        {
+            var currentResultsOfTGenerated = File.ReadAllText(resultsOfTGeneratedPath);
+            var currentTestsGenerated = File.ReadAllText(testsGeneratedPath);
+
+            ResultsOfTGenerator.Program.Run(testResultsOfTGeneratedPath, testTestsGeneratedPath);
+
+            var testResultsOfTGenerated = File.ReadAllText(testResultsOfTGeneratedPath);
+            var testTestsGenerated = File.ReadAllText(testTestsGeneratedPath);
+
+            AssertFileContentEqual(currentResultsOfTGenerated, testResultsOfTGenerated, "ResultsOfT.cs");
+            AssertFileContentEqual(currentTestsGenerated, testTestsGenerated, "ResultsOfTTests.Generated.cs");
+        }
+        finally
+        {
+            File.Delete(testResultsOfTGeneratedPath);
+            File.Delete(testTestsGeneratedPath);
+        }
+    }
+
+    private static IServiceCollection CreateServices()
+    {
+        var services = new ServiceCollection();
+        services.AddSingleton<ILoggerFactory>(NullLoggerFactory.Instance);
+        services.AddSingleton(typeof(ILogger<>), typeof(NullLogger<>));
+        return services;
+    }
+
+    private static HttpContext GetHttpContext()
+    {
+        var services = CreateServices();
+
+        var httpContext = new DefaultHttpContext
+        {
+            RequestServices = services.BuildServiceProvider()
+        };
+
+        return httpContext;
+    }
+
+    private void AssertFileContentEqual(string expected, string actual, string type)
+    {
+        try
+        {
+            Assert.Equal(expected.Trim(), actual.Trim(), ignoreLineEndingDifferences: true);
+        }
+        catch (Exception)
+        {
+            _output.WriteLine($"Error when comparing {type}.");
+            _output.WriteLine("Expected:");
+            _output.WriteLine(expected);
+            _output.WriteLine("Actual:");
+            _output.WriteLine(actual);
+            throw;
+        }
+    }
+}

src/Http/Http.Results/tools/ResultsOfTGenerator/Program.cs

@@ -0,0 +1,904 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Globalization;
+using System.Text;
+
+namespace ResultsOfTGenerator;
+
+public class Program
+{
+    private const int TYPE_ARG_COUNT = 6;
+
+    public static void Main(string[] args)
+    {
+        // By default we assume we're being run in the context of the <repo>/src/Http/Http.Results/src
+        var pwd = Directory.GetCurrentDirectory();
+        var classTargetFilePath = Path.Combine(pwd, "ResultsOfT.cs");
+        var testsTargetFilePath = Path.Combine(pwd, "..", "test", "ResultsOfTTests.Generated.cs");
+
+        if (args.Length > 0)
+        {
+            if (args.Length != 2)
+            {
+                throw new ArgumentException("Invalid number of args specified. Must specify both class file path and test file path if args are passed.");
+            }
+
+            classTargetFilePath = args[0];
+            testsTargetFilePath = args[1];
+        }
+
+        GenerateClassFile(classTargetFilePath, TYPE_ARG_COUNT, args.Length == 0);
+
+        GenerateTestFiles(testsTargetFilePath, TYPE_ARG_COUNT, args.Length == 0);
+    }
+
+    public static void Run(string classFilePath, string testsFilePath)
+    {
+        GenerateClassFile(classFilePath, TYPE_ARG_COUNT, false);
+
+        GenerateTestFiles(testsFilePath, TYPE_ARG_COUNT, false);
+    }
+
+    static void GenerateClassFile(string classFilePath, int typeArgCount, bool interactive = true)
+    {
+        Console.WriteLine($"Will generate class file at {classFilePath}");
+
+        if (interactive)
+        {
+            Console.WriteLine("Press any key to continue or Ctrl-C to cancel");
+            Console.ReadKey();
+        }
+
+        using var writer = new StreamWriter(classFilePath, append: false);
+
+        // File header
+        writer.WriteLine("// Licensed to the .NET Foundation under one or more agreements.");
+        writer.WriteLine("// The .NET Foundation licenses this file to you under the MIT license.");
+        writer.WriteLine();
+        writer.WriteLine("// This file is generated by a tool. See: src/Http/Http.Results/tools/ResultsOfTGenerator");
+
+        // Namespace
+        writer.WriteLine("namespace Microsoft.AspNetCore.Http;");
+        writer.WriteLine();
+
+        // Skip 1 as we don't have a Results<TResult1> class
+        for (int i = 2; i <= typeArgCount; i++)
+        {
+            // Class summary doc
+            writer.WriteLine("/// <summary>");
+            writer.WriteLine($"/// An <see cref=\"IResult\"/> that could be one of {i.ToWords()} different <see cref=\"IResult\"/> types. On execution will");
+            writer.WriteLine("/// execute the underlying <see cref=\"IResult\"/> instance that was actually returned by the HTTP endpoint.");
+            writer.WriteLine("/// </summary>");
+
+            // Class remarks doc
+            writer.WriteLine("/// <remarks>");
+            writer.WriteLine("/// An instance of this type cannot be created explicitly. Use the implicit cast operators to create an instance");
+            writer.WriteLine("/// from an instance of one of the declared type arguments, e.g.");
+            writer.WriteLine("/// <code>Results&lt;OkObjectHttpResult, ProblemHttpResult&gt; result = Results.Ok();</code>");
+            writer.WriteLine("/// </remarks>");
+
+            // Type params docs
+            for (int j = 1; j <= i; j++)
+            {
+                writer.WriteLine(@$"/// <typeparam name=""TResult{j}"">The {j.ToOrdinalWords()} result type.</typeparam>");
+            }
+
+            // Class declaration
+            writer.Write($"public sealed class Results<");
+
+            // Type args
+            for (int j = 1; j <= i; j++)
+            {
+                writer.Write($"TResult{j}");
+                if (j != i)
+                {
+                    writer.Write(", ");
+                }
+            }
+
+            writer.WriteLine("> : IResult");
+
+            // Type arg contraints
+            for (int j = 1; j <= i; j++)
+            {
+                writer.WriteIndent($"where TResult{j} : IResult");
+                if (j != i)
+                {
+                    writer.WriteLine();
+                }
+            }
+            writer.WriteLine();
+            writer.WriteLine("{");
+
+            // Ctor
+            writer.WriteIndentedLine("// Use implicit cast operators to create an instance");
+            writer.WriteIndentedLine($"private Results(IResult activeResult)");
+            writer.WriteIndentedLine("{");
+            writer.WriteIndentedLine(2, "Result = activeResult;");
+            writer.WriteIndentedLine("}");
+            writer.WriteLine();
+
+            // Result property
+            writer.WriteIndentedLine("/// <summary>");
+            writer.WriteIndentedLine($"/// Gets the actual <see cref=\"IResult\"/> returned by the <see cref=\"Endpoint\"/> route handler delegate.");
+            writer.WriteIndentedLine("/// </summary>");
+            writer.WriteIndentedLine("public IResult Result { get; }");
+            writer.WriteLine();
+
+            // ExecuteAsync method
+            writer.WriteIndentedLine("/// <inheritdoc/>");
+            writer.WriteIndentedLine("public Task ExecuteAsync(HttpContext httpContext)");
+            writer.WriteIndentedLine("{");
+            writer.WriteIndentedLine(2, "ArgumentNullException.ThrowIfNull(httpContext, nameof(httpContext));");
+            writer.WriteLine();
+            writer.WriteIndentedLine(2, "if (Result is null)");
+            writer.WriteIndentedLine(2, "{");
+            writer.WriteIndentedLine(3, "throw new InvalidOperationException(\"The IResult assigned to the Result property must not be null.\");");
+            writer.WriteIndentedLine(2, "}");
+            writer.WriteLine();
+            writer.WriteIndentedLine(2, "return Result.ExecuteAsync(httpContext);");
+            writer.WriteIndentedLine("}");
+            writer.WriteLine();
+
+            // Implicit converter operators
+            var sb = new StringBuilder();
+            for (int j = 1; j <= i; j++)
+            {
+                sb.AppendFormat(CultureInfo.InvariantCulture, "TResult{0}", j);
+                if (j != i)
+                {
+                    sb.Append(", ");
+                }
+            }
+            var typeArgsList = sb.ToString();
+
+            for (int j = 1; j <= i; j++)
+            {
+                writer.WriteIndentedLine("/// <summary>");
+                writer.WriteIndentedLine($"/// Converts the <typeparamref name=\"TResult{j}\"/> to a <see cref=\"Results{{{typeArgsList}}}\" />.");
+                writer.WriteIndentedLine("/// </summary>");
+                writer.WriteIndentedLine("/// <param name=\"result\">The result.</param>");
+                writer.WriteIndentedLine($"public static implicit operator Results<{typeArgsList}>(TResult{j} result) => new(result);");
+
+                if (i != j)
+                {
+                    writer.WriteLine();
+                }
+            }
+
+            // Class end
+            writer.WriteLine("}");
+
+            if (i != typeArgCount)
+            {
+                writer.WriteLine();
+            }
+        }
+
+        writer.Flush();
+        writer.Close();
+
+        var file = new FileInfo(classFilePath);
+
+        if (!file.Exists)
+        {
+            throw new FileNotFoundException(classFilePath);
+        }
+
+        Console.WriteLine();
+        Console.WriteLine($"{file.Length:N0} bytes written to {file.FullName} successfully!");
+        Console.WriteLine();
+    }
+
+    static void GenerateTestFiles(string testFilePath, int typeArgCount, bool interactive = true)
+    {
+        Console.WriteLine($"Will generate tests file at {testFilePath}");
+
+        if (interactive)
+        {
+            Console.WriteLine("Press any key to continue or Ctrl-C to cancel");
+            Console.ReadKey();
+        }
+
+        using var writer = new StreamWriter(testFilePath, append: false);
+
+        // File header
+        writer.WriteLine("// Licensed to the .NET Foundation under one or more agreements.");
+        writer.WriteLine("// The .NET Foundation licenses this file to you under the MIT license.");
+        writer.WriteLine();
+        writer.WriteLine("// This file is generated by a tool. See: src/Http/Http.Results/tools/ResultsOfTGenerator");
+
+        // Namespace
+        writer.WriteLine("namespace Microsoft.AspNetCore.Http.Result;");
+        writer.WriteLine();
+
+        // Using statements
+        writer.WriteLine("using System.Threading.Tasks;");
+        writer.WriteLine("using Microsoft.Extensions.DependencyInjection;");
+        writer.WriteLine("using Microsoft.Extensions.Logging;");
+        writer.WriteLine("using Microsoft.Extensions.Logging.Abstractions;");
+        writer.WriteLine();
+
+        // Class declaration
+        writer.WriteLine($"public partial class ResultsOfTTests");
+        writer.WriteLine("{");
+
+        for (int i = 1; i <= typeArgCount; i++)
+        {
+            // Skip first as we don't have a Results<TResult1> class
+            if (i == 1)
+            {
+                continue;
+            }
+
+            GenerateTest_Result_IsAssignedResult(writer, i);
+            GenerateTest_ExecuteResult_ExecutesAssignedResult(writer, i);
+            GenerateTest_Throws_ArgumentNullException_WhenHttpContextIsNull(writer, i);
+            GenerateTest_Throws_InvalidOperationException_WhenResultIsNull(writer, i);
+            Generate_AcceptsIResult_AsAnyTypeArg(writer, i);
+            Generate_AcceptsNestedResultsOfT_AsAnyTypeArg(writer, i);
+        }
+
+        Generate_ChecksumResultClass(writer);
+
+        // CustomResult classes
+        writer.WriteLine();
+        for (int i = 1; i <= typeArgCount + 1; i++)
+        {
+            Generate_ChecksumResultClass(writer, i);
+
+            if (i != typeArgCount)
+            {
+                writer.WriteLine();
+            }
+        }
+
+        // End test class
+        writer.WriteLine("}");
+
+        writer.Flush();
+        writer.Close();
+
+        var file = new FileInfo(testFilePath);
+
+        if (!file.Exists)
+        {
+            throw new FileNotFoundException(testFilePath);
+        }
+
+        Console.WriteLine();
+        Console.WriteLine($"{file.Length:N0} bytes written to {file.FullName} successfully!");
+    }
+
+    static void GenerateTest_Result_IsAssignedResult(StreamWriter writer, int typeArgNumber)
+    {
+        //[Theory]
+        //[InlineData(1, typeof(ChecksumResult1))]
+        //[InlineData(2, typeof(ChecksumResult2))]
+        //public void ResultsOfTResult1TResult2_Result_IsAssignedResult(int input, Type expectedResultType)
+        //{
+        //    // Arrange
+        //    Results<CustomResult1, CustomResult2> MyApi(int id)
+        //    {
+        //        return id switch
+        //        {
+        //            1 => new CustomResult1(),
+        //            _ => new CustomResult2()
+        //        };
+        //    }
+
+        //    // Act
+        //    var result = MyApi(input);
+
+        //    // Assert
+        //    Assert.IsType(expectedResultType, result.Result);
+        //}
+
+        // Attributes
+        writer.WriteIndentedLine("[Theory]");
+
+        // InlineData
+        for (int j = 1; j <= typeArgNumber; j++)
+        {
+            writer.WriteIndentedLine($"[InlineData({j}, typeof(ChecksumResult{j}))]");
+        }
+
+        // Method
+        writer.WriteIndent(1, "public void ResultsOf");
+        for (int j = 1; j <= typeArgNumber; j++)
+        {
+            writer.Write($"TResult{j}");
+        }
+        writer.WriteLine("_Result_IsAssignedResult(int input, Type expectedResultType)");
+        writer.WriteIndentedLine("{");
+
+        // Arrange
+        writer.WriteIndentedLine(2, "// Arrange");
+        writer.WriteIndent(2, "Results<");
+        for (int j = 1; j <= typeArgNumber; j++)
+        {
+            writer.Write($"ChecksumResult{j}");
+            if (typeArgNumber != j)
+            {
+                writer.Write(", ");
+            }
+        }
+        writer.WriteLine("> MyApi(int id)");
+        writer.WriteIndentedLine(2, "{");
+        writer.WriteIndentedLine(3, "return id switch");
+        writer.WriteIndentedLine(3, "{");
+        for (int j = 1; j <= typeArgNumber; j++)
+        {
+            if (j != typeArgNumber)
+            {
+                writer.WriteIndentedLine(4, $"{j} => new ChecksumResult{j}(),");
+            }
+            else
+            {
+                writer.WriteIndentedLine(4, $"_ => new ChecksumResult{j}()");
+            }
+        }
+        writer.WriteIndentedLine(3, "};");
+        writer.WriteIndentedLine(2, "}");
+        writer.WriteLine();
+
+        // Act
+        writer.WriteIndentedLine(2, "// Act");
+        writer.WriteIndentedLine(2, "var result = MyApi(input);");
+        writer.WriteLine();
+
+        // Assert
+        writer.WriteIndentedLine(2, "// Assert");
+        writer.WriteIndentedLine(2, "Assert.IsType(expectedResultType, result.Result);");
+
+        // End of method
+        writer.WriteIndentedLine("}");
+        writer.WriteLine();
+    }
+
+    static void GenerateTest_ExecuteResult_ExecutesAssignedResult(StreamWriter writer, int typeArgNumber)
+    {
+        //[Theory]
+        //[InlineData(1, 1)]
+        //[InlineData(2, 2)]
+        //[InlineData(-1, null)]
+        //public async Task ResultsOfTResult1TResult2_ExecuteResult_ExecutesAssignedResult(int input, object expected)
+        //{
+        //    // Arrange
+        //    Results<ChecksumResult1, ChecksumResult2, NoContentHttpResult> MyApi(int checksum)
+        //    {
+        //        return checksum switch
+        //        {
+        //            1 => new ChecksumResult1(checksum),
+        //            2 => new ChecksumResult2(checksum),
+        //            _ => (NoContentHttpResult)Results.NoContent()
+        //        };
+        //    }
+        //    var httpContext = GetHttpContext();
+
+        //    // Act
+        //    var result = MyApi(input);
+        //    await result.ExecuteAsync(httpContext);
+
+        //    // Assert
+        //    Assert.Equal(expected, httpContext.Items[nameof(ChecksumResult.Checksum)]);
+        //}
+
+        // Attributes
+        writer.WriteIndentedLine("[Theory]");
+
+        // InlineData
+        for (int j = 1; j <= typeArgNumber; j++)
+        {
+            writer.WriteIndentedLine($"[InlineData({j})]");
+        }
+
+        // Method
+        // public void ResultsOfTResult1TResult2_ExecuteResult_ExecutesAssignedResult(int input, object expected)
+        writer.WriteIndent(1, "public async Task ResultsOf");
+        for (int j = 1; j <= typeArgNumber; j++)
+        {
+            writer.Write($"TResult{j}");
+        }
+        writer.WriteLine("_ExecuteResult_ExecutesAssignedResult(int input)");
+        writer.WriteIndentedLine("{");
+
+        // Arrange
+        writer.WriteIndentedLine(2, "// Arrange");
+        writer.WriteIndent(2, "Results<");
+        for (int j = 1; j <= typeArgNumber; j++)
+        {
+            writer.Write($"ChecksumResult{j}");
+            if (typeArgNumber != j)
+            {
+                writer.Write(", ");
+            }
+        }
+        writer.WriteLine("> MyApi(int checksum)");
+        writer.WriteIndentedLine(2, "{");
+        writer.WriteIndentedLine(3, "return checksum switch");
+        writer.WriteIndentedLine(3, "{");
+        for (int j = 1; j <= typeArgNumber; j++)
+        {
+            if (j < typeArgNumber)
+            {
+                writer.WriteIndentedLine(4, $"{j} => new ChecksumResult{j}(checksum),");
+            }
+            else
+            {
+                writer.WriteIndentedLine(4, $"_ => new ChecksumResult{j}(checksum)");
+            }
+        }
+        writer.WriteIndentedLine(3, "};");
+        writer.WriteIndentedLine(2, "}");
+        writer.WriteIndentedLine(2, "var httpContext = GetHttpContext();");
+        writer.WriteLine();
+
+        // Act
+        writer.WriteIndentedLine(2, "// Act");
+        writer.WriteIndentedLine(2, "var result = MyApi(input);");
+        writer.WriteIndentedLine(2, "await result.ExecuteAsync(httpContext);");
+        writer.WriteLine();
+
+        // Assert
+        writer.WriteIndentedLine(2, "// Assert");
+        writer.WriteIndentedLine(2, "Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);");
+
+        // End of method
+        writer.WriteIndentedLine("}");
+        writer.WriteLine();
+    }
+
+    static void GenerateTest_Throws_ArgumentNullException_WhenHttpContextIsNull(StreamWriter writer, int typeArgNumber)
+    {
+        //[Fact]
+        //public void ResultsOfTResult1TResult2_Throws_ArgumentNullException_WhenHttpContextIsNull()
+        //{
+        //    // Arrange
+        //    Results<ChecksumResult1, NoContentHttpResult> MyApi()
+        //    {
+        //        return new ChecksumResult1(1);
+        //    }
+        //    HttpContext httpContext = null;
+
+        //    // Act & Assert
+        //    var result = MyApi();
+
+        //    Assert.ThrowsAsync<ArgumentNullException>(async () =>
+        //    {
+        //        await result.ExecuteAsync(httpContext);
+        //    });
+        //}
+
+        // Attributes
+        writer.WriteIndentedLine("[Fact]");
+
+        // Start method
+        writer.WriteIndent(1, "public void ResultsOf");
+        for (int j = 1; j <= typeArgNumber; j++)
+        {
+            writer.Write($"TResult{j}");
+        }
+        writer.WriteLine("_Throws_ArgumentNullException_WhenHttpContextIsNull()");
+        writer.WriteIndentedLine("{");
+
+        // Arrange
+        writer.WriteIndentedLine(2, "// Arrange");
+        writer.WriteIndentedLine(2, "Results<ChecksumResult1, NoContentHttpResult> MyApi()");
+        writer.WriteIndentedLine(2, "{");
+        writer.WriteIndentedLine(3, "return new ChecksumResult1(1);");
+        writer.WriteIndentedLine(2, "}");
+        writer.WriteIndentedLine(2, "HttpContext httpContext = null;");
+        writer.WriteIndentedLine(2);
+
+        // Act & Assert
+        writer.WriteIndentedLine(2, "// Act & Assert");
+        writer.WriteIndentedLine(2, "var result = MyApi();");
+        writer.WriteIndentedLine(2);
+
+        writer.WriteIndentedLine(2, "Assert.ThrowsAsync<ArgumentNullException>(async () =>");
+        writer.WriteIndentedLine(2, "{");
+        writer.WriteIndentedLine(3, "await result.ExecuteAsync(httpContext);");
+        writer.WriteIndentedLine(2, "});");
+
+        // Close method
+        writer.WriteIndentedLine(1, "}");
+        writer.WriteIndentedLine();
+    }
+
+    static void GenerateTest_Throws_InvalidOperationException_WhenResultIsNull(StreamWriter writer, int typeArgNumber)
+    {
+        //[Fact]
+        //public void ResultsOfTResult1TResult2_Throws_InvalidOperationException_WhenResultIsNull()
+        //{
+        //    // Arrange
+        //    Results<ChecksumResult1, NoContentHttpResult> MyApi()
+        //    {
+        //        return (ChecksumResult1)null;
+        //    }
+        //    var httpContext = GetHttpContext();
+
+        //    // Act & Assert
+        //    var result = MyApi();
+
+        //    Assert.ThrowsAsync<InvalidOperationException>(async () =>
+        //    {
+        //        await result.ExecuteAsync(httpContext);
+        //    });
+        //}
+
+        // Attributes
+        writer.WriteIndentedLine("[Fact]");
+
+        // Start method
+        writer.WriteIndent(1, "public void ResultsOf");
+        for (int j = 1; j <= typeArgNumber; j++)
+        {
+            writer.Write($"TResult{j}");
+        }
+        writer.WriteLine("_Throws_InvalidOperationException_WhenResultIsNull()");
+        writer.WriteIndentedLine("{");
+
+        // Arrange
+        writer.WriteIndentedLine(2, "// Arrange");
+        writer.WriteIndentedLine(2, "Results<ChecksumResult1, NoContentHttpResult> MyApi()");
+        writer.WriteIndentedLine(2, "{");
+        writer.WriteIndentedLine(3, "return new ChecksumResult1(1);");
+        writer.WriteIndentedLine(2, "}");
+        writer.WriteIndentedLine(2, "var httpContext = GetHttpContext();");
+        writer.WriteIndentedLine(2);
+
+        // Act & Assert
+        writer.WriteIndentedLine(2, "// Act & Assert");
+        writer.WriteIndentedLine(2, "var result = MyApi();");
+        writer.WriteIndentedLine(2);
+
+        writer.WriteIndentedLine(2, "Assert.ThrowsAsync<InvalidOperationException>(async () =>");
+        writer.WriteIndentedLine(2, "{");
+        writer.WriteIndentedLine(3, "await result.ExecuteAsync(httpContext);");
+        writer.WriteIndentedLine(2, "});");
+
+        // Close method
+        writer.WriteIndentedLine(1, "}");
+        writer.WriteIndentedLine();
+    }
+
+    static void Generate_AcceptsIResult_AsAnyTypeArg(StreamWriter writer, int typeArgCount)
+    {
+        for (int i = 1; i <= typeArgCount; i++)
+        {
+            Generate_AcceptsIResult_AsNthTypeArg(writer, typeArgCount, i);
+        }
+    }
+
+    static void Generate_AcceptsIResult_AsNthTypeArg(StreamWriter writer, int typeArgCount, int typeArgNumber)
+    {
+        //[Theory]
+        //[InlineData(1, typeof(ChecksumResult1))]
+        //[InlineData(2, typeof(ChecksumResult2))]
+        //public async Task ResultsOfTResult1TResult2_AcceptsIResult_AsFirstTypeArg(int input, Type expectedResultType)
+        //{
+        //    // Arrange
+        //    Results<IResult, ChecksumResult2> MyApi(int id)
+        //    {
+        //        return id switch
+        //        {
+        //            1 => new ChecksumResult1(1),
+        //            _ => new ChecksumResult2(2)
+        //        };
+        //    }
+        //    var httpContext = GetHttpContext();
+
+        //    // Act
+        //    var result = MyApi(input);
+        //    await result.ExecuteAsync(httpContext);
+
+        //    // Assert
+        //    Assert.IsType(expectedResultType, result.Result);
+        //    Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);
+        //}
+
+        // Attributes
+        writer.WriteIndentedLine("[Theory]");
+
+        // InlineData
+        for (int j = 1; j <= typeArgCount; j++)
+        {
+            writer.WriteIndentedLine($"[InlineData({j}, typeof(ChecksumResult{j}))]");
+        }
+
+        // Start method
+        writer.WriteIndent(1, "public async Task ResultsOf");
+        for (int j = 1; j <= typeArgCount; j++)
+        {
+            writer.Write($"TResult{j}");
+        }
+        writer.WriteLine($"_AcceptsIResult_As{typeArgNumber.ToOrdinalWords().TitleCase()}TypeArg(int input, Type expectedResultType)");
+        writer.WriteIndentedLine("{");
+
+        // Arrange
+        writer.WriteIndentedLine(2, "// Arrange");
+        writer.WriteIndent(2, "Results<");
+        for (int j = 1; j <= typeArgCount; j++)
+        {
+            if (j == typeArgNumber)
+            {
+                writer.Write("IResult");
+            }
+            else
+            {
+                writer.Write($"ChecksumResult{j}");
+            }
+
+            if (j < typeArgCount)
+            {
+                writer.Write(", ");
+            }
+        }
+        writer.WriteLine("> MyApi(int id)");
+        writer.WriteIndentedLine(2, "{");
+        writer.WriteIndentedLine(3, "return id switch");
+        writer.WriteIndentedLine(3, "{");
+        for (int j = 1; j <= typeArgCount; j++)
+        {
+            if (j < typeArgCount)
+            {
+                writer.WriteIndentedLine(4, $"{j} => new ChecksumResult{j}({j}),");
+            }
+            else
+            {
+                writer.WriteIndentedLine(4, $"_ => new ChecksumResult{j}({j})");
+            }
+        }
+        writer.WriteIndentedLine(3, "};");
+        writer.WriteIndentedLine(2, "}");
+        writer.WriteIndentedLine(2, "var httpContext = GetHttpContext();");
+        writer.WriteLine();
+
+        // Act
+        writer.WriteIndentedLine(2, "// Act");
+        writer.WriteIndentedLine(2, "var result = MyApi(input);");
+        writer.WriteIndentedLine(2, "await result.ExecuteAsync(httpContext);");
+        writer.WriteIndentedLine(2);
+
+        // Assert
+        writer.WriteIndentedLine(2, "// Assert");
+        writer.WriteIndentedLine(2, "Assert.IsType(expectedResultType, result.Result);");
+        writer.WriteIndentedLine(2, "Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);");
+
+        // Close method
+        writer.WriteIndentedLine(1, "}");
+        writer.WriteIndentedLine();
+    }
+
+    static void Generate_AcceptsNestedResultsOfT_AsAnyTypeArg(StreamWriter writer, int typeArgCount)
+    {
+        for (int i = 1; i <= typeArgCount; i++)
+        {
+            Generate_AcceptsNestedResultsOfT_AsNthTypeArg(writer, typeArgCount, i);
+        }
+    }
+
+    static void Generate_AcceptsNestedResultsOfT_AsNthTypeArg(StreamWriter writer, int typeArgCount, int typeArgNumber)
+    {
+        //[Theory]
+        //[InlineData(1, typeof(Results<ChecksumResult1, ChecksumResult2>))]
+        //[InlineData(2, typeof(Results<ChecksumResult1, ChecksumResult2>))]
+        //[InlineData(3, typeof(ChecksumResult3))]
+        //public async Task ResultsOfTResult1TResult2_AcceptsNestedResultsOfT_AsFirstTypeArg(int input, Type expectedResultType)
+        //{
+        //    // Arrange
+        //    Results<Results<ChecksumResult1, ChecksumResult2>, ChecksumResult3> MyApi(int id)
+        //    {
+        //        return id switch
+        //        {
+        //            1 => (Results<ChecksumResult1, ChecksumResult2>)new ChecksumResult1(1),
+        //            2 => (Results<ChecksumResult1, ChecksumResult2>)new ChecksumResult2(2),
+        //            _ => new ChecksumResult3(3)
+        //        };
+        //    }
+        //    var httpContext = GetHttpContext();
+
+        //    // Act
+        //    var result = MyApi(input);
+        //    await result.ExecuteAsync(httpContext);
+
+        //    // Assert
+        //    Assert.IsType(expectedResultType, result.Result);
+        //    Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);
+        //}
+
+        var sb = new StringBuilder("Results<");
+        for (int j = 1; j <= typeArgCount; j++)
+        {
+            sb.Append(CultureInfo.InvariantCulture, $"ChecksumResult{j}");
+
+            if (j < typeArgCount)
+            {
+                sb.Append(", ");
+            }
+        }
+        sb.Append('>');
+        var nestedResultTypeName = sb.ToString();
+
+        // Attributes
+        writer.WriteIndentedLine("[Theory]");
+
+        // InlineData
+        for (int j = 1; j <= typeArgCount + 1; j++)
+        {
+            if (j <= typeArgCount)
+            {
+                writer.WriteIndentedLine($"[InlineData({j}, typeof({nestedResultTypeName}))]");
+            }
+            else
+            {
+                writer.WriteIndentedLine($"[InlineData({j}, typeof(ChecksumResult{j}))]");
+            }
+        }
+
+        // Start method
+        writer.WriteIndent(1, "public async Task ResultsOf");
+        for (int j = 1; j <= typeArgCount; j++)
+        {
+            writer.Write($"TResult{j}");
+        }
+        writer.WriteLine($"_AcceptsNestedResultsOfT_As{typeArgNumber.ToOrdinalWords().TitleCase()}TypeArg(int input, Type expectedResultType)");
+        writer.WriteIndentedLine("{");
+
+        // Arrange
+        writer.WriteIndentedLine(2, "// Arrange");
+        writer.WriteIndent(2, "Results<");
+        writer.WriteLine($"{nestedResultTypeName}, ChecksumResult{typeArgCount + 1}> MyApi(int id)");
+        writer.WriteIndentedLine(2, "{");
+        writer.WriteIndentedLine(3, "return id switch");
+        writer.WriteIndentedLine(3, "{");
+        for (int j = 1; j <= typeArgCount; j++)
+        {
+            writer.WriteIndentedLine(4, $"{j} => ({nestedResultTypeName})new ChecksumResult{j}({j}),");
+        }
+        writer.WriteIndentedLine(4, $"_ => new ChecksumResult{typeArgCount + 1}({typeArgCount + 1})");
+        writer.WriteIndentedLine(3, "};");
+        writer.WriteIndentedLine(2, "}");
+        writer.WriteIndentedLine(2, "var httpContext = GetHttpContext();");
+        writer.WriteLine();
+
+        // Act
+        writer.WriteIndentedLine(2, "// Act");
+        writer.WriteIndentedLine(2, "var result = MyApi(input);");
+        writer.WriteIndentedLine(2, "await result.ExecuteAsync(httpContext);");
+        writer.WriteIndentedLine(2);
+
+        // Assert
+        writer.WriteIndentedLine(2, "// Assert");
+        writer.WriteIndentedLine(2, "Assert.IsType(expectedResultType, result.Result);");
+        writer.WriteIndentedLine(2, "Assert.Equal(input, httpContext.Items[nameof(ChecksumResult.Checksum)]);");
+
+        // Close method
+        writer.WriteIndentedLine(1, "}");
+        writer.WriteIndentedLine();
+    }
+
+    static void Generate_ChecksumResultClass(StreamWriter writer, int typeArgNumber = -1)
+    {
+        if (typeArgNumber <= 0)
+        {
+            writer.WriteIndentedLine(1, "abstract class ChecksumResult : IResult");
+            writer.WriteIndentedLine(1, "{");
+            writer.WriteIndentedLine(2, "public ChecksumResult(int checksum = 0)");
+            writer.WriteIndentedLine(2, "{");
+            writer.WriteIndentedLine(3, "Checksum = checksum;");
+            writer.WriteIndentedLine(2, "}");
+            writer.WriteLine();
+            writer.WriteIndentedLine(2, "public int Checksum { get; }");
+            writer.WriteLine();
+            writer.WriteIndentedLine(2, "public Task ExecuteAsync(HttpContext httpContext)");
+            writer.WriteIndentedLine(2, "{");
+            writer.WriteIndentedLine(3, "httpContext.Items[nameof(ChecksumResult.Checksum)] = Checksum;");
+            writer.WriteIndentedLine(3, "return Task.CompletedTask;");
+            writer.WriteIndentedLine(2, "}");
+            writer.WriteIndentedLine(1, "}");
+        }
+        else
+        {
+            // ChecksumResult class
+            //class ChecksumResult1 : ChecksumResult
+            //{
+            //    public ChecksumResult1(int checksum = 0) : base(checksum) { }
+            //}
+            writer.WriteIndentedLine(1, $"class ChecksumResult{typeArgNumber} : ChecksumResult");
+            writer.WriteIndentedLine(1, "{");
+            writer.WriteIndentedLine(2, $"public ChecksumResult{typeArgNumber}(int checksum = 0) : base(checksum) {{ }}");
+            writer.WriteIndentedLine(1, "}");
+        }
+    }
+}
+public static class StringExtensions
+{
+    public static void WriteIndent(this StreamWriter writer, string? value = null)
+    {
+        WriteIndent(writer, 1, value);
+    }
+
+    public static void WriteIndent(this StreamWriter writer, int count, string? value = null)
+    {
+        for (var i = 1; i <= count; i++)
+        {
+            writer.Write("    ");
+        }
+
+        if (value != null)
+        {
+            writer.Write(value);
+        }
+    }
+
+    public static void WriteIndentedLine(this StreamWriter writer, string? value = null)
+    {
+        WriteIndentedLine(writer, 1, value);
+    }
+
+    public static void WriteIndentedLine(this StreamWriter writer, int count, string? value = null)
+    {
+        WriteIndent(writer, count, value);
+        writer.WriteLine();
+    }
+
+    public static string ToWords(this int number) => number switch
+    {
+        1 => "one",
+        2 => "two",
+        3 => "three",
+        4 => "four",
+        5 => "five",
+        6 => "six",
+        7 => "seven",
+        8 => "eight",
+        9 => "nine",
+        10 => "ten",
+        11 => "eleven",
+        12 => "twelve",
+        13 => "thirteen",
+        14 => "fourteen",
+        15 => "fifteen",
+        16 => "sixteen",
+        17 => "seventeen",
+        18 => "eighteen",
+        19 => "nineteen",
+        20 => "twenty",
+        _ => throw new NotImplementedException("Add more numbers")
+    };
+
+    public static string ToOrdinalWords(this int number) => number switch
+    {
+        1 => "first",
+        2 => "second",
+        3 => "third",
+        4 => "fourth",
+        5 => "fifth",
+        6 => "sixth",
+        7 => "seventh",
+        8 => "eighth",
+        9 => "ninth",
+        10 => "tenth",
+        11 => "eleventh",
+        12 => "twelfth",
+        13 => "thirteenth",
+        14 => "fourteenth",
+        15 => "fifteenth",
+        16 => "sixteenth",
+        17 => "seventeenth",
+        18 => "eighteenth",
+        19 => "nineteenth",
+        20 => "twentieth",
+        _ => throw new NotImplementedException("Add more numbers")
+    };
+
+    public static string TitleCase(this string value) => string.Create(value.Length, value, (c, s) =>
+    {
+        var origValueSpan = s.AsSpan();
+        c[0] = char.ToUpper(origValueSpan[0], CultureInfo.InvariantCulture);
+        origValueSpan[1..].TryCopyTo(c[1..]);
+    });
+}

src/Http/Http.Results/tools/ResultsOfTGenerator/Properties/launchSettings.json

@@ -0,0 +1,8 @@
+{
+  "profiles": {
+    "ResultsOfTGenerator": {
+      "commandName": "Project",
+      "workingDirectory": "$(ProjectDir)\\..\\..\\src\\"
+    }
+  }
+}

src/Http/Http.Results/tools/ResultsOfTGenerator/ResultsOfTGenerator.csproj

@@ -0,0 +1,10 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>$(DefaultNetCoreTargetFramework)</TargetFramework>
+    <Nullable>enable</Nullable>
+    <AddPublicApiAnalyzers>false</AddPublicApiAnalyzers>
+  </PropertyGroup>
+
+</Project>

src/Http/HttpAbstractions.slnf

@@ -21,6 +21,7 @@
       "src\\Http\\Http.Features\\src\\Microsoft.AspNetCore.Http.Features.csproj",
       "src\\Http\\Http.Results\\src\\Microsoft.AspNetCore.Http.Results.csproj",
       "src\\Http\\Http.Results\\test\\Microsoft.AspNetCore.Http.Results.Tests.csproj",
+      "src\\Http\\Http.Results\\tools\\ResultsOfTGenerator\\ResultsOfTGenerator.csproj",
       "src\\Http\\Http\\perf\\Microbenchmarks\\Microsoft.AspNetCore.Http.Microbenchmarks.csproj",
       "src\\Http\\Http\\src\\Microsoft.AspNetCore.Http.csproj",
       "src\\Http\\Http\\test\\Microsoft.AspNetCore.Http.Tests.csproj",

src/Http/README.md

@@ -15,6 +15,7 @@ The following contains a description of each sub-directory in the `Http` directo
 - [Http.Abstractions/](Http.Abstractions/): Contains HTTP object model for HTTP requests and responses and also common extension methods for registering middleware in an IApplicationBuilder.
 - [Http.Extensions/](Http.Extensions/): Contains common extension methods for HTTP abstractions, HTTP headers, HTTP request/response, and session state.
 - [Http.Features/](Http.Features/): Contains HTTP feature interface definitions.
+- [Http.Results/](Http.Results/): Contains implementations of `IResult` and related types.
 - [Metadata/](Metadata/): Contains ASP.NET Core metadata.
 - [Owin/](Owin/): Contains components for running OWIN middleware in an ASP.NET Core application, and to run ASP.NET Core middleware in an OWIN application.
 - [Routing/](Routing/): Contains middleware for routing requests to application logic and for generating links.

src/Http/samples/MinimalSample/Program.cs

@@ -19,6 +19,17 @@ app.MapGet("/json", Json);
 string SayHello(string name) => $"Hello, {name}!";
 app.MapGet("/hello/{name}", SayHello);
 
+app.MapGet("/null-result", IResult () => null);
+
+app.MapGet("/todo/{id}", Results<OkObjectHttpResult, NotFoundObjectHttpResult> (int id) =>
+{
+    return id switch
+    {
+        >= 1 and <= 10 => (OkObjectHttpResult)Results.Ok(new { Id = id, Title = "Walk the dog" }),
+        _ => (NotFoundObjectHttpResult)Results.NotFound()
+    };
+});
+
 var extensions = new Dictionary<string, object>() { { "traceId", "traceId123" } };
 
 app.MapGet("/problem", () =>