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