refactor for readability and easier inspection

Author: Viir

implement/pine/ElmInteractive/InteractiveSessionPine.cs

@@ -891,138 +891,198 @@ void logDuration(string label) =>
                 addInspectionLogEntry?.Invoke(
                     label + " duration: " + CommandLineInterface.FormatIntegerForDisplay(clock.ElapsedMilliseconds) + " ms");
 
-            return
-                buildCompilerResult
-                .MapError(err => "Failed to build compiler: " + err)
-                .AndThen(elmCompiler =>
-                buildPineEvalContextTask.Result
-                .MapError(error => "Failed to build initial Pine eval context: " + error)
-                .AndThen(buildPineEvalContextOk =>
-                {
-                    clock.Restart();
+            if (buildCompilerResult.IsErrOrNull() is { } buildCompilerErr)
+            {
+                return "Failed to build Elm compiler: " + buildCompilerErr;
+            }
 
-                    var parseSubmissionResult =
-                        ParseInteractiveSubmission(
-                            elmCompiler,
-                            pineVM,
-                            submission: submission,
-                            addInspectionLogEntry: compileEntry => addInspectionLogEntry?.Invoke("Parse: " + compileEntry));
+            if (buildCompilerResult.IsOkOrNull() is not { } elmCompiler)
+            {
+                throw new NotImplementedException(
+                    "Unexpected build compiler result type: " + buildCompilerResult.GetType());
+            }
 
-                    return
-                    parseSubmissionResult
-                    .MapError(error => "Failed to parse submission: " + error)
-                    .AndThen(parsedSubmissionOk =>
-                    {
-                        return
-                        elmCompilerCache.PineValueDecodedAsElmValue(parsedSubmissionOk)
-                        .MapError(error => "Failed parsing result as Elm value: " + error)
-                        .AndThen(parsedSubmissionAsElmValue =>
-                        {
-                            logDuration("parse");
-
-                            clock.Restart();
-
-                            var environmentEncodedForCompiler =
-                                elmCompilerCache.EncodeValueForCompiler(buildPineEvalContextOk);
-
-                            logDuration("compile - encode environment");
-
-                            clock.Restart();
-
-                            var compileParsedResult =
-                                ElmInteractiveEnvironment.ApplyFunction(
-                                    pineVM,
-                                    elmCompiler.CompileParsedInteractiveSubmission,
-                                    arguments:
-                                    [
-                                        environmentEncodedForCompiler,
-                                        parsedSubmissionOk
-                                    ]);
-
-                            if (compileParsedResult.IsOkOrNull() is not { } compileParsedOk)
-                            {
-                                return
-                                "Failed compiling parsed submission (" +
-                                parsedSubmissionAsElmValue + "): " +
-                                compileParsedResult.Unpack(err => err, ok => "Not an err");
-                            }
-
-                            logDuration("compile - apply");
-
-                            clock.Restart();
-
-                            var compileParsedOkAsElmValue =
-                            elmCompilerCache.PineValueDecodedAsElmValue(compileParsedOk)
-                            .Extract(err => throw new Exception("Failed decoding as Elm value: " + err));
-
-                            logDuration("compile - decode result");
-
-                            clock.Restart();
-
-                            if (compileParsedOkAsElmValue is not ElmValue.ElmTag compiledResultTag)
-                            {
-                                return "Unexpected return value: No tag: " + compileParsedOkAsElmValue;
-                            }
-
-                            if (compiledResultTag.TagName is not "Ok" || compiledResultTag.Arguments.Count is not 1)
-                            {
-                                return "Failed compile: " + compiledResultTag;
-                            }
-
-                            var decodeExpressionResult =
-                            elmCompilerCache.DecodeExpressionFromElmValue(compiledResultTag.Arguments[0]);
-
-                            return
-                            decodeExpressionResult
-                            .MapError(error => "Failed decoding compiled expression: " + error)
-                            .AndThen(resultingExpr =>
-                            {
-                                logDuration("compile - decode expression");
-
-                                clock.Restart();
-
-                                var evalResult = pineVM.EvaluateExpression(resultingExpr, buildPineEvalContextOk);
-
-                                logDuration("eval");
-
-                                return
-                                evalResult
-                                .MapError(error => "Failed to evaluate expression in PineVM: " + error)
-                                .AndThen(evalOk =>
-                                {
-                                    if (evalOk is not PineValue.ListValue evalResultListComponent)
-                                    {
-                                        return
-                                        "Type mismatch: Pine expression evaluated to a blob";
-                                    }
-
-                                    if (evalResultListComponent.Elements.Length is not 2)
-                                    {
-                                        return
-                                        "Type mismatch: Pine expression evaluated to a list with unexpected number of elements: " +
-                                        evalResultListComponent.Elements.Length +
-                                        " instead of 2";
-                                    }
-
-                                    buildPineEvalContextTask = System.Threading.Tasks.Task.FromResult(
-                                        Result<string, PineValue>.ok(evalResultListComponent.Elements.Span[0]));
-
-                                    clock.Restart();
-
-                                    var parseSubmissionResponseResult =
-                                        ElmInteractive.SubmissionResponseFromResponsePineValue(
-                                            response: evalResultListComponent.Elements.Span[1]);
-
-                                    logDuration("parse-result");
-
-                                    return
-                                    parseSubmissionResponseResult
-                                    .MapError(error => "Failed to parse submission response: " + error);
-                                });
-                            });
-                        });
-                    });
-                }));
+            if (buildPineEvalContextTask.Result.IsErrOrNull() is { } buildPineEvalContextErr)
+            {
+                return "Failed to build initial Pine eval context: " + buildPineEvalContextErr;
+            }
+
+            if (buildPineEvalContextTask.Result.IsOkOrNull() is not { } buildPineEvalContextOk)
+            {
+                throw new NotImplementedException(
+                    "Unexpected build Pine eval context result type: " + buildPineEvalContextTask.Result.GetType());
+            }
+
+            clock.Restart();
+
+            var parseSubmissionResult =
+                ParseInteractiveSubmission(
+                    elmCompiler,
+                    pineVM,
+                    submission: submission,
+                    addInspectionLogEntry: compileEntry => addInspectionLogEntry?.Invoke("Parse: " + compileEntry));
+
+            if (parseSubmissionResult.IsErrOrNull() is { } parseSubmissionErr)
+            {
+                return "Failed to parse submission: " + parseSubmissionErr;
+            }
+
+            if (parseSubmissionResult.IsOkOrNull() is not { } parsedSubmissionOk)
+            {
+                throw new NotImplementedException(
+                    "Unexpected parse submission result type: " + parseSubmissionResult.GetType());
+            }
+
+            var parseSubmissionAsElmValueResult =
+                elmCompilerCache.PineValueDecodedAsElmValue(parsedSubmissionOk);
+
+            if (parseSubmissionAsElmValueResult.IsErrOrNull() is { } parseSubmissionAsElmValueErr)
+            {
+                return "Failed parsing submission response as Elm value: " + parseSubmissionAsElmValueErr;
+            }
+
+            if (parseSubmissionAsElmValueResult.IsOkOrNull() is not { } parsedSubmissionAsElmValue)
+            {
+                throw new NotImplementedException(
+                    "Unexpected parse submission as Elm value result type: " + parseSubmissionAsElmValueResult.GetType());
+            }
+
+            logDuration("parse");
+
+            clock.Restart();
+
+            var environmentEncodedForCompiler =
+                elmCompilerCache.EncodeValueForCompiler(buildPineEvalContextOk);
+
+            logDuration("compile - encode environment");
+
+            clock.Restart();
+
+            var compileParsedResult =
+                ElmInteractiveEnvironment.ApplyFunction(
+                    pineVM,
+                    elmCompiler.CompileParsedInteractiveSubmission,
+                    arguments:
+                    [
+                        environmentEncodedForCompiler,
+                        parsedSubmissionOk
+                    ]);
+
+            if (compileParsedResult.IsErrOrNull() is { } compileParsedErr)
+            {
+                return "Failed compiling parsed submission (" +
+                    parsedSubmissionAsElmValue + "): " + compileParsedErr;
+            }
+
+            if (compileParsedResult.IsOkOrNull() is not { } compileParsedOk)
+            {
+                return
+                    "Failed compiling parsed submission (" +
+                    parsedSubmissionAsElmValue + "): " +
+                    compileParsedResult.Unpack(err => err, ok => "Not an err");
+            }
+
+            logDuration("compile - apply");
+
+            clock.Restart();
+
+            var compileParsedOkAsElmValueResult =
+                elmCompilerCache.PineValueDecodedAsElmValue(compileParsedOk);
+
+            if (compileParsedOkAsElmValueResult.IsErrOrNull() is { } compileParsedOkAsElmValueErr)
+            {
+                return "Failed decoding compiled expression: " + compileParsedOkAsElmValueErr;
+            }
+
+            if (compileParsedOkAsElmValueResult.IsOkOrNull() is not { } compileParsedOkAsElmValue)
+            {
+                throw new NotImplementedException(
+                    "Unexpected compile parsed ok as Elm value result type: " + compileParsedOkAsElmValueResult.GetType());
+            }
+
+            logDuration("compile - decode result");
+
+            clock.Restart();
+
+            if (compileParsedOkAsElmValue is not ElmValue.ElmTag compiledResultTag)
+            {
+                return "Unexpected return value: No tag: " + compileParsedOkAsElmValue;
+            }
+
+            if (compiledResultTag.TagName is not "Ok" || compiledResultTag.Arguments.Count is not 1)
+            {
+                return "Failed compile: " + compiledResultTag;
+            }
+
+            var decodeExpressionResult =
+                elmCompilerCache.DecodeExpressionFromElmValue(compiledResultTag.Arguments[0]);
+
+            if (decodeExpressionResult.IsErrOrNull() is { } decodeExpressionErr)
+            {
+                return "Failed decoding compiled expression: " + decodeExpressionErr;
+            }
+
+            if (decodeExpressionResult.IsOkOrNull() is not { } resultingExpr)
+            {
+                throw new NotImplementedException(
+                    "Unexpected decode expression result type: " + decodeExpressionResult.GetType());
+            }
+
+            logDuration("compile - decode expression");
+
+            clock.Restart();
+
+            var evalResult = pineVM.EvaluateExpression(resultingExpr, buildPineEvalContextOk);
+
+            logDuration("eval");
+
+            if (evalResult.IsErrOrNull() is { } evalErr)
+            {
+                return "Failed to evaluate compiled expression in PineVM: " + evalErr;
+            }
+
+            if (evalResult.IsOkOrNull() is not { } evalOk)
+            {
+                throw new NotImplementedException(
+                    "Unexpected eval result type: " + evalResult.GetType());
+            }
+
+            if (evalOk is not PineValue.ListValue evalResultListComponent)
+            {
+                return "Type mismatch: Pine expression not evaluated to a list: " + evalOk;
+            }
+
+            if (evalResultListComponent.Elements.Length is not 2)
+            {
+                return
+                    "Type mismatch: Pine expression evaluated to a list with unexpected number of elements: " +
+                    evalResultListComponent.Elements.Length +
+                    " instead of 2";
+            }
+
+            buildPineEvalContextTask = System.Threading.Tasks.Task.FromResult(
+                Result<string, PineValue>.ok(evalResultListComponent.Elements.Span[0]));
+
+            clock.Restart();
+
+            var parseSubmissionResponseResult =
+                ElmInteractive.SubmissionResponseFromResponsePineValue(
+                    response: evalResultListComponent.Elements.Span[1]);
+
+            logDuration("parse-result");
+
+            if (parseSubmissionResponseResult.IsErrOrNull() is { } parseSubmissionResponseErr)
+            {
+                return "Failed to parse submission response: " + parseSubmissionResponseErr;
+            }
+
+            if (parseSubmissionResponseResult.IsOkOrNull() is not { } parseSubmissionResponseOk)
+            {
+                throw new NotImplementedException(
+                    "Unexpected parse submission response result type: " + parseSubmissionResponseResult.GetType());
+            }
+
+            return parseSubmissionResponseOk;
         }
     }