MycLib/Src/AST/Myc.Ast.Evaluator.pas

unit Myc.Ast.Evaluator;

interface

uses
    System.SysUtils,
    System.Classes,
    System.Generics.Collections,
    Myc.Data.Scalar,
    Myc.Data.Value,
    Myc.Ast.Nodes,
    Myc.Ast.Scope;

type
    // The standard AST evaluator for production use.
    // This class inherits directly from TInterfacedObject as it is an
    // Interpreter (AST -> TDataValue), not a Transformer (AST -> IAstNode).
    TEvaluatorVisitor = class(TInterfacedObject, IAstVisitor, IEvaluatorVisitor)
    private
        FScope: IExecutionScope;
        class var
        procedure HandleTCO(var ResultValue: TDataValue);

    protected
        // IAstVisitor methods made virtual for TDebugEvaluatorVisitor to override
        function VisitConstant(const Node: IConstantNode): TDataValue; virtual;
        function VisitIdentifier(const Node: IIdentifierNode): TDataValue; virtual;
        function VisitKeyword(const Node: IKeywordNode): TDataValue; virtual;
        function VisitBinaryExpression(const Node: IBinaryExpressionNode): TDataValue; virtual;
        function VisitUnaryExpression(const Node: IUnaryExpressionNode): TDataValue; virtual;
        function VisitIfExpression(const Node: IIfExpressionNode): TDataValue; virtual;
        function VisitTernaryExpression(const Node: ITernaryExpressionNode): TDataValue; virtual;
        function VisitLambdaExpression(const Node: ILambdaExpressionNode): TDataValue; virtual;
        function VisitMacroDefinition(const Node: IMacroDefinitionNode): TDataValue; virtual;
        function VisitQuasiquote(const Node: IQuasiquoteNode): TDataValue; virtual;
        function VisitUnquote(const Node: IUnquoteNode): TDataValue; virtual;
        function VisitUnquoteSplicing(const Node: IUnquoteSplicingNode): TDataValue; virtual;
        function VisitFunctionCall(const Node: IFunctionCallNode): TDataValue; virtual;
        function VisitMacroExpansionNode(const Node: IMacroExpansionNode): TDataValue; virtual;
        function VisitBlockExpression(const Node: IBlockExpressionNode): TDataValue; virtual;
        function VisitVariableDeclaration(const Node: IVariableDeclarationNode): TDataValue; virtual;
        function VisitAssignment(const Node: IAssignmentNode): TDataValue; virtual;
        function VisitIndexer(const Node: IIndexerNode): TDataValue; virtual;
        function VisitMemberAccess(const Node: IMemberAccessNode): TDataValue; virtual;
        function VisitRecordLiteral(const Node: IRecordLiteralNode): TDataValue; virtual;
        function VisitCreateSeries(const Node: ICreateSeriesNode): TDataValue; virtual;
        function VisitAddSeriesItem(const Node: IAddSeriesItemNode): TDataValue; virtual;
        function VisitSeriesLength(const Node: ISeriesLengthNode): TDataValue; virtual;
        function VisitRecurNode(const Node: IRecurNode): TDataValue; virtual;
        function VisitNop(const Node: INopNode): TDataValue; virtual;

        function IsTruthy(const AValue: TDataValue): Boolean; inline;

        // Returns a closure that can create the correct type of visitor for a lambda's body.
        function CreateVisitorFactory: TEvaluatorFactory; virtual;

        property Scope: IExecutionScope read FScope;
    public
        constructor Create(const AScope: IExecutionScope);

        // Executes an AST with proper TCO handling. This is the main entry point.
        function Execute(const RootNode: IAstNode): TDataValue;
    end;

implementation

uses
    System.TypInfo,
    System.Generics.Defaults,
    Myc.Ast,
    Myc.Data.Keyword,
    Myc.Data.Decimal,
    Myc.Data.Series,
    Myc.Data.Scalar.JSON;

// Helper type for TCO via trampolining.
type
    TThunk = record
        Callee: TDataValue;
        Args: TArray<TDataValue>;
        Recur: Boolean;
        constructor Create(const ACallee: TDataValue; const AArgs: TArray<TDataValue>; ARecur: Boolean);
    end;

constructor TThunk.Create(const ACallee: TDataValue; const AArgs: TArray<TDataValue>; ARecur: Boolean);
begin
    Callee := ACallee;
    Args := AArgs;
    Recur := ARecur;
end;

{ TDynamicRecord }

type
    // Runtime implementation for generic records using linear search
    TDynamicRecord = class(TInterfacedObject, IKeywordMapping<TDataValue>)
    private
        FFields: TArray<TPair<IKeyword, TDataValue>>;
        function GetFields: TArray<TPair<IKeyword, TDataValue>>;
    public
        constructor Create(const AFields: TArray<TPair<IKeyword, TDataValue>>);
        function IndexOf(const Key: IKeyword): Integer;
    end;

constructor TDynamicRecord.Create(const AFields: TArray<TPair<IKeyword, TDataValue>>);
begin
    inherited Create;
    FFields := AFields;
end;

function TDynamicRecord.GetFields: TArray<TPair<IKeyword, TDataValue>>;
begin
    Result := FFields;
end;

function TDynamicRecord.IndexOf(const Key: IKeyword): Integer;
begin
    // Linear search (O(n)) as requested
    for Result := 0 to High(FFields) do
    begin
        if FFields[Result].Key.Idx = Key.Idx then
            exit;
    end;
    Result := -1;
end;

{ TEvaluatorVisitor }

constructor TEvaluatorVisitor.Create(const AScope: IExecutionScope);
begin
    inherited Create;
    Assert(Assigned(AScope));
    FScope := AScope;
end;

function TEvaluatorVisitor.Execute(const RootNode: IAstNode): TDataValue;
begin
    if not Assigned(RootNode) then
        exit(TDataValue.Void);

    Result := RootNode.Accept(Self);
    HandleTCO(Result);
end;

function TEvaluatorVisitor.CreateVisitorFactory: TEvaluatorFactory;
begin
    // The production visitor returns a factory that creates another production visitor.
    Result := function(const AScope: IExecutionScope): IEvaluatorVisitor begin Result := TEvaluatorVisitor.Create(AScope); end;
end;

procedure TEvaluatorVisitor.HandleTCO(var ResultValue: TDataValue);
begin
    // This is the central trampoline loop for Tail Call Optimization.
    // It runs as long as the evaluation returns a thunk.
    while ResultValue.Kind = vkGeneric do
    begin
        var thunk := ResultValue.AsGeneric<TThunk>;
        var callee := thunk.Callee.AsMethod();
        ResultValue := callee(thunk.Args);
    end;
end;

function TEvaluatorVisitor.IsTruthy(const AValue: TDataValue): Boolean;
begin
    // Other types (Text, Series, etc.) are considered "false" in a boolean context
    if (AValue.Kind <> vkScalar) then
        exit(false);

    case AValue.AsScalar.Kind of
        TScalar.TKind.Ordinal: Result := AValue.AsScalar.Value.AsInt64 <> 0;
        TScalar.TKind.Float: Result := AValue.AsScalar.Value.AsDouble <> 0.0;
        TScalar.TKind.Keyword: Result := AValue.AsScalar.Value.AsInt64 <> 0;
    else
        Result := false;
    end;
end;

function TEvaluatorVisitor.VisitLambdaExpression(const Node: ILambdaExpressionNode): TDataValue;
var
    boundNode: TLambdaExpressionNode; // Changed
    capturedCells: TArray<IValueCell>;
    i: Integer;
    sourceAddresses: TArray<TResolvedAddress>;
    closureScope: IExecutionScope;
    visitorFactory: TEvaluatorFactory;
begin
    // Cast to the bound node to access binder-specific information.
    boundNode := Node as TLambdaExpressionNode; // Changed

    // Create the closure by capturing the value cells of all upvalues from the current scope.
    sourceAddresses := boundNode.Upvalues;
    SetLength(capturedCells, Length(sourceAddresses));
    for i := 0 to High(sourceAddresses) do
        capturedCells[i] := FScope.Capture(sourceAddresses[i]);

    // Memory optimization: a lambda's scope does not need to be kept alive as a parent
    // if it contains no nested lambdas that might need to capture from it later.
    if boundNode.HasNestedLambdas then
        closureScope := FScope
    else
        closureScope := nil;

    // Get a factory to create the correct visitor (e.g., debug or production) for the lambda body.
    visitorFactory := CreateVisitorFactory();

    var scopeDescriptor := boundNode.ScopeDescriptor;
    var params := boundNode.Parameters;
    var cNode: ILambdaExpressionNode := Node;

    // [unsafe] prevents a reference cycle since the closure captures itself for 'recur'.
    var [unsafe] closure: TDataValue.TFunc;
    closure :=
        function(const ArgValues: TArray<TDataValue>): TDataValue
        var
            lambdaScope: IExecutionScope;
            bodyVisitor: IAstVisitor;
            i: Integer;
            adr: TResolvedAddress;
        begin
            if (Length(ArgValues) <> Length(params)) then
                raise EArgumentException.CreateFmt('Argument count mismatch: expected %d, got %d', [Length(params), Length(ArgValues)]);

            // Create the new execution scope for this function call.
            lambdaScope := TScope.CreateScope(closureScope, scopeDescriptor, capturedCells);

            adr.Kind := akLocalOrParent;
            adr.ScopeDepth := 0;

            // Capture the closure itself in slot 0 for 'recur' to find it.
            adr.SlotIndex := 0;
            lambdaScope[adr] := TDataValue(closure); // Explicit cast

            // Populate the scope with the actual parameters passed to the function.
            for i := 0 to High(ArgValues) do
            begin
                // Parameters in a bound lambda must be bound identifiers.
                adr.SlotIndex := (params[i] as TIdentifierNode).Address.SlotIndex; // Changed
                lambdaScope[adr] := ArgValues[i];
            end;

            // Create a visitor with the new scope and execute the lambda's body.
            bodyVisitor := visitorFactory(lambdaScope);
            Result := cNode.Body.Accept(bodyVisitor);
        end;

    // The result of visiting a lambda node is the callable closure itself.
    Result := TDataValue(closure); // Explicit cast
end;

function TEvaluatorVisitor.VisitMacroDefinition(const Node: IMacroDefinitionNode): TDataValue;
begin
    // Macro definitions are compile-time constructs and should have been
    // processed and removed from the AST by the TMacroExpander.
    // If we encounter one here, it's a compiler pipeline error.
    raise Exception.Create('Macro definitions cannot be evaluated at runtime.');
end;

function TEvaluatorVisitor.VisitQuasiquote(const Node: IQuasiquoteNode): TDataValue;
begin
    raise Exception.Create('Quasiquote nodes are a compile-time construct and cannot be evaluated at runtime.');
end;

function TEvaluatorVisitor.VisitUnquote(const Node: IUnquoteNode): TDataValue;
begin
    raise Exception.Create('Unquote nodes are a compile-time construct and cannot be evaluated at runtime.');
end;

function TEvaluatorVisitor.VisitUnquoteSplicing(const Node: IUnquoteSplicingNode): TDataValue;
begin
    raise Exception.Create('Unquote-splicing nodes are a compile-time construct and cannot be evaluated at runtime.');
end;

function TEvaluatorVisitor.VisitFunctionCall(const Node: IFunctionCallNode): TDataValue;
var
    calleeValue: TDataValue;
    argValues: TArray<TDataValue>;
    boundNode: TFunctionCallNode; // Changed
begin
    calleeValue := Node.Callee.Accept(Self);
    if calleeValue.Kind <> vkMethod then
        raise EArgumentException.Create('Expression is not invokable in this context.');

    var argNodes := Node.Arguments;
    SetLength(argValues, Length(argNodes));
    for var i := 0 to High(argNodes) do
        argValues[i] := argNodes[i].Accept(Self);

    boundNode := Node as TFunctionCallNode; // Changed
    if boundNode.IsTailCall then
    begin
        // This is a tail call. Return a thunk to be processed by the trampoline.
        Result := TDataValue.FromGeneric<TThunk>(TThunk.Create(calleeValue, argValues, false));
    end
    else
    begin
        // This is a non-tail call. It must execute the call and act as the trampoline.
        Result := (calleeValue.AsMethod)(argValues);

        HandleTCO(Result);
    end;
end;

function TEvaluatorVisitor.VisitMacroExpansionNode(const Node: IMacroExpansionNode): TDataValue;
begin
    // The evaluator simply "unwraps" the macro expansion node
    // and executes the expanded body it contains.
    Result := Node.ExpandedBody.Accept(Self);
end;

function TEvaluatorVisitor.VisitRecurNode(const Node: IRecurNode): TDataValue;
var
    argValues: TArray<TDataValue>;
    calleeAddress: TResolvedAddress;
    calleeValue: TDataValue;
    i: Integer;
begin
    // The binder ensures this is only in a tail position.
    SetLength(argValues, Length(Node.Arguments));
    for i := 0 to High(Node.Arguments) do
        argValues[i] := Node.Arguments[i].Accept(Self);

    // The callee is the current function, stored in slot 0 of the current scope.
    calleeAddress.Kind := akLocalOrParent;
    calleeAddress.ScopeDepth := 0;
    calleeAddress.SlotIndex := 0;
    calleeValue := FScope[calleeAddress];

    // Recur always returns a thunk for the trampoline.
    Result := TDataValue.FromGeneric<TThunk>(TThunk.Create(calleeValue, argValues, true));
end;

function TEvaluatorVisitor.VisitAddSeriesItem(const Node: IAddSeriesItemNode): TDataValue;
var
    itemValue, lookbackValue, seriesVar: TDataValue;
    lookback: Int64;
begin
    seriesVar := FScope[(Node.Series as TIdentifierNode).Address]; // Changed
    itemValue := Node.Value.Accept(Self);
    lookback := -1;

    if Assigned(Node.Lookback) then
    begin
        lookbackValue := Node.Lookback.Accept(Self);
        if (lookbackValue.Kind <> vkScalar) or (lookbackValue.AsScalar.Kind <> TScalar.TKind.Ordinal) then
            raise EArgumentException.Create('Lookback parameter must be an integer.');
        lookback := lookbackValue.AsScalar.Value.AsInt64;
    end;

    case seriesVar.Kind of
        vkRecordSeries:
        begin
            if (itemValue.Kind <> vkRecord) then
                raise EArgumentException.Create('Can only add record values to a TScalarRecordSeries.');

            with seriesVar.AsRecordSeries do
            begin
                Add(itemValue.AsRecord, lookback);
            end;
        end;
    else
        raise EArgumentException.Create('"add" operation is only supported for series types.');
    end;
    Result := TDataValue.Void;
end;

function TEvaluatorVisitor.VisitAssignment(const Node: IAssignmentNode): TDataValue;
begin
    // Evaluate the new value.
    Result := Node.Value.Accept(Self);
    // Assign it. The scope's SetValues implementation now handles boxing correctly.
    FScope[(Node.Identifier as TIdentifierNode).Address] := Result; // Changed
end;

function TEvaluatorVisitor.VisitConstant(const Node: IConstantNode): TDataValue;
begin
    Result := Node.Value;
end;

function TEvaluatorVisitor.VisitKeyword(const Node: IKeywordNode): TDataValue;
begin
    // Return the keyword as a TScalar value
    Result := TDataValue(TScalar.FromKeyword(Node.Value)); // Explicit cast
end;

function TEvaluatorVisitor.VisitCreateSeries(const Node: ICreateSeriesNode): TDataValue;
var
    def: string;
begin
    def := Node.Definition.Trim;
    if def.StartsWith('[') then
    begin
        var recordDef := TRttiAstHelper.JsonToRecordDefinition(def);
        if Length(recordDef.Fields) = 0 then
            raise EArgumentException.Create('Failed to parse record definition from JSON array.');
        var recordSeries := TScalarRecordSeries.Create(recordDef);
        Result := TDataValue.FromRecordSeries(recordSeries);
    end
    else
    begin
        var scalarKind := TScalar.StringToKind(def);
        Result := TDataValue.FromSeries(TScalarSeries.Create(scalarKind));
    end;
end;

function TEvaluatorVisitor.VisitIdentifier(const Node: IIdentifierNode): TDataValue;
begin
    // The scope's GetValues implementation now handles unboxing automatically.
    Result := FScope[(Node as TIdentifierNode).Address]; // Changed
end;

function TEvaluatorVisitor.VisitIndexer(const Node: IIndexerNode): TDataValue;
var
    baseValue, indexValue: TDataValue;
    index: Int64;
    series: ISeries;
    recSeries: IRecordSeries;
    i, fieldCount: Integer;
    values: TArray<TScalar.TValue>;
    key: IKeyword;
    memberSeries: ISeries;
    scalarValue: TScalar;
    rec: TScalarRecord;
begin
    baseValue := Node.Base.Accept(Self);
    indexValue := Node.Index.Accept(Self);

    if (indexValue.Kind <> vkScalar) or (indexValue.AsScalar.Kind <> TScalar.TKind.Ordinal) then
        raise EArgumentException.Create('Indexer `[]` requires an integer argument.');

    index := indexValue.AsScalar.Value.AsInt64;

    case baseValue.Kind of
        vkSeries:
        begin
            series := baseValue.AsSeries;
            if (index < 0) or (index >= series.TotalCount) then
                raise EArgumentException.CreateFmt('Index %d is out of bounds for series with %d elements.', [index, series.TotalCount]);
            Result := TDataValue(series.Items[Integer(index)]); // Explicit cast
        end;
        vkRecordSeries:
        begin
            recSeries := baseValue.AsRecordSeries;
            if (index < 0) or (index >= recSeries.TotalCount) then
                raise EArgumentException.CreateFmt('Index %d is out of bounds for series with %d elements.', [index, recSeries.TotalCount]);

            // Materialize the TScalarRecord by accessing each member series by index
            fieldCount := Length(recSeries.Def.Fields);
            SetLength(values, fieldCount);

            for i := 0 to fieldCount - 1 do
            begin
                key := recSeries.Def.Fields[i].Key;
                memberSeries := recSeries[key];
                scalarValue := memberSeries[index];
                values[i] := scalarValue.Value;
            end;

            rec := TScalarRecord.Create(recSeries.Def, values);
            Result := TDataValue.FromRecord(rec);
        end;
    else
        raise EArgumentException.Create('Indexer `[]` is not supported for this value type.');
    end;
end;

function TEvaluatorVisitor.VisitMemberAccess(const Node: IMemberAccessNode): TDataValue;
var
    baseValue: TDataValue;
begin
    baseValue := Node.Base.Accept(Self);

    case baseValue.Kind of
        vkRecordSeries: Result := TDataValue.FromSeries(baseValue.AsRecordSeries[Node.Member.Value]);

        vkRecord: Result := TDataValue(baseValue.AsRecord[Node.Member.Value]); // Explicit cast

        // --- NEW GENERIC PATH ---
        vkGenericRecord:
        begin
            var rec := baseValue.AsGenericRecord;
            var fieldIndex := rec.IndexOf(Node.Member.Value);
            if fieldIndex < 0 then
                raise EArgumentException.CreateFmt('Member ":%s" not found in record.', [Node.Member.Value.Name]);

            Result := rec.Fields[fieldIndex].Value;
        end;
    else
        raise EArgumentException.Create('Member access operator `.` is not supported for this value type.');
    end;
end;

function TEvaluatorVisitor.VisitRecordLiteral(const Node: IRecordLiteralNode): TDataValue;
var
    i: Integer;
begin
    // Check which type the binder created
    if Node is TGenericRecordLiteralNode then // Changed
    begin
        // --- NEW GENERIC PATH ---
        var boundNode := Node as TGenericRecordLiteralNode; // Changed
        var genFields: TArray<TPair<IKeyword, TDataValue>>;
        SetLength(genFields, Length(boundNode.Fields));

        // Evaluate all field values
        for i := 0 to High(boundNode.Fields) do
        begin
            genFields[i] :=
                TPair<IKeyword, TDataValue>.Create(
                    boundNode.Fields[i].Key.Value,
                    boundNode.Fields[i].Value.Accept(Self) // Evaluate expression
                );
        end;

        // Create the new runtime object and wrap it
        var dynRec := TDynamicRecord.Create(genFields);
        Result := TDataValue.FromGenericRecord(dynRec);
    end
    else if Node is TRecordLiteralNode then // Changed
    begin
        // --- EXISTING SCALAR PATH ---
        var boundNode := Node as TRecordLiteralNode; // Changed
        var values: TArray<TScalar.TValue>;
        SetLength(values, Length(boundNode.Fields));

        for i := 0 to High(boundNode.Fields) do
        begin
            var valData := boundNode.Fields[i].Value.Accept(Self);
            // Binder guarantees these are vkScalar
            values[i] := valData.AsScalar.Value;
        end;

        var rec := TScalarRecord.Create(boundNode.Definition, values);
        Result := TDataValue.FromRecord(rec);
    end
    else
        raise EInvalidOpException.Create('Unknown record literal node type during evaluation.');
end;

function TEvaluatorVisitor.VisitVariableDeclaration(const Node: IVariableDeclarationNode): TDataValue;
var
    address: TResolvedAddress;
    boundNode: TVariableDeclarationNode; // Changed
begin
    // First, evaluate the initializer to get the variable's initial value.
    if Assigned(Node.Initializer) then
        Result := Node.Initializer.Accept(Self)
    else
        Result := TDataValue.Void;

    // After binding, all declaration nodes are TVariableDeclarationNode
    boundNode := Node as TVariableDeclarationNode; // Changed
    address := (boundNode.Identifier as TIdentifierNode).Address; // Changed

    // Check the IsBoxed flag set by the binder.
    if boundNode.IsBoxed then
    begin
        // This is a captured variable. Use the clean scope method to create the box.
        Assert(address.ScopeDepth = 0);
        FScope.DefineBoxed(address.SlotIndex, Result);
    end
    else
    begin
        // This is a standard local variable. Store the raw value directly.
        FScope[address] := Result;
    end;
end;

function TEvaluatorVisitor.VisitBinaryExpression(const Node: IBinaryExpressionNode): TDataValue;
var
    leftValue, rightValue: TDataValue;
    resScalar: TScalar;
begin
    leftValue := Node.Left.Accept(Self);
    rightValue := Node.Right.Accept(Self);

    // Standard scalar operations
    if (leftValue.Kind <> vkScalar) or (rightValue.Kind <> vkScalar) then
        raise ENotSupportedException.Create('Binary operations are only supported for scalar types.');

    if not TScalar.TryBinaryOperation(Node.Operator, leftValue.AsScalar, rightValue.AsScalar, resScalar) then
        raise ENotSupportedException.Create(
            'Binary operation not supported for scalar types '
                + leftValue.AsScalar.Kind.ToString
                + ' and '
                + rightValue.AsScalar.Kind.ToString
                + ' .');
    Result := TDataValue(resScalar); // Explicit cast
end;

function TEvaluatorVisitor.VisitUnaryExpression(const Node: IUnaryExpressionNode): TDataValue;
var
    rightValue: TDataValue;
begin
    rightValue := Node.Right.Accept(Self);

    if rightValue.Kind <> vkScalar then
        raise ENotSupportedException.Create('Unary operations are only supported for scalar types.');

    var res: TScalar;
    if not TScalar.TryUnaryOperation(Node.Operator, rightValue.AsScalar, res) then
        raise ENotSupportedException.Create('Unary operation not supported for scalar type' + rightValue.AsScalar.Kind.ToString + '.');
    Result := TDataValue(res); // Explicit cast
end;

function TEvaluatorVisitor.VisitIfExpression(const Node: IIfExpressionNode): TDataValue;
begin
    if IsTruthy(Node.Condition.Accept(Self)) then
        Result := Node.ThenBranch.Accept(Self)
    else if Assigned(Node.ElseBranch) then
        Result := Node.ElseBranch.Accept(Self)
    else
        Result := TDataValue.Void;
end;

function TEvaluatorVisitor.VisitTernaryExpression(const Node: ITernaryExpressionNode): TDataValue;
begin
    if IsTruthy(Node.Condition.Accept(Self)) then
        Result := Node.ThenBranch.Accept(Self)
    else
        Result := Node.ElseBranch.Accept(Self);
end;

function TEvaluatorVisitor.VisitBlockExpression(const Node: IBlockExpressionNode): TDataValue;
var
    expression: IAstNode;
begin
    Result := TDataValue.Void;
    for expression in Node.Expressions do
        Result := expression.Accept(Self);
end;

function TEvaluatorVisitor.VisitNop(const Node: INopNode): TDataValue;
begin
    // This node should be rejected by the Binder/TypeChecker.
    // If it reaches the evaluator, it's a compiler bug, but we treat it as Void.
    Result := TDataValue.Void;
end;

function TEvaluatorVisitor.VisitSeriesLength(const Node: ISeriesLengthNode): TDataValue;
var
    seriesValue: TDataValue;
    len: Int64;
begin
    seriesValue := FScope[(Node.Series as TIdentifierNode).Address]; // Changed

    case seriesValue.Kind of
        vkSeries: len := seriesValue.AsSeries.Count;
        vkRecordSeries: len := seriesValue.AsRecordSeries.Count;
    else
        raise EArgumentException.CreateFmt('Cannot get length of type %s.', [GetEnumName(TypeInfo(TDataValueKind), Ord(seriesValue.Kind))]);
    end;

    Result := TDataValue(TScalar.FromInt64(len)); // Explicit cast
end;

end.