DefinitionTree {
    definitions: [
        TypeAlias(
            TypeAliasDefinition {
                type: Span {
                    line: 1,
                    column: 1,
                    position: 0,
                },
                name: TemplatedIdentifier {
                    name: Identifier {
                        span: Span {
                            line: 1,
                            column: 6,
                            position: 5,
                        },
                        value: "num",
                    },
                    templates: None,
                },
                equals: Span {
                    line: 1,
                    column: 10,
                    position: 9,
                },
                data_type: Union(
                    [
                        Integer(
                            Span {
                                line: 1,
                                column: 12,
                                position: 11,
                            },
                        ),
                        Float(
                            Span {
                                line: 1,
                                column: 16,
                                position: 15,
                            },
                        ),
                    ],
                ),
                semicolon: Span {
                    line: 1,
                    column: 21,
                    position: 20,
                },
            },
        ),
        Class(
            ClassDefinition {
                comments: CommentGroup {
                    comments: [],
                },
                attributes: [],
                modifiers: ClassModifierDefinitionGroup {
                    modifiers: [
                        Final(
                            Span {
                                line: 3,
                                column: 1,
                                position: 23,
                            },
                        ),
                        Readonly(
                            Span {
                                line: 3,
                                column: 7,
                                position: 29,
                            },
                        ),
                    ],
                },
                class: Span {
                    line: 3,
                    column: 16,
                    position: 38,
                },
                name: Identifier {
                    span: Span {
                        line: 3,
                        column: 22,
                        position: 44,
                    },
                    value: "Collection",
                },
                templates: Some(
                    TemplateGroupDefinition {
                        comments: CommentGroup {
                            comments: [],
                        },
                        less_than: Span {
                            line: 3,
                            column: 32,
                            position: 54,
                        },
                        members: CommaSeparated {
                            inner: [
                                TemplateDefinition {
                                    variance: Invaraint,
                                    name: Identifier {
                                        span: Span {
                                            line: 3,
                                            column: 33,
                                            position: 55,
                                        },
                                        value: "T",
                                    },
                                    constraint: None,
                                },
                            ],
                            commas: [],
                        },
                        greater_than: Span {
                            line: 3,
                            column: 34,
                            position: 56,
                        },
                    },
                ),
                extends: None,
                implements: None,
                body: ClassDefinitionBody {
                    left_brace: Span {
                        line: 3,
                        column: 36,
                        position: 58,
                    },
                    members: [
                        ConcreteConstructor(
                            ConcreteConstructorDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                attributes: [],
                                modifiers: MethodModifierDefinitionGroup {
                                    modifiers: [
                                        Public(
                                            Span {
                                                line: 4,
                                                column: 5,
                                                position: 64,
                                            },
                                        ),
                                    ],
                                },
                                function: Span {
                                    line: 4,
                                    column: 12,
                                    position: 71,
                                },
                                name: Identifier {
                                    span: Span {
                                        line: 4,
                                        column: 21,
                                        position: 80,
                                    },
                                    value: "__construct",
                                },
                                parameters: ConstructorParameterListDefinition {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_parenthesis: Span {
                                        line: 4,
                                        column: 32,
                                        position: 91,
                                    },
                                    parameters: CommaSeparated {
                                        inner: [
                                            ConstructorParameterDefinition {
                                                attributes: [],
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                modifiers: PromotedPropertyModifierDefinitionGroup {
                                                    modifiers: [
                                                        Private(
                                                            Span {
                                                                line: 5,
                                                                column: 9,
                                                                position: 101,
                                                            },
                                                        ),
                                                    ],
                                                },
                                                type_definition: Vec(
                                                    Span {
                                                        line: 5,
                                                        column: 17,
                                                        position: 109,
                                                    },
                                                    TypeTemplateGroupDefinition {
                                                        comments: CommentGroup {
                                                            comments: [],
                                                        },
                                                        less_than: Span {
                                                            line: 5,
                                                            column: 20,
                                                            position: 112,
                                                        },
                                                        members: CommaSeparated {
                                                            inner: [
                                                                Identifier(
                                                                    TemplatedIdentifier {
                                                                        name: Identifier {
                                                                            span: Span {
                                                                                line: 5,
                                                                                column: 21,
                                                                                position: 113,
                                                                            },
                                                                            value: "T",
                                                                        },
                                                                        templates: None,
                                                                    },
                                                                ),
                                                            ],
                                                            commas: [],
                                                        },
                                                        greater_than: Span {
                                                            line: 5,
                                                            column: 22,
                                                            position: 114,
                                                        },
                                                    },
                                                ),
                                                ellipsis: None,
                                                variable: Variable {
                                                    span: Span {
                                                        line: 5,
                                                        column: 24,
                                                        position: 116,
                                                    },
                                                    name: "$items",
                                                },
                                                default: Some(
                                                    FunctionLikeParameterDefaultValueDefinition {
                                                        equals: Span {
                                                            line: 5,
                                                            column: 31,
                                                            position: 123,
                                                        },
                                                        value: Vec(
                                                            VecExpression {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                vec: Span {
                                                                    line: 5,
                                                                    column: 33,
                                                                    position: 125,
                                                                },
                                                                left_bracket: Span {
                                                                    line: 5,
                                                                    column: 36,
                                                                    position: 128,
                                                                },
                                                                members: CommaSeparated {
                                                                    inner: [],
                                                                    commas: [],
                                                                },
                                                                right_bracket: Span {
                                                                    line: 5,
                                                                    column: 37,
                                                                    position: 129,
                                                                },
                                                            },
                                                        ),
                                                    },
                                                ),
                                            },
                                        ],
                                        commas: [
                                            Span {
                                                line: 5,
                                                column: 38,
                                                position: 130,
                                            },
                                        ],
                                    },
                                    right_parenthesis: Span {
                                        line: 6,
                                        column: 5,
                                        position: 136,
                                    },
                                },
                                body: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: Span {
                                        line: 6,
                                        column: 7,
                                        position: 138,
                                    },
                                    statements: [],
                                    right_brace: Span {
                                        line: 6,
                                        column: 8,
                                        position: 139,
                                    },
                                },
                            },
                        ),
                        ConcreteMethod(
                            ConcreteMethodDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                attributes: [],
                                modifiers: MethodModifierDefinitionGroup {
                                    modifiers: [
                                        Public(
                                            Span {
                                                line: 8,
                                                column: 5,
                                                position: 146,
                                            },
                                        ),
                                    ],
                                },
                                function: Span {
                                    line: 8,
                                    column: 12,
                                    position: 153,
                                },
                                name: Identifier {
                                    span: Span {
                                        line: 8,
                                        column: 21,
                                        position: 162,
                                    },
                                    value: "filter",
                                },
                                templates: None,
                                parameters: FunctionLikeParameterListDefinition {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_parenthesis: Span {
                                        line: 8,
                                        column: 27,
                                        position: 168,
                                    },
                                    parameters: CommaSeparated {
                                        inner: [
                                            FunctionLikeParameterDefinition {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                attributes: [],
                                                type_definition: Function {
                                                    outer_left_parenthesis: Span {
                                                        line: 8,
                                                        column: 28,
                                                        position: 169,
                                                    },
                                                    fn: Span {
                                                        line: 8,
                                                        column: 29,
                                                        position: 170,
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 8,
                                                        column: 31,
                                                        position: 172,
                                                    },
                                                    parameter_type_definitions: CommaSeparated {
                                                        inner: [
                                                            Identifier(
                                                                TemplatedIdentifier {
                                                                    name: Identifier {
                                                                        span: Span {
                                                                            line: 8,
                                                                            column: 32,
                                                                            position: 173,
                                                                        },
                                                                        value: "T",
                                                                    },
                                                                    templates: None,
                                                                },
                                                            ),
                                                        ],
                                                        commas: [],
                                                    },
                                                    right_parenthesis: Span {
                                                        line: 8,
                                                        column: 33,
                                                        position: 174,
                                                    },
                                                    colon: Span {
                                                        line: 8,
                                                        column: 34,
                                                        position: 175,
                                                    },
                                                    return_type_definition: Boolean(
                                                        Span {
                                                            line: 8,
                                                            column: 36,
                                                            position: 177,
                                                        },
                                                    ),
                                                    outer_right_parenthesis: Span {
                                                        line: 8,
                                                        column: 40,
                                                        position: 181,
                                                    },
                                                },
                                                ellipsis: None,
                                                variable: Variable {
                                                    span: Span {
                                                        line: 8,
                                                        column: 42,
                                                        position: 183,
                                                    },
                                                    name: "$func",
                                                },
                                                default: None,
                                            },
                                        ],
                                        commas: [],
                                    },
                                    right_parenthesis: Span {
                                        line: 8,
                                        column: 47,
                                        position: 188,
                                    },
                                },
                                return_type: FunctionLikeReturnTypeDefinition {
                                    colon: Span {
                                        line: 8,
                                        column: 48,
                                        position: 189,
                                    },
                                    type_definition: Identifier(
                                        TemplatedIdentifier {
                                            name: Identifier {
                                                span: Span {
                                                    line: 8,
                                                    column: 50,
                                                    position: 191,
                                                },
                                                value: "Collection",
                                            },
                                            templates: Some(
                                                TypeTemplateGroupDefinition {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    less_than: Span {
                                                        line: 8,
                                                        column: 60,
                                                        position: 201,
                                                    },
                                                    members: CommaSeparated {
                                                        inner: [
                                                            Identifier(
                                                                TemplatedIdentifier {
                                                                    name: Identifier {
                                                                        span: Span {
                                                                            line: 8,
                                                                            column: 61,
                                                                            position: 202,
                                                                        },
                                                                        value: "T",
                                                                    },
                                                                    templates: None,
                                                                },
                                                            ),
                                                        ],
                                                        commas: [],
                                                    },
                                                    greater_than: Span {
                                                        line: 8,
                                                        column: 62,
                                                        position: 203,
                                                    },
                                                },
                                            ),
                                        },
                                    ),
                                },
                                constraints: None,
                                body: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: Span {
                                        line: 8,
                                        column: 64,
                                        position: 205,
                                    },
                                    statements: [
                                        Expression(
                                            ExpressionStatement {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                expression: AssignmentOperation(
                                                    Assignment {
                                                        comments: CommentGroup {
                                                            comments: [],
                                                        },
                                                        left: Variable(
                                                            Variable {
                                                                span: Span {
                                                                    line: 9,
                                                                    column: 9,
                                                                    position: 215,
                                                                },
                                                                name: "$result",
                                                            },
                                                        ),
                                                        equals: Span {
                                                            line: 9,
                                                            column: 17,
                                                            position: 223,
                                                        },
                                                        right: Vec(
                                                            VecExpression {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                vec: Span {
                                                                    line: 9,
                                                                    column: 19,
                                                                    position: 225,
                                                                },
                                                                left_bracket: Span {
                                                                    line: 9,
                                                                    column: 22,
                                                                    position: 228,
                                                                },
                                                                members: CommaSeparated {
                                                                    inner: [],
                                                                    commas: [],
                                                                },
                                                                right_bracket: Span {
                                                                    line: 9,
                                                                    column: 23,
                                                                    position: 229,
                                                                },
                                                            },
                                                        ),
                                                    },
                                                ),
                                                semicolon: Span {
                                                    line: 9,
                                                    column: 24,
                                                    position: 230,
                                                },
                                            },
                                        ),
                                        Foreach(
                                            ForeachStatement {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                foreach: Span {
                                                    line: 10,
                                                    column: 9,
                                                    position: 240,
                                                },
                                                iterator: Value {
                                                    expression: ObjectOperation(
                                                        PropertyFetch {
                                                            comments: CommentGroup {
                                                                comments: [],
                                                            },
                                                            object: Variable(
                                                                Variable {
                                                                    span: Span {
                                                                        line: 10,
                                                                        column: 17,
                                                                        position: 248,
                                                                    },
                                                                    name: "$this",
                                                                },
                                                            ),
                                                            arrow: Span {
                                                                line: 10,
                                                                column: 22,
                                                                position: 253,
                                                            },
                                                            property: Identifier {
                                                                span: Span {
                                                                    line: 10,
                                                                    column: 24,
                                                                    position: 255,
                                                                },
                                                                value: "items",
                                                            },
                                                        },
                                                    ),
                                                    as: Span {
                                                        line: 10,
                                                        column: 30,
                                                        position: 261,
                                                    },
                                                    value: Variable {
                                                        span: Span {
                                                            line: 10,
                                                            column: 33,
                                                            position: 264,
                                                        },
                                                        name: "$item",
                                                    },
                                                },
                                                block: BlockStatement {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_brace: Span {
                                                        line: 10,
                                                        column: 39,
                                                        position: 270,
                                                    },
                                                    statements: [
                                                        If(
                                                            IfStatement {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                if: Span {
                                                                    line: 11,
                                                                    column: 13,
                                                                    position: 284,
                                                                },
                                                                condition: FunctionOperation(
                                                                    Call {
                                                                        comments: CommentGroup {
                                                                            comments: [],
                                                                        },
                                                                        function: Variable(
                                                                            Variable {
                                                                                span: Span {
                                                                                    line: 11,
                                                                                    column: 16,
                                                                                    position: 287,
                                                                                },
                                                                                name: "$func",
                                                                            },
                                                                        ),
                                                                        generics: None,
                                                                        arguments: ArgumentListExpression {
                                                                            comments: CommentGroup {
                                                                                comments: [],
                                                                            },
                                                                            left_parenthesis: Span {
                                                                                line: 11,
                                                                                column: 21,
                                                                                position: 292,
                                                                            },
                                                                            arguments: CommaSeparated {
                                                                                inner: [
                                                                                    Positional {
                                                                                        comments: CommentGroup {
                                                                                            comments: [],
                                                                                        },
                                                                                        ellipsis: None,
                                                                                        value: Variable(
                                                                                            Variable {
                                                                                                span: Span {
                                                                                                    line: 11,
                                                                                                    column: 22,
                                                                                                    position: 293,
                                                                                                },
                                                                                                name: "$item",
                                                                                            },
                                                                                        ),
                                                                                    },
                                                                                ],
                                                                                commas: [],
                                                                            },
                                                                            right_parenthesis: Span {
                                                                                line: 11,
                                                                                column: 27,
                                                                                position: 298,
                                                                            },
                                                                        },
                                                                    },
                                                                ),
                                                                block: BlockStatement {
                                                                    comments: CommentGroup {
                                                                        comments: [],
                                                                    },
                                                                    left_brace: Span {
                                                                        line: 11,
                                                                        column: 29,
                                                                        position: 300,
                                                                    },
                                                                    statements: [
                                                                        Expression(
                                                                            ExpressionStatement {
                                                                                comments: CommentGroup {
                                                                                    comments: [],
                                                                                },
                                                                                expression: AssignmentOperation(
                                                                                    Assignment {
                                                                                        comments: CommentGroup {
                                                                                            comments: [],
                                                                                        },
                                                                                        left: ArrayOperation(
                                                                                            Push {
                                                                                                comments: CommentGroup {
                                                                                                    comments: [],
                                                                                                },
                                                                                                array: Variable(
                                                                                                    Variable {
                                                                                                        span: Span {
                                                                                                            line: 12,
                                                                                                            column: 17,
                                                                                                            position: 318,
                                                                                                        },
                                                                                                        name: "$result",
                                                                                                    },
                                                                                                ),
                                                                                                left_bracket: Span {
                                                                                                    line: 12,
                                                                                                    column: 24,
                                                                                                    position: 325,
                                                                                                },
                                                                                                right_bracket: Span {
                                                                                                    line: 12,
                                                                                                    column: 25,
                                                                                                    position: 326,
                                                                                                },
                                                                                            },
                                                                                        ),
                                                                                        equals: Span {
                                                                                            line: 12,
                                                                                            column: 27,
                                                                                            position: 328,
                                                                                        },
                                                                                        right: Variable(
                                                                                            Variable {
                                                                                                span: Span {
                                                                                                    line: 12,
                                                                                                    column: 29,
                                                                                                    position: 330,
                                                                                                },
                                                                                                name: "$item",
                                                                                            },
                                                                                        ),
                                                                                    },
                                                                                ),
                                                                                semicolon: Span {
                                                                                    line: 12,
                                                                                    column: 34,
                                                                                    position: 335,
                                                                                },
                                                                            },
                                                                        ),
                                                                    ],
                                                                    right_brace: Span {
                                                                        line: 13,
                                                                        column: 13,
                                                                        position: 349,
                                                                    },
                                                                },
                                                                elseifs: [],
                                                                else: None,
                                                            },
                                                        ),
                                                    ],
                                                    right_brace: Span {
                                                        line: 14,
                                                        column: 9,
                                                        position: 359,
                                                    },
                                                },
                                            },
                                        ),
                                        Return(
                                            Explicit {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                return: Span {
                                                    line: 16,
                                                    column: 9,
                                                    position: 370,
                                                },
                                                expression: Some(
                                                    ClassOperation(
                                                        Initialization {
                                                            comments: CommentGroup {
                                                                comments: [],
                                                            },
                                                            new: Span {
                                                                line: 16,
                                                                column: 16,
                                                                position: 377,
                                                            },
                                                            class: Identifier {
                                                                span: Span {
                                                                    line: 16,
                                                                    column: 20,
                                                                    position: 381,
                                                                },
                                                                value: "Collection",
                                                            },
                                                            generics: Some(
                                                                GenericGroupExpression {
                                                                    double_colon_less_than: Span {
                                                                        line: 16,
                                                                        column: 30,
                                                                        position: 391,
                                                                    },
                                                                    types: CommaSeparated {
                                                                        inner: [
                                                                            Identifier(
                                                                                TemplatedIdentifier {
                                                                                    name: Identifier {
                                                                                        span: Span {
                                                                                            line: 16,
                                                                                            column: 33,
                                                                                            position: 394,
                                                                                        },
                                                                                        value: "T",
                                                                                    },
                                                                                    templates: None,
                                                                                },
                                                                            ),
                                                                        ],
                                                                        commas: [],
                                                                    },
                                                                    greater_than: Span {
                                                                        line: 16,
                                                                        column: 34,
                                                                        position: 395,
                                                                    },
                                                                },
                                                            ),
                                                            arguments: ArgumentListExpression {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                left_parenthesis: Span {
                                                                    line: 16,
                                                                    column: 35,
                                                                    position: 396,
                                                                },
                                                                arguments: CommaSeparated {
                                                                    inner: [
                                                                        Positional {
                                                                            comments: CommentGroup {
                                                                                comments: [],
                                                                            },
                                                                            ellipsis: None,
                                                                            value: Variable(
                                                                                Variable {
                                                                                    span: Span {
                                                                                        line: 16,
                                                                                        column: 36,
                                                                                        position: 397,
                                                                                    },
                                                                                    name: "$result",
                                                                                },
                                                                            ),
                                                                        },
                                                                    ],
                                                                    commas: [],
                                                                },
                                                                right_parenthesis: Span {
                                                                    line: 16,
                                                                    column: 43,
                                                                    position: 404,
                                                                },
                                                            },
                                                        },
                                                    ),
                                                ),
                                                semicolon: Span {
                                                    line: 16,
                                                    column: 44,
                                                    position: 405,
                                                },
                                            },
                                        ),
                                    ],
                                    right_brace: Span {
                                        line: 17,
                                        column: 5,
                                        position: 411,
                                    },
                                },
                            },
                        ),
                        ConcreteMethod(
                            ConcreteMethodDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                attributes: [],
                                modifiers: MethodModifierDefinitionGroup {
                                    modifiers: [
                                        Public(
                                            Span {
                                                line: 19,
                                                column: 5,
                                                position: 418,
                                            },
                                        ),
                                    ],
                                },
                                function: Span {
                                    line: 19,
                                    column: 12,
                                    position: 425,
                                },
                                name: Identifier {
                                    span: Span {
                                        line: 19,
                                        column: 21,
                                        position: 434,
                                    },
                                    value: "map",
                                },
                                templates: Some(
                                    TemplateGroupDefinition {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        less_than: Span {
                                            line: 19,
                                            column: 24,
                                            position: 437,
                                        },
                                        members: CommaSeparated {
                                            inner: [
                                                TemplateDefinition {
                                                    variance: Invaraint,
                                                    name: Identifier {
                                                        span: Span {
                                                            line: 19,
                                                            column: 25,
                                                            position: 438,
                                                        },
                                                        value: "Tout",
                                                    },
                                                    constraint: None,
                                                },
                                            ],
                                            commas: [],
                                        },
                                        greater_than: Span {
                                            line: 19,
                                            column: 29,
                                            position: 442,
                                        },
                                    },
                                ),
                                parameters: FunctionLikeParameterListDefinition {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_parenthesis: Span {
                                        line: 19,
                                        column: 30,
                                        position: 443,
                                    },
                                    parameters: CommaSeparated {
                                        inner: [
                                            FunctionLikeParameterDefinition {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                attributes: [],
                                                type_definition: Function {
                                                    outer_left_parenthesis: Span {
                                                        line: 19,
                                                        column: 31,
                                                        position: 444,
                                                    },
                                                    fn: Span {
                                                        line: 19,
                                                        column: 32,
                                                        position: 445,
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 19,
                                                        column: 34,
                                                        position: 447,
                                                    },
                                                    parameter_type_definitions: CommaSeparated {
                                                        inner: [
                                                            Identifier(
                                                                TemplatedIdentifier {
                                                                    name: Identifier {
                                                                        span: Span {
                                                                            line: 19,
                                                                            column: 35,
                                                                            position: 448,
                                                                        },
                                                                        value: "T",
                                                                    },
                                                                    templates: None,
                                                                },
                                                            ),
                                                        ],
                                                        commas: [],
                                                    },
                                                    right_parenthesis: Span {
                                                        line: 19,
                                                        column: 36,
                                                        position: 449,
                                                    },
                                                    colon: Span {
                                                        line: 19,
                                                        column: 37,
                                                        position: 450,
                                                    },
                                                    return_type_definition: Identifier(
                                                        TemplatedIdentifier {
                                                            name: Identifier {
                                                                span: Span {
                                                                    line: 19,
                                                                    column: 39,
                                                                    position: 452,
                                                                },
                                                                value: "Tout",
                                                            },
                                                            templates: None,
                                                        },
                                                    ),
                                                    outer_right_parenthesis: Span {
                                                        line: 19,
                                                        column: 43,
                                                        position: 456,
                                                    },
                                                },
                                                ellipsis: None,
                                                variable: Variable {
                                                    span: Span {
                                                        line: 19,
                                                        column: 45,
                                                        position: 458,
                                                    },
                                                    name: "$func",
                                                },
                                                default: None,
                                            },
                                        ],
                                        commas: [],
                                    },
                                    right_parenthesis: Span {
                                        line: 19,
                                        column: 50,
                                        position: 463,
                                    },
                                },
                                return_type: FunctionLikeReturnTypeDefinition {
                                    colon: Span {
                                        line: 19,
                                        column: 51,
                                        position: 464,
                                    },
                                    type_definition: Identifier(
                                        TemplatedIdentifier {
                                            name: Identifier {
                                                span: Span {
                                                    line: 19,
                                                    column: 53,
                                                    position: 466,
                                                },
                                                value: "Collection",
                                            },
                                            templates: Some(
                                                TypeTemplateGroupDefinition {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    less_than: Span {
                                                        line: 19,
                                                        column: 63,
                                                        position: 476,
                                                    },
                                                    members: CommaSeparated {
                                                        inner: [
                                                            Identifier(
                                                                TemplatedIdentifier {
                                                                    name: Identifier {
                                                                        span: Span {
                                                                            line: 19,
                                                                            column: 64,
                                                                            position: 477,
                                                                        },
                                                                        value: "Tout",
                                                                    },
                                                                    templates: None,
                                                                },
                                                            ),
                                                        ],
                                                        commas: [],
                                                    },
                                                    greater_than: Span {
                                                        line: 19,
                                                        column: 68,
                                                        position: 481,
                                                    },
                                                },
                                            ),
                                        },
                                    ),
                                },
                                constraints: None,
                                body: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: Span {
                                        line: 19,
                                        column: 70,
                                        position: 483,
                                    },
                                    statements: [
                                        Expression(
                                            ExpressionStatement {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                expression: AssignmentOperation(
                                                    Assignment {
                                                        comments: CommentGroup {
                                                            comments: [],
                                                        },
                                                        left: Variable(
                                                            Variable {
                                                                span: Span {
                                                                    line: 20,
                                                                    column: 9,
                                                                    position: 493,
                                                                },
                                                                name: "$result",
                                                            },
                                                        ),
                                                        equals: Span {
                                                            line: 20,
                                                            column: 17,
                                                            position: 501,
                                                        },
                                                        right: Vec(
                                                            VecExpression {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                vec: Span {
                                                                    line: 20,
                                                                    column: 19,
                                                                    position: 503,
                                                                },
                                                                left_bracket: Span {
                                                                    line: 20,
                                                                    column: 22,
                                                                    position: 506,
                                                                },
                                                                members: CommaSeparated {
                                                                    inner: [],
                                                                    commas: [],
                                                                },
                                                                right_bracket: Span {
                                                                    line: 20,
                                                                    column: 23,
                                                                    position: 507,
                                                                },
                                                            },
                                                        ),
                                                    },
                                                ),
                                                semicolon: Span {
                                                    line: 20,
                                                    column: 24,
                                                    position: 508,
                                                },
                                            },
                                        ),
                                        Foreach(
                                            ForeachStatement {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                foreach: Span {
                                                    line: 21,
                                                    column: 9,
                                                    position: 518,
                                                },
                                                iterator: Value {
                                                    expression: ObjectOperation(
                                                        PropertyFetch {
                                                            comments: CommentGroup {
                                                                comments: [],
                                                            },
                                                            object: Variable(
                                                                Variable {
                                                                    span: Span {
                                                                        line: 21,
                                                                        column: 17,
                                                                        position: 526,
                                                                    },
                                                                    name: "$this",
                                                                },
                                                            ),
                                                            arrow: Span {
                                                                line: 21,
                                                                column: 22,
                                                                position: 531,
                                                            },
                                                            property: Identifier {
                                                                span: Span {
                                                                    line: 21,
                                                                    column: 24,
                                                                    position: 533,
                                                                },
                                                                value: "items",
                                                            },
                                                        },
                                                    ),
                                                    as: Span {
                                                        line: 21,
                                                        column: 30,
                                                        position: 539,
                                                    },
                                                    value: Variable {
                                                        span: Span {
                                                            line: 21,
                                                            column: 33,
                                                            position: 542,
                                                        },
                                                        name: "$item",
                                                    },
                                                },
                                                block: BlockStatement {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_brace: Span {
                                                        line: 21,
                                                        column: 39,
                                                        position: 548,
                                                    },
                                                    statements: [
                                                        Expression(
                                                            ExpressionStatement {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                expression: AssignmentOperation(
                                                                    Assignment {
                                                                        comments: CommentGroup {
                                                                            comments: [],
                                                                        },
                                                                        left: ArrayOperation(
                                                                            Push {
                                                                                comments: CommentGroup {
                                                                                    comments: [],
                                                                                },
                                                                                array: Variable(
                                                                                    Variable {
                                                                                        span: Span {
                                                                                            line: 22,
                                                                                            column: 13,
                                                                                            position: 562,
                                                                                        },
                                                                                        name: "$result",
                                                                                    },
                                                                                ),
                                                                                left_bracket: Span {
                                                                                    line: 22,
                                                                                    column: 20,
                                                                                    position: 569,
                                                                                },
                                                                                right_bracket: Span {
                                                                                    line: 22,
                                                                                    column: 21,
                                                                                    position: 570,
                                                                                },
                                                                            },
                                                                        ),
                                                                        equals: Span {
                                                                            line: 22,
                                                                            column: 23,
                                                                            position: 572,
                                                                        },
                                                                        right: FunctionOperation(
                                                                            Call {
                                                                                comments: CommentGroup {
                                                                                    comments: [],
                                                                                },
                                                                                function: Variable(
                                                                                    Variable {
                                                                                        span: Span {
                                                                                            line: 22,
                                                                                            column: 25,
                                                                                            position: 574,
                                                                                        },
                                                                                        name: "$func",
                                                                                    },
                                                                                ),
                                                                                generics: None,
                                                                                arguments: ArgumentListExpression {
                                                                                    comments: CommentGroup {
                                                                                        comments: [],
                                                                                    },
                                                                                    left_parenthesis: Span {
                                                                                        line: 22,
                                                                                        column: 30,
                                                                                        position: 579,
                                                                                    },
                                                                                    arguments: CommaSeparated {
                                                                                        inner: [
                                                                                            Positional {
                                                                                                comments: CommentGroup {
                                                                                                    comments: [],
                                                                                                },
                                                                                                ellipsis: None,
                                                                                                value: Variable(
                                                                                                    Variable {
                                                                                                        span: Span {
                                                                                                            line: 22,
                                                                                                            column: 31,
                                                                                                            position: 580,
                                                                                                        },
                                                                                                        name: "$item",
                                                                                                    },
                                                                                                ),
                                                                                            },
                                                                                        ],
                                                                                        commas: [],
                                                                                    },
                                                                                    right_parenthesis: Span {
                                                                                        line: 22,
                                                                                        column: 36,
                                                                                        position: 585,
                                                                                    },
                                                                                },
                                                                            },
                                                                        ),
                                                                    },
                                                                ),
                                                                semicolon: Span {
                                                                    line: 22,
                                                                    column: 37,
                                                                    position: 586,
                                                                },
                                                            },
                                                        ),
                                                    ],
                                                    right_brace: Span {
                                                        line: 23,
                                                        column: 9,
                                                        position: 596,
                                                    },
                                                },
                                            },
                                        ),
                                        Return(
                                            Explicit {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                return: Span {
                                                    line: 25,
                                                    column: 9,
                                                    position: 607,
                                                },
                                                expression: Some(
                                                    ClassOperation(
                                                        Initialization {
                                                            comments: CommentGroup {
                                                                comments: [],
                                                            },
                                                            new: Span {
                                                                line: 25,
                                                                column: 16,
                                                                position: 614,
                                                            },
                                                            class: Identifier {
                                                                span: Span {
                                                                    line: 25,
                                                                    column: 20,
                                                                    position: 618,
                                                                },
                                                                value: "Collection",
                                                            },
                                                            generics: Some(
                                                                GenericGroupExpression {
                                                                    double_colon_less_than: Span {
                                                                        line: 25,
                                                                        column: 30,
                                                                        position: 628,
                                                                    },
                                                                    types: CommaSeparated {
                                                                        inner: [
                                                                            Identifier(
                                                                                TemplatedIdentifier {
                                                                                    name: Identifier {
                                                                                        span: Span {
                                                                                            line: 25,
                                                                                            column: 33,
                                                                                            position: 631,
                                                                                        },
                                                                                        value: "Tout",
                                                                                    },
                                                                                    templates: None,
                                                                                },
                                                                            ),
                                                                        ],
                                                                        commas: [],
                                                                    },
                                                                    greater_than: Span {
                                                                        line: 25,
                                                                        column: 37,
                                                                        position: 635,
                                                                    },
                                                                },
                                                            ),
                                                            arguments: ArgumentListExpression {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                left_parenthesis: Span {
                                                                    line: 25,
                                                                    column: 38,
                                                                    position: 636,
                                                                },
                                                                arguments: CommaSeparated {
                                                                    inner: [
                                                                        Positional {
                                                                            comments: CommentGroup {
                                                                                comments: [],
                                                                            },
                                                                            ellipsis: None,
                                                                            value: Variable(
                                                                                Variable {
                                                                                    span: Span {
                                                                                        line: 25,
                                                                                        column: 39,
                                                                                        position: 637,
                                                                                    },
                                                                                    name: "$result",
                                                                                },
                                                                            ),
                                                                        },
                                                                    ],
                                                                    commas: [],
                                                                },
                                                                right_parenthesis: Span {
                                                                    line: 25,
                                                                    column: 46,
                                                                    position: 644,
                                                                },
                                                            },
                                                        },
                                                    ),
                                                ),
                                                semicolon: Span {
                                                    line: 25,
                                                    column: 47,
                                                    position: 645,
                                                },
                                            },
                                        ),
                                    ],
                                    right_brace: Span {
                                        line: 26,
                                        column: 5,
                                        position: 651,
                                    },
                                },
                            },
                        ),
                        ConcreteMethod(
                            ConcreteMethodDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                attributes: [],
                                modifiers: MethodModifierDefinitionGroup {
                                    modifiers: [
                                        Public(
                                            Span {
                                                line: 28,
                                                column: 5,
                                                position: 658,
                                            },
                                        ),
                                    ],
                                },
                                function: Span {
                                    line: 28,
                                    column: 12,
                                    position: 665,
                                },
                                name: Identifier {
                                    span: Span {
                                        line: 28,
                                        column: 21,
                                        position: 674,
                                    },
                                    value: "sum",
                                },
                                templates: None,
                                parameters: FunctionLikeParameterListDefinition {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_parenthesis: Span {
                                        line: 28,
                                        column: 24,
                                        position: 677,
                                    },
                                    parameters: CommaSeparated {
                                        inner: [],
                                        commas: [],
                                    },
                                    right_parenthesis: Span {
                                        line: 28,
                                        column: 25,
                                        position: 678,
                                    },
                                },
                                return_type: FunctionLikeReturnTypeDefinition {
                                    colon: Span {
                                        line: 28,
                                        column: 26,
                                        position: 679,
                                    },
                                    type_definition: Integer(
                                        Span {
                                            line: 28,
                                            column: 28,
                                            position: 681,
                                        },
                                    ),
                                },
                                constraints: Some(
                                    MethodDefinitionTypeConstraintGroup {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        where: Span {
                                            line: 28,
                                            column: 32,
                                            position: 685,
                                        },
                                        constraints: CommaSeparated {
                                            inner: [
                                                MethodDefinitionTypeConstraint {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    identifier: Identifier {
                                                        span: Span {
                                                            line: 28,
                                                            column: 38,
                                                            position: 691,
                                                        },
                                                        value: "T",
                                                    },
                                                    is: Span {
                                                        line: 28,
                                                        column: 40,
                                                        position: 693,
                                                    },
                                                    type_definition: Identifier(
                                                        TemplatedIdentifier {
                                                            name: Identifier {
                                                                span: Span {
                                                                    line: 28,
                                                                    column: 43,
                                                                    position: 696,
                                                                },
                                                                value: "num",
                                                            },
                                                            templates: None,
                                                        },
                                                    ),
                                                },
                                            ],
                                            commas: [],
                                        },
                                    },
                                ),
                                body: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: Span {
                                        line: 28,
                                        column: 47,
                                        position: 700,
                                    },
                                    statements: [
                                        Expression(
                                            ExpressionStatement {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                expression: AssignmentOperation(
                                                    Assignment {
                                                        comments: CommentGroup {
                                                            comments: [],
                                                        },
                                                        left: Variable(
                                                            Variable {
                                                                span: Span {
                                                                    line: 29,
                                                                    column: 9,
                                                                    position: 710,
                                                                },
                                                                name: "$result",
                                                            },
                                                        ),
                                                        equals: Span {
                                                            line: 29,
                                                            column: 17,
                                                            position: 718,
                                                        },
                                                        right: Literal(
                                                            Integer(
                                                                LiteralInteger {
                                                                    comments: CommentGroup {
                                                                        comments: [],
                                                                    },
                                                                    value: "0",
                                                                    span: Span {
                                                                        line: 29,
                                                                        column: 19,
                                                                        position: 720,
                                                                    },
                                                                },
                                                            ),
                                                        ),
                                                    },
                                                ),
                                                semicolon: Span {
                                                    line: 29,
                                                    column: 20,
                                                    position: 721,
                                                },
                                            },
                                        ),
                                        Foreach(
                                            ForeachStatement {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                foreach: Span {
                                                    line: 30,
                                                    column: 9,
                                                    position: 731,
                                                },
                                                iterator: Value {
                                                    expression: ObjectOperation(
                                                        PropertyFetch {
                                                            comments: CommentGroup {
                                                                comments: [],
                                                            },
                                                            object: Variable(
                                                                Variable {
                                                                    span: Span {
                                                                        line: 30,
                                                                        column: 17,
                                                                        position: 739,
                                                                    },
                                                                    name: "$this",
                                                                },
                                                            ),
                                                            arrow: Span {
                                                                line: 30,
                                                                column: 22,
                                                                position: 744,
                                                            },
                                                            property: Identifier {
                                                                span: Span {
                                                                    line: 30,
                                                                    column: 24,
                                                                    position: 746,
                                                                },
                                                                value: "items",
                                                            },
                                                        },
                                                    ),
                                                    as: Span {
                                                        line: 30,
                                                        column: 30,
                                                        position: 752,
                                                    },
                                                    value: Variable {
                                                        span: Span {
                                                            line: 30,
                                                            column: 33,
                                                            position: 755,
                                                        },
                                                        name: "$item",
                                                    },
                                                },
                                                block: BlockStatement {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_brace: Span {
                                                        line: 30,
                                                        column: 39,
                                                        position: 761,
                                                    },
                                                    statements: [
                                                        Expression(
                                                            ExpressionStatement {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                expression: AssignmentOperation(
                                                                    Addition {
                                                                        comments: CommentGroup {
                                                                            comments: [],
                                                                        },
                                                                        left: Variable(
                                                                            Variable {
                                                                                span: Span {
                                                                                    line: 31,
                                                                                    column: 13,
                                                                                    position: 775,
                                                                                },
                                                                                name: "$result",
                                                                            },
                                                                        ),
                                                                        plus_equals: Span {
                                                                            line: 31,
                                                                            column: 21,
                                                                            position: 783,
                                                                        },
                                                                        right: Variable(
                                                                            Variable {
                                                                                span: Span {
                                                                                    line: 31,
                                                                                    column: 24,
                                                                                    position: 786,
                                                                                },
                                                                                name: "$item",
                                                                            },
                                                                        ),
                                                                    },
                                                                ),
                                                                semicolon: Span {
                                                                    line: 31,
                                                                    column: 29,
                                                                    position: 791,
                                                                },
                                                            },
                                                        ),
                                                    ],
                                                    right_brace: Span {
                                                        line: 32,
                                                        column: 9,
                                                        position: 801,
                                                    },
                                                },
                                            },
                                        ),
                                        Return(
                                            Implicit {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                expression: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 34,
                                                            column: 9,
                                                            position: 812,
                                                        },
                                                        name: "$result",
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                    right_brace: Span {
                                        line: 35,
                                        column: 5,
                                        position: 824,
                                    },
                                },
                            },
                        ),
                    ],
                    right_brace: Span {
                        line: 36,
                        column: 1,
                        position: 826,
                    },
                },
            },
        ),
        Function(
            FunctionDefinition {
                comments: CommentGroup {
                    comments: [],
                },
                attributes: [],
                function: Span {
                    line: 38,
                    column: 1,
                    position: 829,
                },
                name: Identifier {
                    span: Span {
                        line: 38,
                        column: 10,
                        position: 838,
                    },
                    value: "example",
                },
                templates: None,
                parameters: FunctionLikeParameterListDefinition {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_parenthesis: Span {
                        line: 38,
                        column: 17,
                        position: 845,
                    },
                    parameters: CommaSeparated {
                        inner: [],
                        commas: [],
                    },
                    right_parenthesis: Span {
                        line: 38,
                        column: 18,
                        position: 846,
                    },
                },
                return_type: FunctionLikeReturnTypeDefinition {
                    colon: Span {
                        line: 38,
                        column: 19,
                        position: 847,
                    },
                    type_definition: Integer(
                        Span {
                            line: 38,
                            column: 21,
                            position: 849,
                        },
                    ),
                },
                body: BlockStatement {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_brace: Span {
                        line: 38,
                        column: 25,
                        position: 853,
                    },
                    statements: [
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 39,
                                                    column: 5,
                                                    position: 859,
                                                },
                                                name: "$collection",
                                            },
                                        ),
                                        equals: Span {
                                            line: 39,
                                            column: 17,
                                            position: 871,
                                        },
                                        right: ClassOperation(
                                            Initialization {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                new: Span {
                                                    line: 39,
                                                    column: 19,
                                                    position: 873,
                                                },
                                                class: Identifier {
                                                    span: Span {
                                                        line: 39,
                                                        column: 23,
                                                        position: 877,
                                                    },
                                                    value: "Collection",
                                                },
                                                generics: Some(
                                                    GenericGroupExpression {
                                                        double_colon_less_than: Span {
                                                            line: 39,
                                                            column: 33,
                                                            position: 887,
                                                        },
                                                        types: CommaSeparated {
                                                            inner: [
                                                                Identifier(
                                                                    TemplatedIdentifier {
                                                                        name: Identifier {
                                                                            span: Span {
                                                                                line: 39,
                                                                                column: 36,
                                                                                position: 890,
                                                                            },
                                                                            value: "num",
                                                                        },
                                                                        templates: None,
                                                                    },
                                                                ),
                                                            ],
                                                            commas: [],
                                                        },
                                                        greater_than: Span {
                                                            line: 39,
                                                            column: 39,
                                                            position: 893,
                                                        },
                                                    },
                                                ),
                                                arguments: ArgumentListExpression {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 39,
                                                        column: 40,
                                                        position: 894,
                                                    },
                                                    arguments: CommaSeparated {
                                                        inner: [
                                                            Positional {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                ellipsis: None,
                                                                value: Vec(
                                                                    VecExpression {
                                                                        comments: CommentGroup {
                                                                            comments: [],
                                                                        },
                                                                        vec: Span {
                                                                            line: 39,
                                                                            column: 41,
                                                                            position: 895,
                                                                        },
                                                                        left_bracket: Span {
                                                                            line: 39,
                                                                            column: 44,
                                                                            position: 898,
                                                                        },
                                                                        members: CommaSeparated {
                                                                            inner: [
                                                                                VecExpressionItem {
                                                                                    value: Literal(
                                                                                        Integer(
                                                                                            LiteralInteger {
                                                                                                comments: CommentGroup {
                                                                                                    comments: [],
                                                                                                },
                                                                                                value: "1",
                                                                                                span: Span {
                                                                                                    line: 40,
                                                                                                    column: 9,
                                                                                                    position: 908,
                                                                                                },
                                                                                            },
                                                                                        ),
                                                                                    ),
                                                                                },
                                                                                VecExpressionItem {
                                                                                    value: Literal(
                                                                                        Integer(
                                                                                            LiteralInteger {
                                                                                                comments: CommentGroup {
                                                                                                    comments: [],
                                                                                                },
                                                                                                value: "2",
                                                                                                span: Span {
                                                                                                    line: 40,
                                                                                                    column: 12,
                                                                                                    position: 911,
                                                                                                },
                                                                                            },
                                                                                        ),
                                                                                    ),
                                                                                },
                                                                                VecExpressionItem {
                                                                                    value: Literal(
                                                                                        Float(
                                                                                            LiteralFloat {
                                                                                                comments: CommentGroup {
                                                                                                    comments: [],
                                                                                                },
                                                                                                value: "3.0",
                                                                                                span: Span {
                                                                                                    line: 40,
                                                                                                    column: 15,
                                                                                                    position: 914,
                                                                                                },
                                                                                            },
                                                                                        ),
                                                                                    ),
                                                                                },
                                                                                VecExpressionItem {
                                                                                    value: Literal(
                                                                                        Float(
                                                                                            LiteralFloat {
                                                                                                comments: CommentGroup {
                                                                                                    comments: [],
                                                                                                },
                                                                                                value: "4.0",
                                                                                                span: Span {
                                                                                                    line: 40,
                                                                                                    column: 20,
                                                                                                    position: 919,
                                                                                                },
                                                                                            },
                                                                                        ),
                                                                                    ),
                                                                                },
                                                                                VecExpressionItem {
                                                                                    value: Literal(
                                                                                        Integer(
                                                                                            LiteralInteger {
                                                                                                comments: CommentGroup {
                                                                                                    comments: [],
                                                                                                },
                                                                                                value: "5",
                                                                                                span: Span {
                                                                                                    line: 40,
                                                                                                    column: 25,
                                                                                                    position: 924,
                                                                                                },
                                                                                            },
                                                                                        ),
                                                                                    ),
                                                                                },
                                                                                VecExpressionItem {
                                                                                    value: Literal(
                                                                                        Integer(
                                                                                            LiteralInteger {
                                                                                                comments: CommentGroup {
                                                                                                    comments: [],
                                                                                                },
                                                                                                value: "6",
                                                                                                span: Span {
                                                                                                    line: 40,
                                                                                                    column: 28,
                                                                                                    position: 927,
                                                                                                },
                                                                                            },
                                                                                        ),
                                                                                    ),
                                                                                },
                                                                                VecExpressionItem {
                                                                                    value: Literal(
                                                                                        Float(
                                                                                            LiteralFloat {
                                                                                                comments: CommentGroup {
                                                                                                    comments: [],
                                                                                                },
                                                                                                value: "7.0",
                                                                                                span: Span {
                                                                                                    line: 40,
                                                                                                    column: 31,
                                                                                                    position: 930,
                                                                                                },
                                                                                            },
                                                                                        ),
                                                                                    ),
                                                                                },
                                                                                VecExpressionItem {
                                                                                    value: Literal(
                                                                                        Float(
                                                                                            LiteralFloat {
                                                                                                comments: CommentGroup {
                                                                                                    comments: [],
                                                                                                },
                                                                                                value: "9.0",
                                                                                                span: Span {
                                                                                                    line: 40,
                                                                                                    column: 36,
                                                                                                    position: 935,
                                                                                                },
                                                                                            },
                                                                                        ),
                                                                                    ),
                                                                                },
                                                                                VecExpressionItem {
                                                                                    value: Literal(
                                                                                        Integer(
                                                                                            LiteralInteger {
                                                                                                comments: CommentGroup {
                                                                                                    comments: [],
                                                                                                },
                                                                                                value: "10",
                                                                                                span: Span {
                                                                                                    line: 40,
                                                                                                    column: 41,
                                                                                                    position: 940,
                                                                                                },
                                                                                            },
                                                                                        ),
                                                                                    ),
                                                                                },
                                                                            ],
                                                                            commas: [
                                                                                Span {
                                                                                    line: 40,
                                                                                    column: 10,
                                                                                    position: 909,
                                                                                },
                                                                                Span {
                                                                                    line: 40,
                                                                                    column: 13,
                                                                                    position: 912,
                                                                                },
                                                                                Span {
                                                                                    line: 40,
                                                                                    column: 18,
                                                                                    position: 917,
                                                                                },
                                                                                Span {
                                                                                    line: 40,
                                                                                    column: 23,
                                                                                    position: 922,
                                                                                },
                                                                                Span {
                                                                                    line: 40,
                                                                                    column: 26,
                                                                                    position: 925,
                                                                                },
                                                                                Span {
                                                                                    line: 40,
                                                                                    column: 29,
                                                                                    position: 928,
                                                                                },
                                                                                Span {
                                                                                    line: 40,
                                                                                    column: 34,
                                                                                    position: 933,
                                                                                },
                                                                                Span {
                                                                                    line: 40,
                                                                                    column: 39,
                                                                                    position: 938,
                                                                                },
                                                                            ],
                                                                        },
                                                                        right_bracket: Span {
                                                                            line: 41,
                                                                            column: 5,
                                                                            position: 947,
                                                                        },
                                                                    },
                                                                ),
                                                            },
                                                        ],
                                                        commas: [],
                                                    },
                                                    right_parenthesis: Span {
                                                        line: 41,
                                                        column: 6,
                                                        position: 948,
                                                    },
                                                },
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 41,
                                    column: 7,
                                    position: 949,
                                },
                            },
                        ),
                        Return(
                            Implicit {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: ObjectOperation(
                                    MethodCall {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        object: ObjectOperation(
                                            MethodCall {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                object: ObjectOperation(
                                                    MethodCall {
                                                        comments: CommentGroup {
                                                            comments: [],
                                                        },
                                                        object: Variable(
                                                            Variable {
                                                                span: Span {
                                                                    line: 43,
                                                                    column: 5,
                                                                    position: 956,
                                                                },
                                                                name: "$collection",
                                                            },
                                                        ),
                                                        arrow: Span {
                                                            line: 44,
                                                            column: 7,
                                                            position: 974,
                                                        },
                                                        method: Identifier {
                                                            span: Span {
                                                                line: 44,
                                                                column: 9,
                                                                position: 976,
                                                            },
                                                            value: "filter",
                                                        },
                                                        generics: None,
                                                        arguments: ArgumentListExpression {
                                                            comments: CommentGroup {
                                                                comments: [],
                                                            },
                                                            left_parenthesis: Span {
                                                                line: 44,
                                                                column: 15,
                                                                position: 982,
                                                            },
                                                            arguments: CommaSeparated {
                                                                inner: [
                                                                    Positional {
                                                                        comments: CommentGroup {
                                                                            comments: [],
                                                                        },
                                                                        ellipsis: None,
                                                                        value: ArrowFunction(
                                                                            ArrowFunctionExpression {
                                                                                comments: CommentGroup {
                                                                                    comments: [],
                                                                                },
                                                                                static: None,
                                                                                fn: Span {
                                                                                    line: 44,
                                                                                    column: 16,
                                                                                    position: 983,
                                                                                },
                                                                                attributes: [],
                                                                                parameters: FunctionLikeParameterListDefinition {
                                                                                    comments: CommentGroup {
                                                                                        comments: [],
                                                                                    },
                                                                                    left_parenthesis: Span {
                                                                                        line: 44,
                                                                                        column: 18,
                                                                                        position: 985,
                                                                                    },
                                                                                    parameters: CommaSeparated {
                                                                                        inner: [
                                                                                            FunctionLikeParameterDefinition {
                                                                                                comments: CommentGroup {
                                                                                                    comments: [],
                                                                                                },
                                                                                                attributes: [],
                                                                                                type_definition: Identifier(
                                                                                                    TemplatedIdentifier {
                                                                                                        name: Identifier {
                                                                                                            span: Span {
                                                                                                                line: 44,
                                                                                                                column: 19,
                                                                                                                position: 986,
                                                                                                            },
                                                                                                            value: "num",
                                                                                                        },
                                                                                                        templates: None,
                                                                                                    },
                                                                                                ),
                                                                                                ellipsis: None,
                                                                                                variable: Variable {
                                                                                                    span: Span {
                                                                                                        line: 44,
                                                                                                        column: 23,
                                                                                                        position: 990,
                                                                                                    },
                                                                                                    name: "$n",
                                                                                                },
                                                                                                default: None,
                                                                                            },
                                                                                        ],
                                                                                        commas: [],
                                                                                    },
                                                                                    right_parenthesis: Span {
                                                                                        line: 44,
                                                                                        column: 25,
                                                                                        position: 992,
                                                                                    },
                                                                                },
                                                                                return_type: FunctionLikeReturnTypeDefinition {
                                                                                    colon: Span {
                                                                                        line: 44,
                                                                                        column: 26,
                                                                                        position: 993,
                                                                                    },
                                                                                    type_definition: Boolean(
                                                                                        Span {
                                                                                            line: 44,
                                                                                            column: 28,
                                                                                            position: 995,
                                                                                        },
                                                                                    ),
                                                                                },
                                                                                double_arrow: Span {
                                                                                    line: 44,
                                                                                    column: 33,
                                                                                    position: 1000,
                                                                                },
                                                                                body: ComparisonOperation(
                                                                                    LessThan {
                                                                                        comments: CommentGroup {
                                                                                            comments: [],
                                                                                        },
                                                                                        left: Variable(
                                                                                            Variable {
                                                                                                span: Span {
                                                                                                    line: 44,
                                                                                                    column: 36,
                                                                                                    position: 1003,
                                                                                                },
                                                                                                name: "$n",
                                                                                            },
                                                                                        ),
                                                                                        less_than: Span {
                                                                                            line: 44,
                                                                                            column: 39,
                                                                                            position: 1006,
                                                                                        },
                                                                                        right: Literal(
                                                                                            Integer(
                                                                                                LiteralInteger {
                                                                                                    comments: CommentGroup {
                                                                                                        comments: [],
                                                                                                    },
                                                                                                    value: "8",
                                                                                                    span: Span {
                                                                                                        line: 44,
                                                                                                        column: 41,
                                                                                                        position: 1008,
                                                                                                    },
                                                                                                },
                                                                                            ),
                                                                                        ),
                                                                                    },
                                                                                ),
                                                                            },
                                                                        ),
                                                                    },
                                                                ],
                                                                commas: [],
                                                            },
                                                            right_parenthesis: Span {
                                                                line: 44,
                                                                column: 42,
                                                                position: 1009,
                                                            },
                                                        },
                                                    },
                                                ),
                                                arrow: Span {
                                                    line: 45,
                                                    column: 7,
                                                    position: 1017,
                                                },
                                                method: Identifier {
                                                    span: Span {
                                                        line: 45,
                                                        column: 9,
                                                        position: 1019,
                                                    },
                                                    value: "map",
                                                },
                                                generics: Some(
                                                    GenericGroupExpression {
                                                        double_colon_less_than: Span {
                                                            line: 45,
                                                            column: 12,
                                                            position: 1022,
                                                        },
                                                        types: CommaSeparated {
                                                            inner: [
                                                                Float(
                                                                    Span {
                                                                        line: 45,
                                                                        column: 15,
                                                                        position: 1025,
                                                                    },
                                                                ),
                                                            ],
                                                            commas: [],
                                                        },
                                                        greater_than: Span {
                                                            line: 45,
                                                            column: 20,
                                                            position: 1030,
                                                        },
                                                    },
                                                ),
                                                arguments: ArgumentListExpression {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 45,
                                                        column: 21,
                                                        position: 1031,
                                                    },
                                                    arguments: CommaSeparated {
                                                        inner: [
                                                            Positional {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                ellipsis: None,
                                                                value: ArrowFunction(
                                                                    ArrowFunctionExpression {
                                                                        comments: CommentGroup {
                                                                            comments: [],
                                                                        },
                                                                        static: None,
                                                                        fn: Span {
                                                                            line: 46,
                                                                            column: 9,
                                                                            position: 1041,
                                                                        },
                                                                        attributes: [],
                                                                        parameters: FunctionLikeParameterListDefinition {
                                                                            comments: CommentGroup {
                                                                                comments: [],
                                                                            },
                                                                            left_parenthesis: Span {
                                                                                line: 46,
                                                                                column: 11,
                                                                                position: 1043,
                                                                            },
                                                                            parameters: CommaSeparated {
                                                                                inner: [
                                                                                    FunctionLikeParameterDefinition {
                                                                                        comments: CommentGroup {
                                                                                            comments: [],
                                                                                        },
                                                                                        attributes: [],
                                                                                        type_definition: Identifier(
                                                                                            TemplatedIdentifier {
                                                                                                name: Identifier {
                                                                                                    span: Span {
                                                                                                        line: 46,
                                                                                                        column: 12,
                                                                                                        position: 1044,
                                                                                                    },
                                                                                                    value: "num",
                                                                                                },
                                                                                                templates: None,
                                                                                            },
                                                                                        ),
                                                                                        ellipsis: None,
                                                                                        variable: Variable {
                                                                                            span: Span {
                                                                                                line: 46,
                                                                                                column: 16,
                                                                                                position: 1048,
                                                                                            },
                                                                                            name: "$n",
                                                                                        },
                                                                                        default: None,
                                                                                    },
                                                                                ],
                                                                                commas: [],
                                                                            },
                                                                            right_parenthesis: Span {
                                                                                line: 46,
                                                                                column: 18,
                                                                                position: 1050,
                                                                            },
                                                                        },
                                                                        return_type: FunctionLikeReturnTypeDefinition {
                                                                            colon: Span {
                                                                                line: 46,
                                                                                column: 19,
                                                                                position: 1051,
                                                                            },
                                                                            type_definition: Float(
                                                                                Span {
                                                                                    line: 46,
                                                                                    column: 21,
                                                                                    position: 1053,
                                                                                },
                                                                            ),
                                                                        },
                                                                        double_arrow: Span {
                                                                            line: 46,
                                                                            column: 27,
                                                                            position: 1059,
                                                                        },
                                                                        body: TernaryOperation(
                                                                            Ternary {
                                                                                comments: CommentGroup {
                                                                                    comments: [],
                                                                                },
                                                                                condition: TypeOperation(
                                                                                    Is {
                                                                                        comments: CommentGroup {
                                                                                            comments: [],
                                                                                        },
                                                                                        left: Variable(
                                                                                            Variable {
                                                                                                span: Span {
                                                                                                    line: 46,
                                                                                                    column: 30,
                                                                                                    position: 1062,
                                                                                                },
                                                                                                name: "$n",
                                                                                            },
                                                                                        ),
                                                                                        is: Span {
                                                                                            line: 46,
                                                                                            column: 33,
                                                                                            position: 1065,
                                                                                        },
                                                                                        right: Float(
                                                                                            Span {
                                                                                                line: 46,
                                                                                                column: 36,
                                                                                                position: 1068,
                                                                                            },
                                                                                        ),
                                                                                    },
                                                                                ),
                                                                                question: Span {
                                                                                    line: 46,
                                                                                    column: 42,
                                                                                    position: 1074,
                                                                                },
                                                                                if_true: Variable(
                                                                                    Variable {
                                                                                        span: Span {
                                                                                            line: 46,
                                                                                            column: 44,
                                                                                            position: 1076,
                                                                                        },
                                                                                        name: "$n",
                                                                                    },
                                                                                ),
                                                                                colon: Span {
                                                                                    line: 46,
                                                                                    column: 47,
                                                                                    position: 1079,
                                                                                },
                                                                                if_false: ArithmeticOperation(
                                                                                    Addition {
                                                                                        comments: CommentGroup {
                                                                                            comments: [],
                                                                                        },
                                                                                        left: Variable(
                                                                                            Variable {
                                                                                                span: Span {
                                                                                                    line: 46,
                                                                                                    column: 49,
                                                                                                    position: 1081,
                                                                                                },
                                                                                                name: "$n",
                                                                                            },
                                                                                        ),
                                                                                        plus: Span {
                                                                                            line: 46,
                                                                                            column: 52,
                                                                                            position: 1084,
                                                                                        },
                                                                                        right: Literal(
                                                                                            Float(
                                                                                                LiteralFloat {
                                                                                                    comments: CommentGroup {
                                                                                                        comments: [],
                                                                                                    },
                                                                                                    value: "0.0",
                                                                                                    span: Span {
                                                                                                        line: 46,
                                                                                                        column: 54,
                                                                                                        position: 1086,
                                                                                                    },
                                                                                                },
                                                                                            ),
                                                                                        ),
                                                                                    },
                                                                                ),
                                                                            },
                                                                        ),
                                                                    },
                                                                ),
                                                            },
                                                        ],
                                                        commas: [],
                                                    },
                                                    right_parenthesis: Span {
                                                        line: 47,
                                                        column: 7,
                                                        position: 1096,
                                                    },
                                                },
                                            },
                                        ),
                                        arrow: Span {
                                            line: 48,
                                            column: 7,
                                            position: 1104,
                                        },
                                        method: Identifier {
                                            span: Span {
                                                line: 48,
                                                column: 9,
                                                position: 1106,
                                            },
                                            value: "sum",
                                        },
                                        generics: None,
                                        arguments: ArgumentListExpression {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            left_parenthesis: Span {
                                                line: 48,
                                                column: 12,
                                                position: 1109,
                                            },
                                            arguments: CommaSeparated {
                                                inner: [],
                                                commas: [],
                                            },
                                            right_parenthesis: Span {
                                                line: 48,
                                                column: 13,
                                                position: 1110,
                                            },
                                        },
                                    },
                                ),
                            },
                        ),
                    ],
                    right_brace: Span {
                        line: 49,
                        column: 1,
                        position: 1112,
                    },
                },
            },
        ),
    ],
    eof: Span {
        line: 50,
        column: 1,
        position: 1114,
    },
}