DefinitionTree {
    definitions: [
        TypeAlias(
            TypeAliasDefinition {
                type: 0,
                name: TemplatedIdentifier {
                    name: Identifier {
                        position: 5,
                        value: "Predicate",
                    },
                    templates: Some(
                        TypeTemplateGroupDefinition {
                            comments: CommentGroup {
                                comments: [],
                            },
                            less_than: 14,
                            members: CommaSeparated {
                                inner: [
                                    Identifier(
                                        TemplatedIdentifier {
                                            name: Identifier {
                                                position: 15,
                                                value: "T",
                                            },
                                            templates: None,
                                        },
                                    ),
                                ],
                                commas: [],
                            },
                            greater_than: 16,
                        },
                    ),
                },
                equals: 18,
                data_type: Function {
                    outer_left_parenthesis: 20,
                    fn: 21,
                    left_parenthesis: 23,
                    parameter_type_definitions: CommaSeparated {
                        inner: [
                            Identifier(
                                TemplatedIdentifier {
                                    name: Identifier {
                                        position: 24,
                                        value: "T",
                                    },
                                    templates: None,
                                },
                            ),
                        ],
                        commas: [],
                    },
                    right_parenthesis: 25,
                    colon: 26,
                    return_type_definition: Boolean(
                        28,
                    ),
                    outer_right_parenthesis: 32,
                },
                semicolon: 33,
            },
        ),
        Function(
            FunctionDefinition {
                comments: CommentGroup {
                    comments: [],
                },
                attributes: [],
                function: 36,
                name: Identifier {
                    position: 45,
                    value: "filter",
                },
                templates: Some(
                    TemplateGroupDefinition {
                        comments: CommentGroup {
                            comments: [],
                        },
                        less_than: 51,
                        members: CommaSeparated {
                            inner: [
                                TemplateDefinition {
                                    variance: Invaraint,
                                    name: Identifier {
                                        position: 52,
                                        value: "T",
                                    },
                                    constraint: None,
                                },
                            ],
                            commas: [],
                        },
                        greater_than: 53,
                    },
                ),
                parameters: FunctionLikeParameterListDefinition {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_parenthesis: 54,
                    parameters: CommaSeparated {
                        inner: [
                            FunctionLikeParameterDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                attributes: [],
                                type_definition: Vec(
                                    55,
                                    TypeTemplateGroupDefinition {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        less_than: 58,
                                        members: CommaSeparated {
                                            inner: [
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 59,
                                                            value: "T",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                            ],
                                            commas: [],
                                        },
                                        greater_than: 60,
                                    },
                                ),
                                ellipsis: None,
                                variable: Variable {
                                    position: 62,
                                    name: "$vec",
                                },
                                default: None,
                            },
                            FunctionLikeParameterDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                attributes: [],
                                type_definition: Identifier(
                                    TemplatedIdentifier {
                                        name: Identifier {
                                            position: 68,
                                            value: "Predicate",
                                        },
                                        templates: Some(
                                            TypeTemplateGroupDefinition {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                less_than: 77,
                                                members: CommaSeparated {
                                                    inner: [
                                                        Identifier(
                                                            TemplatedIdentifier {
                                                                name: Identifier {
                                                                    position: 78,
                                                                    value: "T",
                                                                },
                                                                templates: None,
                                                            },
                                                        ),
                                                    ],
                                                    commas: [],
                                                },
                                                greater_than: 79,
                                            },
                                        ),
                                    },
                                ),
                                ellipsis: None,
                                variable: Variable {
                                    position: 81,
                                    name: "$predicate",
                                },
                                default: None,
                            },
                        ],
                        commas: [
                            66,
                        ],
                    },
                    right_parenthesis: 91,
                },
                return_type: FunctionLikeReturnTypeDefinition {
                    colon: 92,
                    type_definition: Vec(
                        94,
                        TypeTemplateGroupDefinition {
                            comments: CommentGroup {
                                comments: [],
                            },
                            less_than: 97,
                            members: CommaSeparated {
                                inner: [
                                    Identifier(
                                        TemplatedIdentifier {
                                            name: Identifier {
                                                position: 98,
                                                value: "T",
                                            },
                                            templates: None,
                                        },
                                    ),
                                ],
                                commas: [],
                            },
                            greater_than: 99,
                        },
                    ),
                },
                body: BlockStatement {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_brace: 101,
                    statements: [
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                position: 107,
                                                name: "$result",
                                            },
                                        ),
                                        equals: 115,
                                        right: Vec(
                                            VecExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                vec: 117,
                                                left_bracket: 120,
                                                elements: CommaSeparated {
                                                    inner: [],
                                                    commas: [],
                                                },
                                                right_bracket: 121,
                                            },
                                        ),
                                    },
                                ),
                                semicolon: 122,
                            },
                        ),
                        Foreach(
                            ForeachStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                foreach: 128,
                                iterator: Value {
                                    expression: Variable(
                                        Variable {
                                            position: 136,
                                            name: "$vec",
                                        },
                                    ),
                                    as: 141,
                                    value: Variable {
                                        position: 144,
                                        name: "$item",
                                    },
                                },
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 150,
                                    statements: [
                                        If(
                                            IfStatement {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                if: 160,
                                                condition: FunctionOperation(
                                                    Call {
                                                        comments: CommentGroup {
                                                            comments: [],
                                                        },
                                                        function: Variable(
                                                            Variable {
                                                                position: 163,
                                                                name: "$predicate",
                                                            },
                                                        ),
                                                        generics: None,
                                                        arguments: ArgumentListExpression {
                                                            comments: CommentGroup {
                                                                comments: [],
                                                            },
                                                            left_parenthesis: 173,
                                                            arguments: CommaSeparated {
                                                                inner: [
                                                                    Positional {
                                                                        comments: CommentGroup {
                                                                            comments: [],
                                                                        },
                                                                        ellipsis: None,
                                                                        value: Variable(
                                                                            Variable {
                                                                                position: 174,
                                                                                name: "$item",
                                                                            },
                                                                        ),
                                                                    },
                                                                ],
                                                                commas: [],
                                                            },
                                                            right_parenthesis: 179,
                                                        },
                                                    },
                                                ),
                                                block: BlockStatement {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_brace: 181,
                                                    statements: [
                                                        Expression(
                                                            ExpressionStatement {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                expression: AssignmentOperation(
                                                                    Assignment {
                                                                        comments: CommentGroup {
                                                                            comments: [],
                                                                        },
                                                                        left: ArrayOperation(
                                                                            Push {
                                                                                comments: CommentGroup {
                                                                                    comments: [],
                                                                                },
                                                                                array: Variable(
                                                                                    Variable {
                                                                                        position: 195,
                                                                                        name: "$result",
                                                                                    },
                                                                                ),
                                                                                left_bracket: 202,
                                                                                right_bracket: 203,
                                                                            },
                                                                        ),
                                                                        equals: 205,
                                                                        right: Variable(
                                                                            Variable {
                                                                                position: 207,
                                                                                name: "$item",
                                                                            },
                                                                        ),
                                                                    },
                                                                ),
                                                                semicolon: 212,
                                                            },
                                                        ),
                                                    ],
                                                    right_brace: 222,
                                                },
                                                elseifs: [],
                                                else: None,
                                            },
                                        ),
                                    ],
                                    right_brace: 228,
                                },
                            },
                        ),
                        Return(
                            Explicit {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                return: 235,
                                expression: Some(
                                    Variable(
                                        Variable {
                                            position: 242,
                                            name: "$result",
                                        },
                                    ),
                                ),
                                semicolon: 249,
                            },
                        ),
                    ],
                    right_brace: 251,
                },
            },
        ),
        TypeAlias(
            TypeAliasDefinition {
                type: 254,
                name: TemplatedIdentifier {
                    name: Identifier {
                        position: 259,
                        value: "Mapper",
                    },
                    templates: Some(
                        TypeTemplateGroupDefinition {
                            comments: CommentGroup {
                                comments: [],
                            },
                            less_than: 265,
                            members: CommaSeparated {
                                inner: [
                                    Identifier(
                                        TemplatedIdentifier {
                                            name: Identifier {
                                                position: 266,
                                                value: "K",
                                            },
                                            templates: None,
                                        },
                                    ),
                                    Identifier(
                                        TemplatedIdentifier {
                                            name: Identifier {
                                                position: 269,
                                                value: "V",
                                            },
                                            templates: None,
                                        },
                                    ),
                                    Identifier(
                                        TemplatedIdentifier {
                                            name: Identifier {
                                                position: 272,
                                                value: "U",
                                            },
                                            templates: None,
                                        },
                                    ),
                                ],
                                commas: [
                                    267,
                                    270,
                                ],
                            },
                            greater_than: 273,
                        },
                    ),
                },
                equals: 275,
                data_type: Union(
                    [
                        Function {
                            outer_left_parenthesis: 277,
                            fn: 278,
                            left_parenthesis: 280,
                            parameter_type_definitions: CommaSeparated {
                                inner: [
                                    Identifier(
                                        TemplatedIdentifier {
                                            name: Identifier {
                                                position: 281,
                                                value: "K",
                                            },
                                            templates: None,
                                        },
                                    ),
                                    Identifier(
                                        TemplatedIdentifier {
                                            name: Identifier {
                                                position: 284,
                                                value: "V",
                                            },
                                            templates: None,
                                        },
                                    ),
                                ],
                                commas: [
                                    282,
                                ],
                            },
                            right_parenthesis: 285,
                            colon: 286,
                            return_type_definition: Identifier(
                                TemplatedIdentifier {
                                    name: Identifier {
                                        position: 288,
                                        value: "U",
                                    },
                                    templates: None,
                                },
                            ),
                            outer_right_parenthesis: 289,
                        },
                        Identifier(
                            TemplatedIdentifier {
                                name: Identifier {
                                    position: 291,
                                    value: "SomeOtherType",
                                },
                                templates: Some(
                                    TypeTemplateGroupDefinition {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        less_than: 304,
                                        members: CommaSeparated {
                                            inner: [
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 305,
                                                            value: "K",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 308,
                                                            value: "V",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 311,
                                                            value: "U",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                            ],
                                            commas: [
                                                306,
                                                309,
                                            ],
                                        },
                                        greater_than: 312,
                                    },
                                ),
                            },
                        ),
                    ],
                ),
                semicolon: 313,
            },
        ),
        Function(
            FunctionDefinition {
                comments: CommentGroup {
                    comments: [],
                },
                attributes: [],
                function: 316,
                name: Identifier {
                    position: 325,
                    value: "map",
                },
                templates: Some(
                    TemplateGroupDefinition {
                        comments: CommentGroup {
                            comments: [],
                        },
                        less_than: 328,
                        members: CommaSeparated {
                            inner: [
                                TemplateDefinition {
                                    variance: Invaraint,
                                    name: Identifier {
                                        position: 329,
                                        value: "K",
                                    },
                                    constraint: None,
                                },
                                TemplateDefinition {
                                    variance: Invaraint,
                                    name: Identifier {
                                        position: 332,
                                        value: "V",
                                    },
                                    constraint: None,
                                },
                                TemplateDefinition {
                                    variance: Invaraint,
                                    name: Identifier {
                                        position: 335,
                                        value: "U",
                                    },
                                    constraint: None,
                                },
                            ],
                            commas: [
                                330,
                                333,
                            ],
                        },
                        greater_than: 336,
                    },
                ),
                parameters: FunctionLikeParameterListDefinition {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_parenthesis: 337,
                    parameters: CommaSeparated {
                        inner: [
                            FunctionLikeParameterDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                attributes: [],
                                type_definition: Dict(
                                    338,
                                    TypeTemplateGroupDefinition {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        less_than: 342,
                                        members: CommaSeparated {
                                            inner: [
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 343,
                                                            value: "K",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 346,
                                                            value: "V",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                            ],
                                            commas: [
                                                344,
                                            ],
                                        },
                                        greater_than: 347,
                                    },
                                ),
                                ellipsis: None,
                                variable: Variable {
                                    position: 349,
                                    name: "$dict",
                                },
                                default: None,
                            },
                            FunctionLikeParameterDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                attributes: [],
                                type_definition: Identifier(
                                    TemplatedIdentifier {
                                        name: Identifier {
                                            position: 356,
                                            value: "Mapper",
                                        },
                                        templates: Some(
                                            TypeTemplateGroupDefinition {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                less_than: 362,
                                                members: CommaSeparated {
                                                    inner: [
                                                        Identifier(
                                                            TemplatedIdentifier {
                                                                name: Identifier {
                                                                    position: 363,
                                                                    value: "K",
                                                                },
                                                                templates: None,
                                                            },
                                                        ),
                                                        Identifier(
                                                            TemplatedIdentifier {
                                                                name: Identifier {
                                                                    position: 366,
                                                                    value: "V",
                                                                },
                                                                templates: None,
                                                            },
                                                        ),
                                                        Identifier(
                                                            TemplatedIdentifier {
                                                                name: Identifier {
                                                                    position: 369,
                                                                    value: "U",
                                                                },
                                                                templates: None,
                                                            },
                                                        ),
                                                    ],
                                                    commas: [
                                                        364,
                                                        367,
                                                    ],
                                                },
                                                greater_than: 370,
                                            },
                                        ),
                                    },
                                ),
                                ellipsis: None,
                                variable: Variable {
                                    position: 372,
                                    name: "$mapper",
                                },
                                default: None,
                            },
                        ],
                        commas: [
                            354,
                        ],
                    },
                    right_parenthesis: 379,
                },
                return_type: FunctionLikeReturnTypeDefinition {
                    colon: 380,
                    type_definition: Dict(
                        382,
                        TypeTemplateGroupDefinition {
                            comments: CommentGroup {
                                comments: [],
                            },
                            less_than: 386,
                            members: CommaSeparated {
                                inner: [
                                    Identifier(
                                        TemplatedIdentifier {
                                            name: Identifier {
                                                position: 387,
                                                value: "K",
                                            },
                                            templates: None,
                                        },
                                    ),
                                    Identifier(
                                        TemplatedIdentifier {
                                            name: Identifier {
                                                position: 390,
                                                value: "U",
                                            },
                                            templates: None,
                                        },
                                    ),
                                ],
                                commas: [
                                    388,
                                ],
                            },
                            greater_than: 391,
                        },
                    ),
                },
                body: BlockStatement {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_brace: 393,
                    statements: [
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                position: 399,
                                                name: "$result",
                                            },
                                        ),
                                        equals: 407,
                                        right: Dict(
                                            DictExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                dict: 409,
                                                left_bracket: 413,
                                                elements: CommaSeparated {
                                                    inner: [],
                                                    commas: [],
                                                },
                                                right_bracket: 414,
                                            },
                                        ),
                                    },
                                ),
                                semicolon: 415,
                            },
                        ),
                        If(
                            IfStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                if: 421,
                                condition: TypeOperation(
                                    Is {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                position: 424,
                                                name: "$mapper",
                                            },
                                        ),
                                        is: 432,
                                        right: Identifier(
                                            TemplatedIdentifier {
                                                name: Identifier {
                                                    position: 435,
                                                    value: "SomeOtherType",
                                                },
                                                templates: Some(
                                                    TypeTemplateGroupDefinition {
                                                        comments: CommentGroup {
                                                            comments: [],
                                                        },
                                                        less_than: 448,
                                                        members: CommaSeparated {
                                                            inner: [
                                                                Identifier(
                                                                    TemplatedIdentifier {
                                                                        name: Identifier {
                                                                            position: 449,
                                                                            value: "K",
                                                                        },
                                                                        templates: None,
                                                                    },
                                                                ),
                                                                Identifier(
                                                                    TemplatedIdentifier {
                                                                        name: Identifier {
                                                                            position: 452,
                                                                            value: "V",
                                                                        },
                                                                        templates: None,
                                                                    },
                                                                ),
                                                                Identifier(
                                                                    TemplatedIdentifier {
                                                                        name: Identifier {
                                                                            position: 455,
                                                                            value: "U",
                                                                        },
                                                                        templates: None,
                                                                    },
                                                                ),
                                                            ],
                                                            commas: [
                                                                450,
                                                                453,
                                                            ],
                                                        },
                                                        greater_than: 456,
                                                    },
                                                ),
                                            },
                                        ),
                                    },
                                ),
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 458,
                                    statements: [
                                        Foreach(
                                            ForeachStatement {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                foreach: 468,
                                                iterator: KeyAndValue {
                                                    expression: Variable(
                                                        Variable {
                                                            position: 476,
                                                            name: "$dict",
                                                        },
                                                    ),
                                                    as: 482,
                                                    key: Variable {
                                                        position: 485,
                                                        name: "$key",
                                                    },
                                                    double_arrow: 490,
                                                    value: Variable {
                                                        position: 493,
                                                        name: "$value",
                                                    },
                                                },
                                                block: BlockStatement {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_brace: 500,
                                                    statements: [
                                                        Expression(
                                                            ExpressionStatement {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                expression: AssignmentOperation(
                                                                    Assignment {
                                                                        comments: CommentGroup {
                                                                            comments: [],
                                                                        },
                                                                        left: ArrayOperation(
                                                                            Access {
                                                                                comments: CommentGroup {
                                                                                    comments: [],
                                                                                },
                                                                                array: Variable(
                                                                                    Variable {
                                                                                        position: 514,
                                                                                        name: "$result",
                                                                                    },
                                                                                ),
                                                                                left_bracket: 521,
                                                                                index: Variable(
                                                                                    Variable {
                                                                                        position: 522,
                                                                                        name: "$key",
                                                                                    },
                                                                                ),
                                                                                right_bracket: 526,
                                                                            },
                                                                        ),
                                                                        equals: 528,
                                                                        right: ObjectOperation(
                                                                            MethodCall {
                                                                                comments: CommentGroup {
                                                                                    comments: [],
                                                                                },
                                                                                object: Variable(
                                                                                    Variable {
                                                                                        position: 530,
                                                                                        name: "$mapper",
                                                                                    },
                                                                                ),
                                                                                arrow: 537,
                                                                                method: Identifier {
                                                                                    position: 539,
                                                                                    value: "doMap",
                                                                                },
                                                                                generics: None,
                                                                                arguments: ArgumentListExpression {
                                                                                    comments: CommentGroup {
                                                                                        comments: [],
                                                                                    },
                                                                                    left_parenthesis: 544,
                                                                                    arguments: CommaSeparated {
                                                                                        inner: [
                                                                                            Positional {
                                                                                                comments: CommentGroup {
                                                                                                    comments: [],
                                                                                                },
                                                                                                ellipsis: None,
                                                                                                value: Variable(
                                                                                                    Variable {
                                                                                                        position: 545,
                                                                                                        name: "$key",
                                                                                                    },
                                                                                                ),
                                                                                            },
                                                                                            Positional {
                                                                                                comments: CommentGroup {
                                                                                                    comments: [],
                                                                                                },
                                                                                                ellipsis: None,
                                                                                                value: Variable(
                                                                                                    Variable {
                                                                                                        position: 551,
                                                                                                        name: "$value",
                                                                                                    },
                                                                                                ),
                                                                                            },
                                                                                        ],
                                                                                        commas: [
                                                                                            549,
                                                                                        ],
                                                                                    },
                                                                                    right_parenthesis: 557,
                                                                                },
                                                                            },
                                                                        ),
                                                                    },
                                                                ),
                                                                semicolon: 558,
                                                            },
                                                        ),
                                                    ],
                                                    right_brace: 568,
                                                },
                                            },
                                        ),
                                    ],
                                    right_brace: 574,
                                },
                                elseifs: [],
                                else: Some(
                                    IfStatementElse {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        else: 576,
                                        block: Block(
                                            BlockStatement {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                left_brace: 581,
                                                statements: [
                                                    Foreach(
                                                        ForeachStatement {
                                                            comments: CommentGroup {
                                                                comments: [],
                                                            },
                                                            foreach: 591,
                                                            iterator: KeyAndValue {
                                                                expression: Variable(
                                                                    Variable {
                                                                        position: 599,
                                                                        name: "$dict",
                                                                    },
                                                                ),
                                                                as: 605,
                                                                key: Variable {
                                                                    position: 608,
                                                                    name: "$key",
                                                                },
                                                                double_arrow: 613,
                                                                value: Variable {
                                                                    position: 616,
                                                                    name: "$value",
                                                                },
                                                            },
                                                            block: BlockStatement {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                left_brace: 623,
                                                                statements: [
                                                                    Expression(
                                                                        ExpressionStatement {
                                                                            comments: CommentGroup {
                                                                                comments: [],
                                                                            },
                                                                            expression: AssignmentOperation(
                                                                                Assignment {
                                                                                    comments: CommentGroup {
                                                                                        comments: [],
                                                                                    },
                                                                                    left: ArrayOperation(
                                                                                        Access {
                                                                                            comments: CommentGroup {
                                                                                                comments: [],
                                                                                            },
                                                                                            array: Variable(
                                                                                                Variable {
                                                                                                    position: 637,
                                                                                                    name: "$result",
                                                                                                },
                                                                                            ),
                                                                                            left_bracket: 644,
                                                                                            index: Variable(
                                                                                                Variable {
                                                                                                    position: 645,
                                                                                                    name: "$key",
                                                                                                },
                                                                                            ),
                                                                                            right_bracket: 649,
                                                                                        },
                                                                                    ),
                                                                                    equals: 651,
                                                                                    right: FunctionOperation(
                                                                                        Call {
                                                                                            comments: CommentGroup {
                                                                                                comments: [],
                                                                                            },
                                                                                            function: Variable(
                                                                                                Variable {
                                                                                                    position: 653,
                                                                                                    name: "$mapper",
                                                                                                },
                                                                                            ),
                                                                                            generics: None,
                                                                                            arguments: ArgumentListExpression {
                                                                                                comments: CommentGroup {
                                                                                                    comments: [],
                                                                                                },
                                                                                                left_parenthesis: 660,
                                                                                                arguments: CommaSeparated {
                                                                                                    inner: [
                                                                                                        Positional {
                                                                                                            comments: CommentGroup {
                                                                                                                comments: [],
                                                                                                            },
                                                                                                            ellipsis: None,
                                                                                                            value: Variable(
                                                                                                                Variable {
                                                                                                                    position: 661,
                                                                                                                    name: "$key",
                                                                                                                },
                                                                                                            ),
                                                                                                        },
                                                                                                        Positional {
                                                                                                            comments: CommentGroup {
                                                                                                                comments: [],
                                                                                                            },
                                                                                                            ellipsis: None,
                                                                                                            value: Variable(
                                                                                                                Variable {
                                                                                                                    position: 667,
                                                                                                                    name: "$value",
                                                                                                                },
                                                                                                            ),
                                                                                                        },
                                                                                                    ],
                                                                                                    commas: [
                                                                                                        665,
                                                                                                    ],
                                                                                                },
                                                                                                right_parenthesis: 673,
                                                                                            },
                                                                                        },
                                                                                    ),
                                                                                },
                                                                            ),
                                                                            semicolon: 674,
                                                                        },
                                                                    ),
                                                                ],
                                                                right_brace: 684,
                                                            },
                                                        },
                                                    ),
                                                ],
                                                right_brace: 690,
                                            },
                                        ),
                                    },
                                ),
                            },
                        ),
                        Return(
                            Explicit {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                return: 697,
                                expression: Some(
                                    Variable(
                                        Variable {
                                            position: 704,
                                            name: "$result",
                                        },
                                    ),
                                ),
                                semicolon: 711,
                            },
                        ),
                    ],
                    right_brace: 713,
                },
            },
        ),
    ],
    eof: 715,
}